SKIP TO CONTENT
vibe coding academy
ON AIR — VIBE CODING ACADEMY · EN · LIVE
All articles
INDUSTRY NEWS·June 1, 2026·10 MIN READ

Vibe Coding Is Dead — Karpathy Just Introduced 'Agentic Engineering' at Sequoia AI Ascent

By EndOfCoding

Andrej Karpathy officially retired the term 'vibe coding' at Sequoia's AI Ascent conference today. He introduced its successor: 'Agentic Engineering.' This isn't a rebrand. It's a fundamental reclassification of what AI-native software development has become — and what it demands of practitioners. If you've been building with Claude Code, Cursor, or any autonomous agent tooling, you are already doing Agentic Engineering. Now you need to understand what that means.

What You'll Learn

You'll understand exactly what Karpathy means by Agentic Engineering and how it differs from vibe coding, why the shift matters for how you structure your AI-assisted development practice, what the new mental model requires of developers in 2026, and how to immediately update your workflow to match the paradigm Karpathy is calling the next era of software development.

What Karpathy Said

At Sequoia AI Ascent, Karpathy announced a conceptual retirement of 'vibe coding' as the defining term for AI-native development. His exact framing:

'Vibe coding was the right name for the beginning — it captured the feeling of letting go, of trusting the AI. But the tools have matured. What we're doing now is Agentic Engineering. You're not just vibing. You're directing autonomous agents through complex multi-step work. That requires engineering discipline, not just vibes.'

He introduced Agentic Engineering as characterized by three core properties that vibe coding, as a concept, undersold:

  1. Delegation with Verification — You delegate entire tasks to agents, but you design the verification layer
  2. Multi-Agent Orchestration — The unit of work is a team of agents, not a single prompt
  3. Engineering Discipline at the Seams — Where agents hand off to each other is where humans must be most rigorous

Why This Is More Than a Rebrand

Vibe coding as Karpathy originally defined it (February 2025) was a mindset: embrace the AI, let go of line-by-line control, trust the output. That was the right prescription for a moment when developers were over-indexing on writing every line themselves.

Eighteen months later, the failure modes have shifted. The problem is no longer 'developers won't trust AI.' The problem is 'developers are trusting agents to do complex multi-step work without adequate verification architecture.'

Agentic Engineering addresses this directly. It's not less AI — it's more structured AI:

Vibe Coding Agentic Engineering
Single AI session does the work Orchestrated agents handle subtasks
Developer reviews final output Developer designs verification at each handoff
Trust the vibes Trust the architecture
Mindset shift Engineering discipline
February 2025 June 2026

The Three Pillars of Agentic Engineering

1. Delegation With Verification

You still give agents large tasks — but you design explicit verification gates:

# Vibe coding approach
claude "Build the entire payment system"
# → hope it works

# Agentic Engineering approach
claude "Build the Stripe webhook handler. 
Done = webhook validates signature + idempotency key + writes to DB.
After building, run the test suite and show me the green checkmarks.
If any test fails, fix it before reporting done."

Verification is not the agent's afterthought — it's built into the task definition.

2. Multi-Agent Orchestration

Karpathy's framework explicitly moves from single-agent sessions to orchestrated teams:

# Agentic Engineering: Multi-Agent Task Structure

## Agent 1: Architecture Agent
Scope: Define system design and API contracts
Output: Architecture doc + OpenAPI spec
Handoff: When spec is complete and reviewed

## Agent 2: Implementation Agent  
Scope: Build implementation against the spec
Input: Architecture doc from Agent 1
Output: Working code with passing unit tests
Handoff: When all tests pass

## Agent 3: Security Agent
Scope: Review implementation for vulnerabilities
Input: Working code from Agent 2
Output: Security report + any required fixes
Handoff: When no HIGH/CRITICAL findings remain

## Agent 4: Deploy Agent
Scope: Deploy to staging, run E2E tests
Input: Reviewed code from Agent 3
Output: Staging URL + E2E results
Handoff: Human reviews staging before prod

