Karpathy Says Vibe Coding Is Passé — Here's What Replaced It

In early April 2026, Andrej Karpathy — the person who coined the term 'vibe coding' in February 2025 — publicly declared it passé. That's a remarkable 14-month arc: from inventing a term that swept the developer world to retiring it. But Karpathy isn't saying AI-assisted coding is over. He's saying the mental model that made 'vibe coding' accurate has been superseded by something more rigorous. The successor paradigms he's pointing to — agentic engineering and context engineering — represent a maturation of the practice, not an abandonment of it. For anyone who has built their workflow around vibe coding, or who is teaching it, this shift requires updating how you think about the discipline. Here's a precise account of what changed, what Karpathy is actually pointing at, and what it means for your practice in April 2026.

What You'll Learn

You'll understand exactly what Karpathy said and why the timing matters, what 'agentic engineering' means as a practice distinct from vibe coding, what 'context engineering' is and why it's becoming the core skill for AI-assisted development, how these paradigms change the way you structure work and interact with AI coding tools, and what this shift means for the Vibe Coding Academy curriculum and how we're updating it.

What Karpathy Actually Said

Karpathy's April 8 statement wasn't a retraction — it was a refinement. The core point: 'vibe coding' as a term captured a particular moment when developers were first discovering that you could ship working software by describing intent to an AI and iterating on its output. That moment was real and the term was useful. But the practice has evolved past what 'vibe' implies.

The word 'vibe' suggests something informal, intuitive, and resistant to systematization. What developers are actually doing in 2026 is more deliberate and more structured than that. Karpathy is pointing at two successor concepts:

1. Agentic Engineering 2. Context Engineering

These aren't marketing terms — they describe real shifts in how the work is done.

Agentic Engineering: What It Is

Agentic engineering is the discipline of designing and directing AI agents to complete multi-step software engineering tasks autonomously.

The key distinction from vibe coding: in vibe coding, the developer is in the loop on every step — you prompt, review output, prompt again, accept or reject. In agentic engineering, you're designing workflows where AI agents execute extended sequences of tasks with minimal interruption.

Vibe coding workflow:
Developer → prompt → AI → output → Developer reviews → prompt again

Agentic engineering workflow:
Developer → defines task specification + constraints → Agent executes
Agent reads files, writes code, runs tests, fixes failures, commits
Developer reviews final output (or gets flagged on failure)

The practical difference: agentic engineering requires the developer to invest more upfront in task specification, context loading, and constraint definition — because the agent will run for an extended period without asking for clarification. The phrasing and structure of what you hand the agent determines whether it produces something useful or diverges.

Concrete examples in April 2026 tooling:

Claude Code Routines (launched April 14): persistent cloud agents that run on schedule or event trigger, without requiring your session to be active
Codex multi-agent orchestration (launched April 17): one orchestrating agent spawns and manages parallel sub-agents for independent workstreams
Cursor Background Agents: long-running tasks that execute in the background while you work on something else

All three represent the same underlying pattern: the developer is now an agent designer and task specifier, not just a prompt-response iterater.

Context Engineering: The Core New Skill

Context engineering is the discipline of constructing the information environment that an AI model receives — what it can see, what it knows about your project, what constraints and patterns it operates within.

This is arguably the most important skill shift in AI-assisted development in 2026. Here's why:

A model like Claude Opus 4.7 or GPT-5 is capable of producing excellent code. But the quality of what it produces for your specific project depends almost entirely on the quality of the context it receives. Two developers using the same model get dramatically different outputs because they're providing different context.

Context engineering inputs (what you control):

1. SYSTEM CONTEXT
   ├── Project description and purpose
   ├── Technology stack and versions
   ├── Architecture decisions and patterns in use
   ├── Naming conventions and code style
   └── What NOT to do (anti-patterns, banned dependencies)

2. TASK CONTEXT
   ├── Precise description of what needs to be built
   ├── Where in the codebase it belongs
   ├── Interfaces with existing code (types, API shapes)
   ├── Acceptance criteria (what does 'done' look like)
   └── Test requirements

3. REFERENCE CONTEXT
   ├── Relevant existing files (similar implementations)
   ├── Documentation for libraries being used
   ├── Error messages and logs (for debugging tasks)
   └── Prior failed attempts and what went wrong

4. CONSTRAINT CONTEXT
   ├── Security requirements
   ├── Performance targets
   ├── Backward compatibility requirements
   └── External review requirements

Context engineering is about deliberately loading all four types of context before the model generates output. Developers who do this consistently produce much better results than developers who write short, under-specified prompts and rely on the model to fill in gaps.

The tools that support context engineering:

CLAUDE.md files: project-level system context that loads into every Claude Code session
Codex persistent memory: project context that persists across sessions without re-specifying
Cursor Rules: project conventions and constraints in .cursorrules
Model Context Protocol (MCP): standardized tool for injecting external data sources into model context

Why the Paradigm Shift Matters for Your Workflow

The 'vibe coding' framing encouraged a particular working style: be casual, experiment freely, accept imperfect output and iterate. That framing was useful for lowering the barrier to entry. Millions of developers who would have been intimidated by traditional software development tried it and shipped real things.

But that framing also created ceiling effects for developers who adopted it as a permanent working style rather than an entry point:

Limitations of pure 'vibe coding' approach:
├── Unpredictable output quality — relies on model filling gaps
├── Doesn't scale to large codebases or long-running agents
├── Security and architecture decisions made implicitly by model
├── Hard to maintain — inconsistent patterns accumulate
└── Difficult to collaborate on — context lives in one person's head

What agentic + context engineering adds:
├── Predictable, reproducible output (same context → same quality)
├── Scales to agentic workflows without constant human intervention
├── Explicit architecture and security constraints enforced in context
├── Maintainable — patterns documented in CLAUDE.md / project files
└── Collaborative — context is sharable and version-controlled

The transition is from 'prompting as a craft skill' (something individual and intuitive) to 'context design as an engineering practice' (something systematic and teachable).

The JetBrains Trust Gap Connection

The JetBrains April 2026 survey (10,000 developers) reported 90% AI tool adoption but only 29% trust in AI code shipped to production. That 61-point trust gap isn't an accident — it's directly related to the quality of context engineering being applied.

Developers who trust AI code in production are, almost universally, the ones who've invested in context engineering: they have explicit architecture docs loaded into model context, they have constraint files that prevent the model from making insecure or architecturally inconsistent decisions, and they have verification workflows that catch divergence.

Developers who don't trust AI code in production are often the ones who are still 'vibe coding' — casual, under-specified prompting that produces plausible-looking code with implicit assumptions the developer hasn't verified.

Context engineering is the mechanism that closes the trust gap. That's why Karpathy's framing shift matters in practice, not just as terminology.

How the Academy Curriculum Is Updating

The Vibe Coding Academy covers this evolution directly. The core modules already cover prompt engineering fundamentals — the updated curriculum is adding dedicated modules on:

Context Engineering Fundamentals: how to structure system context, task context, reference context, and constraint context
Agentic Workflow Design: how to specify tasks for autonomous agents, design checkpoints, and validate agent output
CLAUDE.md and Context Files: building project-level context that makes every AI session more effective
Trust Gap Engineering: the practices that get production confidence from 29% to >80%

These are live updates to the Intermediate and Advanced tracks throughout Q2 2026.

Common Challenges

'If vibe coding is passé, does my work so far need to be rebuilt?' No — nothing you've shipped needs to change. The paradigm shift is about how you work going forward, not a verdict on what you've already built. The code is the code; what's changing is the discipline around producing it. 'Isn't context engineering just prompt engineering with a new name?' Prompt engineering is about the text of individual prompts. Context engineering is about the full information environment the model operates in — system context, project state, constraints, reference material. It's a superset that includes prompt engineering but goes much further. A single well-crafted prompt is prompt engineering. A CLAUDE.md file, a project architecture document loaded into model context, and a constraint file defining security requirements together are context engineering. 'Does this mean I need to become more technical to use AI coding tools effectively?' Somewhat. The pure 'no coding knowledge required' framing of early vibe coding was always overstated for anything beyond simple tools. Agentic and context engineering require understanding enough about your codebase to specify good context — architecture, patterns, constraints. That's a lower bar than traditional software development, but it's higher than 'just describe what you want and it works.' The skill curve has clarified, not disappeared.

Advanced Tips

Start with a CLAUDE.md file if you don't have one. This is the single highest-leverage context engineering investment for most vibe coders. A well-written CLAUDE.md loaded into Claude Code context means every session starts with your architecture, conventions, and constraints already loaded. You stop re-explaining your project at the start of every conversation. For a template structure, the Vibe Coding Ebook Chapter 13 covers advanced workflow configuration including CLAUDE.md patterns. Treat context design as a first-class artifact. The best context engineers treat their CLAUDE.md, .cursorrules, and project docs as version-controlled, maintained artifacts — as important as the code itself. When architecture decisions change, the context files update. This creates a feedback loop: better context → better AI output → more confidence in AI code → higher production trust scores. Use agentic workflows for clearly-bounded independent tasks. The easiest agentic engineering wins are tasks with clear interfaces and verifiable acceptance criteria: write tests for a specific module, document a specific API, implement a specific CRUD endpoint. These map cleanly to single-agent tasks. Reserve multi-agent orchestration for when the parallel workstreams genuinely don't depend on each other — rushing into multi-agent for dependent tasks creates reconciliation overhead that eliminates the speed gain. Stay current on how these paradigms are evolving at EndOfCoding.

Conclusion

Karpathy's April 2026 declaration that vibe coding is passé isn't a dismissal of AI-assisted development — it's an upgrade notice. The practice has matured from 'describe what you want and see what happens' to something more rigorous: agentic engineering (designing autonomous workflows) and context engineering (building the information environment that makes AI output reliable). The 61-point trust gap in the JetBrains survey (90% adoption, 29% production trust) is exactly what context engineering closes. Developers who invest in explicit context design — architecture docs, constraint files, reference material — consistently get AI code they trust enough to ship. The Vibe Coding Academy curriculum is updating to reflect this evolution throughout Q2 2026 — the Intermediate and Advanced tracks are adding dedicated context engineering and agentic workflow modules. For the full framework on context engineering patterns, the Vibe Coding Ebook covers this in the updated Chapter 13. Subscribe to EndOfCoding for weekly coverage of how these paradigms continue to evolve.