Andrej Karpathy champions agentic engineering over vibe coding for AI software evolution

AI development has already moved on from its first phase. The era of "vibe coding"—where you typed ideas in plain English and let the AI fill in the blanks—is behind us. Andrej Karpathy, the researcher who named vibe coding in early 2025, now argues that agentic engineering in AI coding is not just next, it's here, reshaping workflows from prototyping to shipping in production. If you're serious about building with AI, understanding agentic engineering is the difference between riding the next productivity wave and falling behind.

What is agentic engineering in AI coding and how does it differ from vibe coding?

Agentic engineering in AI coding is an autonomous, end-to-end workflow where the model—not the human—owns the process from generation to testing, error detection, fixing, and delivery. Unlike vibe coding, which let humans prompt and steer, agentic engineering puts most of the workflow on autopilot.

Vibe coding, as named by Karpathy in February 2025, was about speed and flexibility. You said what you wanted and the AI built a first draft: landing pages, quick prototypes, fast iterations. But the human was always in the loop—spotting mistakes, rerunning snippets, testing by hand. Agentic engineering pushes that boundary. Now, the AI not only generates code but also runs tests, reads stack traces, patches bugs, re-tests, and only calls for human review once the job is actually shipped.

Summary: Agentic engineering is automated AI code generation with closed-loop testing and self-fixing, unlike the manual, feedback-driven approach of vibe coding.

How did vibe coding shape early AI development?

Vibe coding shaped the first wave of AI programming by making development fast, accessible, and forgiving—especially for non-experts and rapid prototyping teams.

The term came into use in February 2025, attached to Karpathy’s philosophy that you could "vibe" with a model: describe your intent, get usable code, patch by example. It was the core workflow behind early AI code tools, which hit wide adoption for small websites, landing pages, and internal prototypes. The draw was speed—building a working front end in an afternoon—or rolling out a proof of concept over a weekend, thanks to models that handled syntax but not logic.

But the limitations were built in. Vibe coding worked for low-stakes, greenfield projects where humans could deal with mistakes. No serious team wanted CI pipelines or prod deploys on pure vibes. The AI's coverage ended where solid testing, coverage, and compliance began. Still, it democratized early AI-code generation—by doing just enough, fast.

Summary: Vibe coding defined early AI code tools by enabling quick, flexible prototyping, but required humans to test and fix, and it hit limits when reliability mattered.

Why is agentic engineering considered superior to vibe coding?

Agentic engineering overtakes vibe coding by automating the entire code lifecycle, increasing software reliability, and delegating more work to the agent—not the developer.

In the agentic workflow, the human describes the goal and the model iterates autonomously: it writes, tests, debugs, and patches as needed until tasks are complete. This loop—generate, test, fix, retest—is what vibe coding lacked. Instead of halting with "here's some code; good luck," agentic systems deliver features that have already passed test cases and workflows.

This enables several real improvements:

• Reliability: Automated tests catch regressions and bugs before humans ever see the output.
• Speed: Developers spend less time in the loop, so iterations compound faster.
• Scale: The same workflow works whether the agent is writing a CLI tool or a production API endpoint.
• Autonomy: Agents move past the "assistive" phase and directly ship working solutions to the target environment.

It’s not hype: by February 2026, Karpathy was on record saying vibe coding was obsolete, and production teams—in finance, research, and SaaS—were already running agentic loops.

Summary: Agentic engineering is superior because it closes the loop—autonomously testing and fixing code, not just generating drafts.

How is Andrej Karpathy leading the shift to agentic engineering?

Karpathy’s influence is direct and strategic: he’s not just talking up agentic engineering—he’s building the research teams making it real.

As of May 2025, Karpathy joined Anthropic to overhaul their pretraining research. By February 2026, he was publicly calling vibe coding outdated, making clear that hands-on, autonomous agentic workflows were the new benchmark. This isn’t armchair theorizing. When the person who coined the popular-phase name says it’s obsolete, the new architecture isn't hype, it's roadmap.

Karpathy’s shift set signals downstream. When he announced at Anthropic that vibe coding was behind the curve, teams at multiple companies responded—according to a May video, internal engineering orgs reported the move to agentic approaches as already done. The message: agents that do more than generate snippets are now table stakes for serious AI code infrastructure.

Summary: Karpathy’s move to Anthropic in May 2025 and his public statements have directly catalyzed the field’s shift from vibe coding to agentic engineering.