This is Claude Code's multi-agent mode, Anthropic's Dynamic Workflows, or any parallel agent orchestration — structured as an engineering discipline, not an experiment.

3. Engineering Discipline at the Seams

The handoff point between agents is where most failures occur. Karpathy calls this 'the seam problem.' Agentic Engineering requires you to:

  • Define explicit handoff criteria (not 'when done' but 'when X is verified')
  • Use structured outputs at seams (JSON schemas, typed interfaces)
  • Log seam state so failures are debuggable
// Seam output schema — what the implementation agent must produce
const SeamOutput = z.object({
  status: z.enum(['complete', 'blocked']),
  files_created: z.array(z.string()),
  tests_passing: z.boolean(),
  test_output: z.string(),
  blockers: z.array(z.string()).optional(),
});

// Agent task wrapper that enforces seam discipline
const agentTask = async (prompt: string, outputSchema: z.ZodType) => {
  const result = await runAgent(prompt);
  return outputSchema.parse(JSON.parse(result)); // Fails loudly if agent output is malformed
};

What This Means for Your Practice Starting Today

Update Your Mental Model

Stop thinking of yourself as an AI-assisted programmer. Start thinking of yourself as an agent orchestration engineer. Your job is not to write code. Your job is to:

  1. Define task scope and success criteria
  2. Design the agent team structure
  3. Specify handoff schemas
  4. Verify outputs at each seam
  5. Deploy the result

Update Your CLAUDE.md

# Agentic Engineering Principles (Per Karpathy, June 2026)
- Every task has explicit Done criteria, not 'best effort'
- Multi-step tasks use structured checkpoints — not continuous sessions
- Handoffs between agents use JSON schemas, not prose
- Security review is a dedicated agent phase, not an inline step
- I (the human) verify seams, not full implementations

Use Claude's Dynamic Workflows for Parallel Agent Tasks

Claude Opus 4.8's new Dynamic Workflows feature (also announced today) is literally built for Agentic Engineering. It lets you spin up hundreds of parallel subagents from a single orchestration prompt — exactly the multi-agent structure Karpathy is describing.

Common Challenges

'This sounds like what I was already doing' — You were doing it intuitively. Karpathy is giving it a name, a structure, and engineering discipline. The difference between 'winging it with agents' and Agentic Engineering is the same as the difference between 'writing code that works' and software engineering. 'Does this mean vibe coding is bad?' — No. Vibe coding was the right framework for its moment. Agentic Engineering is the maturation of the same underlying insight: AI can do the work, and your job is to direct it. The direction has gotten more sophisticated. 'I'm a solo developer — is multi-agent overkill?' — Karpathy explicitly addressed this: solo Agentic Engineering looks like task decomposition and checkpoint verification, not necessarily multiple running agents. You can orchestrate sequentially rather than in parallel and still get the benefits.

Advanced Tips

Watch for Claude Opus 4.8 Dynamic Workflows — launched the same day as Karpathy's talk, this is not a coincidence. Anthropic's tooling and Karpathy's framework are co-evolving. Dynamic Workflows is Anthropic's native implementation of the multi-agent orchestration pattern. The 'seam problem' is your competitive advantage — most developers using agents are ignoring handoffs. If you implement structured seam schemas and verification gates, your agent-built products will be dramatically more reliable than those built by developers who skip this step. Archive this moment — Karpathy naming a new paradigm at a Sequoia conference is a category-creation event. Agentic Engineering will appear in job descriptions, conference tracks, and course curricula within 90 days.

Conclusion

Vibe coding is not dead — it evolved. Karpathy retiring the term is not a critique of the practice, it's an acknowledgment that the practice has matured beyond what 'vibes' captures. Agentic Engineering is the professional discipline that grows from the vibe coding insight. For practitioners, this is a promotion: you've been experimenting, now there's an engineering framework for what you've been doing. For the foundational curriculum on building with AI agents — now the core of what Agentic Engineering requires — the Vibe Coding Ebook covers the methodology that has now been formalized, and the Multi-Agent Development course at the Academy is your fastest path to mastering the Agentic Engineering stack.

Back to all articlesGet the newsletter →