Karpathy Says 'Agentic Engineering' Replaces Vibe Coding — What That Means for You
By EndOfCoding
Andrej Karpathy — the man who coined 'vibe coding' in February 2025 — has quietly reframed the term. In an April 28, 2026 update, Karpathy drew a sharp line between vibe coding as a beginner's playground and what he now calls 'agentic engineering' for professional software development. His point: vibe coding (prompting without reviewing or understanding the output) is fine for throwaway scripts and learning. But professional engineers in 2026 are doing something fundamentally different — they're orchestrating networks of AI agents, reviewing generated code, applying engineering judgment, and building systems that have to survive contact with production. Karpathy's framing has already sparked debate across the AI coding community, with responses ranging from enthusiastic agreement to accusations that he's retroactively redefining his own term. But regardless of the naming debate, the underlying shift he's describing is real and it has direct implications for how you think about your development practice. This post unpacks exactly what Karpathy means by agentic engineering, how it differs from classical vibe coding, and what the distinction means for developers at different skill levels in 2026.
What You'll Learn
You'll understand Karpathy's precise distinction between vibe coding and agentic engineering, the specific capabilities that define an agentic engineering workflow (multi-agent orchestration, code review, CI/CD integration), how to honestly assess where your own practice sits on the spectrum, what skills to develop if you want to move from vibe coding to agentic engineering, and why this framing matters for how you present yourself and your work professionally.
Karpathy's Distinction: The Exact Line
Karpathy's April 28 update (shared across social platforms and in his newsletter) drew the distinction as follows:
Vibe coding (original definition, Feb 2025):
├── Give the AI a rough description of what you want
├── Accept the generated code without deep review
├── Iterate by describing problems in natural language
├── Treat the code as a black box you don't fully understand
└── Appropriate for: personal scripts, learning, prototypes
where failure cost is low
Agentic engineering (Karpathy, Apr 2026):
├── Design the architecture and agent topology yourself
├── Decompose complex tasks into agent-executable subtasks
├── Review AI-generated code at a meaningful level before merging
├── Use CI/CD pipelines and automated testing to catch agent errors
├── Orchestrate multiple specialized agents for different layers
└── Appropriate for: production systems, team environments,
anything that has to be maintained or scaled
The key shift: in agentic engineering, you're not the one writing code, but you ARE the one responsible for what gets merged. You're an architect, a reviewer, and an orchestration designer — not a passive recipient of AI output.
The Four Pillars of Agentic Engineering
Based on Karpathy's framing and how professional engineers at leading companies are actually working in 2026, agentic engineering has four defining pillars:
Pillar 1: Intentional Architecture
├── You design the system before any code is generated
├── Tools: draw the component graph, define interfaces, decide
│ data ownership — then delegate implementation to agents
├── Claude Code workflow:
│ └── CLAUDE.md defines architecture constraints
│ → /goal for high-level objectives
│ → Agent View shows agent plan for review before execution
│ → You approve or redirect — don't blindly accept
└── Anti-pattern: asking an agent 'build me a SaaS app' without
specifying data model, auth approach, or deployment target
Pillar 2: Multi-Agent Orchestration
├── Production agentic engineering uses specialized agents
│ rather than a single general-purpose model for everything
├── Example agent topology for a full-stack feature:
│ ├── Planning agent: breaks down requirements
│ ├── Frontend agent (Claude Code + React specialist context)
│ ├── Backend agent (Claude Code + API design context)
│ ├── Database agent (schema design, migration generation)
│ ├── Security review agent (OWASP checklist)
│ └── Test generation agent (coverage requirements)
├── Each agent has a specific context and success criteria
└── You coordinate — you don't just talk to one agent and hope
Pillar 3: Meaningful Code Review
├── The defining skill that separates agentic engineering from vibe coding
├── You don't need to have written the code to review it well:
│ ├── Does the logic match the spec you gave?
│ ├── Are there security concerns? (input validation, auth gaps)
│ ├── Will this be maintainable in 6 months?
│ └── Does the test coverage actually catch meaningful failures?
├── Claude Code tools for review:
│ ├── Background sessions run agents while you review other work
│ ├── /thinking enables extended reasoning for complex review
│ └── Git diff integration lets you review changes in context
└── Anti-pattern: merging without reading because 'the agent tested it'
Pillar 4: Engineering-Grade Quality Gates
├── Agentic engineering uses the same quality infrastructure as
│ traditional engineering — not less, often more:
│ ├── Automated tests (the agent should generate these too)
│ ├── CI/CD pipeline with required checks before merge
│ ├── Static analysis (ESLint, TypeScript strict mode)
│ └── Dependency vulnerability scanning (Dependabot, Snyk)
├── The agent generates faster — but the quality bar doesn't drop
└── Tools: GitHub Actions for CI, Claude Code GitHub integration
(expected Q3 2026), pre-commit hooks, Vercel deployment checks
Where Most Developers Actually Are (Honest Assessment)
Karpathy's framing is useful precisely because it lets you honestly locate yourself on the spectrum:
Level 1 — Classic Vibe Coding
├── Prompting for output you accept without deep review
├── Iterating by describing errors in natural language
├── No automated testing or CI
└── Fine for: personal projects, learning, rapid prototyping
Level 2 — Guided Vibe Coding
├── Using CLAUDE.md to constrain agent behavior
├── Reviewing diffs before accepting, even if not line-by-line
├── Running basic tests manually after generation
└── Where many productive individual vibe coders are in 2026
Level 3 — Proto-Agentic Engineering
├── Designing system architecture before delegation
├── Using multiple agents for different concerns
├── Running automated tests in CI on agent-generated code
└── Where teams adopting Claude Code enterprise are landing
Level 4 — Full Agentic Engineering
├── Complete agent topology with specialized roles
├── Engineering-grade review and quality gates
├── Background sessions, CI/CD integration, monitoring
└── Where Karpathy means 'agentic engineering' — the professional tier
Most working developers in 2026 are at Level 2-3. Getting to Level 4 requires deliberately building the orchestration infrastructure — it doesn't happen automatically from using Claude Code more.
The Skills Gap to Close
If you want to move toward agentic engineering, these are the specific skills to develop:
Skill 1: Agent topology design
├── Learn to think in directed graphs of agents
├── Practice: for your next feature, sketch the agent roles on paper
│ before opening Claude Code
└── Resource: Anthropic Agent SDK documentation (tool definitions,
agent-to-agent handoffs, context management)
Skill 2: Effective code review of AI output
├── Read the generated code — don't just run the tests
├── Develop a review checklist: security, logic, maintainability, tests
└── Practice on open source PRs labeled 'AI-generated' to build your eye
Skill 3: CI/CD infrastructure design
├── Set up GitHub Actions for your projects if you haven't
├── Add Claude Code GitHub integration when it ships (Q3 2026 roadmap)
└── Treat failing CI as a hard blocker — don't merge around it
Skill 4: Prompt architecture for complex tasks
├── Learn to write agent instructions that produce reliable output
│ (CLAUDE.md files, system prompts, goal hierarchies)
└── Practice the /goal command in Claude Code for multi-step tasks
Common Challenges
'Does this mean vibe coding is for beginners only?' — No. Karpathy's point is about workflow sophistication, not about who should do it. Many experienced engineers still vibe code for personal projects, prototypes, and exploration. The distinction is about what's appropriate for production systems and team environments — not about gatekeeping the technique. 'I'm not reviewing every line of AI-generated code — should I be concerned?' — Probably yes, for production code. Meaningful review doesn't mean line-by-line reading for every file, but it does mean you understand what the agent changed, why, and whether it matches your intent. Automated tests catch many errors, but they can't catch architectural mistakes or security decisions the agent made that you didn't specify. 'Can I call myself an agentic engineer if I'm using Claude Code but not orchestrating multiple agents?' — Karpathy's framing suggests that multi-agent orchestration is part of what distinguishes agentic engineering. A more honest self-description for single-agent Claude Code work is 'AI-assisted engineering' — which is genuinely valuable, but different from what Karpathy is describing. 'Is this just rebranding to avoid the negative connotations 'vibe coding' has picked up?' — Partly, but the underlying distinction is real. 'Vibe coding' has come to mean 'coding without understanding what you're doing' in mainstream discourse — which is unfair to developers who are thoughtfully using AI tools. Karpathy's reframe attempts to give the professional practice a more accurate name.
Advanced Tips
Build your CLAUDE.md as an architectural constraint document, not just style guidance. The most powerful use of CLAUDE.md for agentic engineering isn't formatting preferences — it's encoding your system's architectural decisions (data ownership, auth patterns, API conventions) so every agent you run respects those decisions without you restating them. Set up a background agent topology for your most common workflows. If you regularly need a frontend agent, a backend agent, and a test agent for feature work, create template CLAUDE.md files for each role and run them as background sessions. Review at the coordination points, not during each individual generation. Use the Agent View 'pause' feature to review plans before execution for unfamiliar tasks. When Claude Code shows you its plan in Agent View before executing, actually read it — especially for tasks that touch production systems, authentication, or database schemas. A plan that looks wrong is much cheaper to correct than a completed implementation that's wrong. The Vibe Coding Academy Module 11 (Multi-Agent Development) is being updated to include Karpathy's agentic engineering framework and practical exercises for building agent topologies. The Vibe Coding Ebook Chapter 6 (The Agent Revolution) and Chapter 14 (Sustainable Workflows) have been updated to reflect the agentic engineering distinction — worth re-reading if you last read them before April 2026. Stay current with Karpathy's evolving thinking on AI engineering at EndOfCoding.
Conclusion
Karpathy's 'agentic engineering' framing isn't just a rebrand. It's a useful signal about where the industry is heading and what skills matter for professional AI-assisted development. Vibe coding as a starting point — prompting, iterating, learning — remains valuable. But production software, team environments, and systems with real users require more: intentional architecture, meaningful code review, multi-agent orchestration, and engineering-grade quality gates. The good news: Claude Code's May 2026 release (Agent View, /goal, background sessions) gives you the tooling to work this way. What it can't give you is the judgment to design agent topologies, review generated code meaningfully, and build the CI/CD infrastructure that makes agentic engineering reliable. Those are skills you develop deliberately. If you're currently at Level 2 on the spectrum — reviewing diffs, using CLAUDE.md, iterating thoughtfully — Level 3 and 4 are within reach with focused practice on the orchestration and review skills that Karpathy is pointing at. The Vibe Coding Academy has the curriculum to get you there, from the multi-agent module to the advanced Claude Code workflows course. Keep building. Keep reviewing. That's the professional practice. Follow the latest on agentic engineering, Claude Code, and the future of software development at EndOfCoding.