How does agentic engineering work in practice today?

Agentic engineering delivers on AI code autonomy by letting agents take a plain-English spec and return shippable, tested code—no manual loop required.

Here’s the standard workflow:

1. Human sets the goal: The user writes a brief—“build a REST API for managing invoices”—or picks a template.
2. Agent writes initial code: The AI autogenerates a first commit—controller, endpoints, tests.
3. Agent runs the tests: Without waiting for human review, the model spins up a sandbox, runs tests or linters, and collects any errors.
4. Agent fixes errors: If tests fail or lint errors surface, the model parses logs, patches code, and iterates.
5. Repeat: Steps 3 and 4 repeat automatically until all tests pass or a threshold error is hit.
6. Agent reports status: Once tests pass, the agent commits, pushes, and signals ready-to-ship status back to the human (or the CI/deploy system).

This process is live now, even outside research labs. As of May, senior engineers at three companies confirmed their teams had already made the shift. Harvard Gazette reported scientists—non-coders—delivering working internal tools after giving a brief to an agent. No human code review, no manual testing required. In banking, as of May 2026, PYMNTS reported a US neobank launched an agent-built customer feature, built and tested without traditional developer sign-off.

Summary: Modern agentic engineering workflows let AI systems write, test, and fix code autonomously—enabling both tech and non-tech users to ship working features with minimal manual touch.

// A simplified agentic coding pattern
const goal = "Create an endpoint for customer onboarding."
const aiAgent = new AgenticCoder(goal)

while (!aiAgent.allTestsPassing()) {
  aiAgent.writeCode()
  aiAgent.runTests()
  if (aiAgent.testFailed()) {
    aiAgent.parseError()
    aiAgent.fixCode()
  }
}

aiAgent.commitAndReport()

This loop is the new default, not a demo.

What are the benefits and challenges of agentic engineering?

Agentic engineering increases speed, scale, and autonomy—but real-world adoption surfaces new obstacles.

Benefits:

• Speed: Removes humans from the iteration loop—agents patch, retry, and ship in minutes.
• Scalability: The same system works whether for internal research tools, production APIs, or regulated banking apps.
• Reduced manual error: Automated test/fix cycles clean up what humans might miss or gloss over.
• Democratization: Enables non-engineers to deliver functional tools by simply describing their needs—the Harvard use-case.

Challenges:

• Model reliability: Agents can still misinterpret specs or introduce subtle logic bugs if test suites are thin.
• Context comprehension: Models can fail to grok non-obvious requirements or business logic, especially in complex real-world domains.
• Ethics and oversight: Shipping without human checks means sensitive features (esp. in finance) need careful policies; the neobank case is promising, but also exposes new surface area for audit.

No methodology is free of friction. The same AI autonomy that brings speed introduces risk if validation and oversight aren’t engineered in.

Summary: Agentic engineering brings autonomy and productivity but still requires solid guardrails for safety, context, and compliance.

What does the future hold for agentic engineering and AI development?

Agentic engineering is forecasted to become the new baseline for software development—redefining engineering roles, workflows, and tooling.

Karpathy’s predicted trajectory is already taking form. From his statements by February 2026 and Anthropic's adoption, agentic workflows are on track for:

• Widespread adoption: Teams across industries, not just big tech, using agentic pipelines.
• Self-improving agents: Models that learn from deployment, updating their code cycles autonomously.
• Redefined developer roles: Engineers move up the stack—from patching and testing to architecting specs and evaluating agent outputs.
• Tooling upheaval: Expect rapid evolution in CI/CD, model monitoring, and interface standards as agentic approaches push demand for frameworks that can orchestrate autonomous test-and-fix flows at scale.

The discipline of software engineering isn’t fading, but its lines are blurring. Future work will focus as much on supervising and enhancing agents as writing manual code.

Summary: Expect agentic engineering to become the dominant paradigm, with ripple effects on tooling, team structure, and the definition of "developer."

Closing: Agentic engineering as the next, lasting era

The age of vibe coding—quick ideas, fast drafts, code built on vibes—is already behind us. The frontier is agentic engineering: AI agents that not only translate intent into code, but own the process from ideation to tested, shippable release. Backed and named obsolete by Karpathy himself, agentic workflows are redefining how AI coding gets done—from banks to research labs to SaaS teams. For anyone building software, learning to harness agentic engineering is now the real enable. The cycle hasn’t ended—it’s leveled up.