Karpathy Called Vibe Coding 'Passé' — Here's What He Replaced It With, and Why It Matters for Your Workflow
By EndOfCoding
On April 1, 2026 — not a joke, he was direct about that — Andrej Karpathy posted that vibe coding is 'passé' and introduced what he called 'agentic engineering' as the paradigm that replaces it. This is significant for two reasons. First, Karpathy coined vibe coding in February 2023 — watching the author of a movement declare it outdated is rare and worth examining carefully. Second, his description of agentic engineering is a precise and useful specification of what expert AI-assisted development actually looks like right now, which means it's the most accurate map we have of where the field is heading. The short version of his framing: vibe coding is casual, exploratory, and human-steered; agentic engineering is deliberate, systematic, and human-architected but AI-executed. Vibe coding is what you do when you're prototyping alone on a weekend. Agentic engineering is what you do when you're building software that has to work reliably at scale. Karpathy's argument is that the tools are now capable enough that the casual framing does them a disservice — and that developers who treat AI assistants as casual autocomplete are leaving most of the capability on the table. This post breaks down exactly what he means, what it looks like in practice, and what it means for your workflow.
What You'll Learn
You'll understand Karpathy's precise distinction between vibe coding and agentic engineering and why he considers one a subset of the other, the five core practices that define agentic engineering as a workflow discipline, how the shift from human-steered to human-architected changes the fundamental model of AI-assisted development, what the concrete workflow differences look like between a vibe coder and an agentic engineer working on the same task, how to assess which parts of your current workflow are vibe coding and which are agentic engineering, and what skills to prioritize to move up the capability curve toward agentic engineering practices.
Karpathy's Exact Framing
Karpathy's post (condensed, retaining his key distinctions):
"Vibe coding was the right name for 2023 — you're exploring, you don't know where you're going, you're riding the vibes. That's still valid for prototyping. But it's passé as a professional paradigm because the tools are now capable of much more structured collaboration. What I'd call agentic engineering is when you stop steering and start architecting. You design the task specification. You define the quality gates. You authorize the tools and the scope. You verify the output against the spec. The AI executes. You're a principal engineer running a team of one very fast, very literal junior developer who needs extremely clear specs and immediate feedback on ambiguity. That's a fundamentally different cognitive posture than vibing."
The core distinction:
Vibe Coding (2023-2025 paradigm):
├── Human steers: You prompt, AI responds, you adjust, repeat
├── Exploratory: Direction emerges from the interaction
├── Conversational: Natural language back-and-forth
├── Human-in-the-loop at every step
└── Analogy: Pair programming where you're typing and the AI suggests
Agentic Engineering (2025-present paradigm):
├── Human architects: You design the full spec before execution
├── Deliberate: Direction is defined before AI starts
├── Declarative: You specify outcomes, AI determines steps
├── Human-in-the-loop at checkpoints, not every step
└── Analogy: Tech lead delegating a complete task to an engineer
Karpathy is precise that agentic engineering isn't a replacement for vibe coding — it's a superset. Vibe coding remains valuable for exploration and prototyping. Agentic engineering is what you graduate to when building for reliability and scale.
The Five Practices of Agentic Engineering
Karpathy described five practices that characterize agentic engineering as a discipline:
Practice 1: Task Specification Engineering
Vibe coding: You describe what you want. The AI interprets. You correct. You describe more.
Agentic engineering: You write a complete task specification before the AI starts. The spec includes:
# Task: Implement OAuth2 GitHub Authentication
## Objective
Add GitHub OAuth2 sign-in to the existing Next.js app, persisting
sessions in Supabase auth. Do not touch existing username/password flow.
## Acceptance Criteria
- [ ] User can click 'Sign in with GitHub' and complete OAuth flow
- [ ] Session is persisted in Supabase auth.users table
- [ ] Existing sessions survive a browser refresh
- [ ] Error states (user cancels, token invalid) show appropriate UI
- [ ] No regressions in existing auth flow
## Constraints
- Use next-auth v5 (not v4 — check package.json)
- Follow the existing auth pattern in src/lib/auth.ts
- Do not modify the database schema — use existing auth.users columns
- Test accounts: test@example.com (existing user), new@example.com (new user)
## Out of Scope
- Role-based access control
- Avatar/profile sync from GitHub
- Multi-provider OAuth (save for next sprint)
## Files Expected to Change
- src/lib/auth.ts (add GitHub provider)
- src/app/api/auth/[...nextauth]/route.ts (may need new file)
- src/components/LoginButton.tsx (add GitHub button)
- .env.example (add GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET)
The investment: 15-30 minutes to write a complete spec. The return: Claude Code executes it with one or two clarifying questions rather than dozens of correction cycles. The total time to working implementation is often shorter including spec time than iterative prompting without spec.
Practice 2: Authorization Architecture
Vibe coding: You give the AI access to tools and let it decide what to use.
Agentic engineering: You explicitly authorize specific access — and only that access:
# Claude Code authorization for the OAuth task above:
name: implement-github-oauth
tools_allowed:
- read # Read any file
- edit # Edit src/lib/auth.ts, src/components/LoginButton.tsx
- write # Write src/app/api/auth/[...nextauth]/route.ts (may not exist)
- bash # Run: npm install, npm run build, npm test
- github # Read repo contents, not write to remote
tools_denied:
- database # Do NOT modify the database schema
- deploy # Do NOT trigger deployments
scope:
files: ["src/lib/auth.ts", "src/components/LoginButton.tsx",
"src/app/api/auth/**", ".env.example"]
restrict_to_scope: true # Do not edit files outside this list
This isn't caution — it's precision. Explicit authorization means Claude knows exactly what it can and can't do, reduces errors from overreach, and produces a clear audit trail of what the agent touched.
Practice 3: Quality Gate Definition
Vibe coding: You review the output and decide if it looks right.
Agentic engineering: You define quality gates in the task spec, and the agent verifies against them before reporting completion:
quality_gates:
automated:
- command: npm run build
must_pass: true
- command: npm test -- --testPathPattern=auth
must_pass: true
- command: npm run type-check
must_pass: true
self_verification:
- "Verify no existing tests are broken (run full test suite)"
- "Verify GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET are in .env.example"
- "Verify the GitHub button appears on /login page"
- "Verify error state renders when OAuth is cancelled"
report_on:
- "List all files changed"
- "List all tests that now pass for this feature"
- "Flag any assumptions made not covered in the spec"
- "Flag any out-of-scope work that was tempting but excluded"
Quality gates shift verification from 'human reviews the output' to 'agent verifies against spec, human spot-checks'. This is the core of the time compression in agentic engineering.
Practice 4: Checkpoint Design
Vibe coding: The interaction is synchronous — you watch, you steer.
Agentic engineering: Long execution runs with human checkpoints:
checkpoints:
- after: "Initial implementation complete"
human_review: "Check that the auth flow compiles and the basic button renders"
# Human takes 5 minutes to verify before agent continues
- after: "Testing complete"
human_review: "Review the test output — if >0 failures, abort"
- after: "Documentation update"
human_review: "Final review before commit"
# Human reviews all changes and approves commit
Checkpoints aren't overhead — they're the mechanism that prevents a single bad assumption from propagating through 3 hours of work. A 5-minute checkpoint that catches a wrong direction saves 90 minutes of backtracking.
Practice 5: Attribution and Audit Trail
Vibe coding: AI writes code, it's in the codebase, authorship is ambiguous.
Agentic engineering: Every agent run produces an artifact trail:
# Commit convention in agentic engineering:
git commit -m "feat(auth): implement GitHub OAuth2 via next-auth v5
Implemented by Claude Opus 4.7 agentic run.
Task spec: .claude/tasks/implement-github-oauth.yaml
Quality gates passed: build, test (auth suite), type-check
Reviewed by: [developer name]
Checkpoints: 3/3 approved
Files changed:
- src/lib/auth.ts: Added GitHub provider configuration
- src/components/LoginButton.tsx: Added GitHub sign-in button
- src/app/api/auth/[...nextauth]/route.ts: Created NextAuth route handler
- .env.example: Added GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET"
This audit trail serves three purposes: incident attribution (what was AI-generated when something breaks), review guidance (human reviewer knows to focus on specified files), and team knowledge (the task spec documents intent, not just implementation).
Mapping Your Current Workflow to the Spectrum
Most developers operate somewhere on the spectrum between vibe coding and agentic engineering. Here's a diagnostic:
Workflow assessment questions:
Task specification:
├── Vibe: You describe what you want in the prompt
├── Hybrid: You write some requirements before prompting
└── Agentic: You write a full spec with acceptance criteria before starting
Authorization:
├── Vibe: Agent has full access to all tools
├── Hybrid: You restrict some tools but not explicitly
└── Agentic: You authorize specific tools and file scope explicitly
Quality verification:
├── Vibe: You review the output and it looks right to you
├── Hybrid: You run tests after the agent completes
└── Agentic: Agent self-verifies against defined gates before completion
Human attention:
├── Vibe: Continuous — you watch and steer throughout
├── Hybrid: Check in regularly but allow some autonomous runs
└── Agentic: Checkpoint-based — autonomous runs with defined review points
Audit trail:
├── Vibe: Code is in git, attribution unclear
├── Hybrid: Commit messages mention AI assistance
└── Agentic: Full task spec, quality gate results, and reviewer sign-off in git
Your score: Count how many of the 5 practices are at 'Agentic' level.
├── 0-1 Agentic: Vibe coder — high agility, lower reliability at scale
├── 2-3 Agentic: Hybrid — improving, most professionals are here
└── 4-5 Agentic: Agentic engineer — maximum delegation efficiency
What Karpathy Gets Right (and the Nuance He Glosses Over)
Karpathy's framing is accurate and useful, with one important nuance:
The practices of agentic engineering have overhead. Writing a complete task spec takes 15-30 minutes. Designing quality gates takes 10-15 minutes. This overhead is worth it for tasks that are:
- Complex (multiple files, multiple concerns)
- High-stakes (production code, security-sensitive)
- Long-running (more than 30 minutes of execution)
- Team-facing (other developers will review and maintain)
It's not worth it for:
- Quick explorations and prototypes
- Single-file, single-function changes
- Experimental code you'll throw away
- Solo projects where you'll review everything anyway
The meta-skill of agentic engineering is knowing when to apply the full practice and when vibe coding remains the right tool. The developers extracting the most value are fluent in both, not dogmatic about either. Karpathy's 'passé' framing is provocative but the precise message is: for production software at the capability level these tools now offer, vibe coding underutilizes the tool.
The Cognitive Shift
The deepest point Karpathy makes is about cognitive posture. Vibe coding keeps the developer in an 'execution mindset' — you're always one prompt away from the next line of code. Agentic engineering puts the developer in an 'architectural mindset' — you're always one spec away from a complete feature.
Cognitive posture comparison:
Vibe coding cognitive loop (fast, shallow):
Think → Prompt → Review → Adjust → Repeat (minutes per cycle)
Agentic engineering cognitive loop (slow, deep):
Architect → Specify → Authorize → Delegate → Checkpoint → Verify
(hours per cycle, much larger task scope per cycle)
At the same wall-clock time:
├── Vibe coding: Many small outputs with high attention overhead
└── Agentic engineering: Fewer, larger outputs with lower attention overhead
For solo developers with limited attention capacity:
Agentic engineering produces more output per hour of human attention —
but requires more careful task design and spec investment upfront.
This is the productivity math that makes agentic engineering compelling: it's not faster in wall-clock time for small tasks, but it produces dramatically more output per hour of human time on large tasks by shifting the human's role from executor to architect.
Common Challenges
'If agentic engineering requires a 30-minute spec, won't I just as easily write the code myself?' — For simple tasks, yes — and you should. The leverage of agentic engineering comes at scale: a 30-minute spec that produces 3 hours of quality AI execution gives you a 6x leverage ratio on that task. For small tasks that take 30 minutes to write and 30 minutes for AI to execute, the leverage isn't there. Apply agentic practices to tasks where the execution scope justifies the design investment.
'Karpathy said vibe coding is passé — should I stop calling what I do vibe coding?' — No. Karpathy's framing is about the professional paradigm, not the terminology. 'Vibe coding' as a term has real cultural resonance and accurately describes the exploratory, AI-assisted workflow. His point is about the ceiling — not that the approach is wrong, but that 'vibing' as the only mode undersells the capability of current tools. Calling yourself a vibe coder is fine; layering agentic engineering practices on top is what Karpathy recommends.
'Does this mean AI tools are actually replacing senior engineers?' — Karpathy's framing suggests the opposite: the value of senior engineering judgment increases in the agentic paradigm. Writing a good task spec requires architectural thinking, security awareness, and deep domain knowledge — skills that take years to develop. The AI executes; the human architect still needs to design what should be executed. The shift is in where that expertise is applied (design, spec, verification) versus where it was previously applied (also implementation).
'How do I convince my team to invest time in task specs when they think it's slower?' — Run a comparison sprint: for the next two weeks, have one developer use standard vibe coding workflow and one use the agentic spec-first approach on comparable features. Measure: total feature completion time including rework, number of review cycles, number of post-merge bugs. The data from your own codebase is more persuasive than any benchmark. The Intermediate Track at Vibe Coding Academy has a team workflow adoption module with exactly this comparison methodology.
Advanced Tips
Start the spec habit with a template. The spec-writing overhead drops dramatically once you have a template. Create .claude/task-template.md with the sections from this post (Objective, Acceptance Criteria, Constraints, Out of Scope, Files Expected to Change, Quality Gates). For each new task, copy the template and fill in the blanks — 15 minutes versus 30+ minutes for a blank-page spec. Over time, your templates get more refined as you learn which sections matter most for your codebase.
Build your authorization profiles in advance. Most of your agentic runs will fall into a small number of authorization profiles: 'full codebase read, write to feature scope'; 'read-only for analysis'; 'CI/CD restricted — build and test only'; 'database migrations — schema only'. Define these profiles in .claude/profiles/ directory and reference them in task specs. Authorization architecture becomes fast when you're selecting from a library rather than designing from scratch each time. The Advanced Track at Vibe Coding Academy Module 11 covers authorization profile libraries for multi-agent systems.
Use the quality gate results as training data. When your quality gates catch something the agent missed, add that class of error to the quality gates for future tasks of that type. When gates are consistently passing, you can relax review overhead on those dimensions. Over time, your quality gate library becomes a codified record of where your AI workflow needs human verification — a living, improving set of checks tuned to your specific codebase and risk profile.
Karpathy's framing works for team dynamics too. If you're a tech lead or senior developer working with a team that uses AI coding tools, the agentic engineering model maps naturally to team workflow: you architect the task spec (senior), the AI (and/or junior developers) execute against it, quality gates enforce standards, and you checkpoint and verify. The spec-first approach also produces better knowledge transfer than ad-hoc vibe sessions — the spec documents intent that otherwise lives only in your head. The Vibe Coding Ebook Chapter 15 covers the business model implications of agentic engineering for teams, agencies, and solo developers.
Conclusion
Karpathy's declaration that vibe coding is 'passé' is less about abandoning an approach and more about raising the ceiling for what AI-assisted development should look like at its best. The five practices of agentic engineering — task specification, authorization architecture, quality gates, checkpoint design, and attribution — aren't overhead. They're the workflow design that makes it possible to reliably delegate substantial, complex engineering work to AI systems at the capability level those systems have now reached. The developers who internalize this shift — from human-steered prompting to human-architected delegation — are the ones who will extract 10x productivity from tools that most developers are using at 3x. The curriculum at Vibe Coding Academy is explicitly designed around the agentic engineering paradigm: the Beginner Track covers the fundamentals, the Intermediate Track covers spec-first workflow design, and the Advanced Track covers multi-agent orchestration that Karpathy's framing points toward. For the full context on how agentic engineering fits into the evolving tool landscape — including Cursor Background Agents, Claude Code Routines, and OpenAI Assistants as the infrastructure for this paradigm — Vibe Coding Ebook Chapter 6 covers the agent revolution with updated coverage of the agentic engineering framing. Stay current with the evolution of AI-assisted development at EndOfCoding.