Andrej Karpathy on the shift to agentic engineering pic.twitter.com/GP5drB5jrW
— Ben Lang (@benln) May 4, 2026
Vibe coding, as coined by Andrej Karpathy in a February 2025 X post, is a casual, high-leverage style of AI-assisted programming where you "fully give in to the vibes, embrace exponentials, and forget that the code even exists."
You describe what you want (often via voice with tools like SuperWhisper), let an LLM-powered agent (e.g., Cursor Composer with strong models like Sonnet) generate, iterate, and debug code, accept changes with minimal review of diffs, paste errors back in, and let the codebase grow organically. It’s ideal for rapid prototyping, throwaway weekend projects, or exploration—lowering the barrier so non-experts or experienced devs can build functional apps quickly without deep syntax knowledge or meticulous oversight. Karpathy demonstrated it by vibe-coding things like a MenuGen app (photo of a restaurant menu → AI-enhanced version with images) in hours, even without prior web/Swift experience.
It took off rapidly because it captured a real shift around early 2025: LLMs had become good enough for coherent, multi-step workflows. It went viral, was covered widely (NYT, Ars Technica, etc.), spawned tutorials and debates, and popularized the idea that "the hottest new programming language is English." Many saw it as democratizing software creation—raising the floor so "anyone can build software." Critics called it reckless for production (bloaty, brittle, security risks), but as a fun/exploratory mode it resonated massively.
Agentic engineering is Karpathy’s evolution (popularized ~early 2026) for professional, high-stakes work. It builds on the leverage of agents but adds discipline, oversight, and quality preservation. "Agentic" because you mostly orchestrate agents (who plan, code, test, debug) rather than writing code directly; "engineering" to stress the art, science, expertise, and rigor required—no compromising on security, correctness, reliability, or maintainability.
Key distinctions from the talk notes and related discussions:
In the Sequoia talk, Karpathy frames this within Software 3.0: prompting/context as the lever over the LLM "interpreter" (vs. Software 1.0 explicit code or 2.0 trained weights). It enables new possibilities beyond speeding up the old world. The Party Is Over: From Vibe Coding To Agentic Engineering, Spec Engineering, System EngineeringThe exuberant early phase of AI coding—the party where anyone could vibe an app into existence by chatting with an LLM—has run its course. What began as liberating fun has matured into something more demanding and powerful. The tools are now too capable, the stakes too high, and the leverage too great for pure vibes. We’re entering an era defined by agentic engineering, sophisticated spec engineering, and broader system engineering that encompasses people, processes, and institutions.The Vibe Coding Era: Fun, Democratizing, But LimitedVibe coding exploded because models crossed a threshold. Suddenly, a skilled pro or enthusiastic amateur could build real software by describing intent, accepting AI outputs, and iterating loosely. It embraced the exponential: more code, faster experiments, forgotten boilerplate. Side projects proliferated; barriers crumbled.
But vibes don’t scale to production systems. Generated code can be bloaty, brittle, or insecure. Without deep understanding, you can’t effectively debug, secure, or evolve complex systems. As Karpathy notes, vibe coding raises the floor—great for accessibility—but professional software demands preserving (or exceeding) prior quality bars. The party ends when you ship to users, handle edge cases, comply with regulations, or maintain long-term.Agentic Engineering: Orchestration with RigorAgentic engineering is the disciplined successor. You act as conductor: specifying goals, orchestrating fleets of agents (planning, coding, testing, deploying), providing oversight, and enforcing verifiability. It’s not "let the AI do it"—it’s engineering with agents as powerful but fallible collaborators.
This mirrors an opera conductor: They don’t play every instrument but shape the whole through precise direction, real-time adjustments, taste, and knowledge of each section’s strengths/weaknesses. Humans retain responsibility for architecture, tradeoffs, ethics, and final judgment. Agents handle execution at scale.
Key practices:
For reinventing an industry (e.g., fintech, healthcare, education), a large, cross-functional team is ideal:
deep domain experts for nitty-gritty details, imaginative thinkers for novel architectures, product/UX for human experience, and engineers for feasibility/verifiability. Imaginative people spot new Software 3.0 possibilities (e.g., LLM-generated dynamic wikis or diffusion-rendered UIs) that pure acceleration misses.
Best practice: Domain experts and visionaries craft/refine the spec; agentic engineers (conductors) implement and oversee. The spec lives, evolves, and serves as living governance. This separates high-quality outcomes from sloppy generation. Tools like annotated Markdown specs that "compile" to stacks illustrate the direction.
Vibe coding skips this; agentic engineering demands it. Poor specs lead to agent drift, unverifiable messes, or security holes. Excellent specs unlock reliable leverage.System Engineering: Beyond Code to People and InstitutionsThe highest level integrates technology with organizations. It’s not just machines/agents but aligning incentives, governance, measurement, culture, and human-AI workflows. Pre-cleared integrations, context lakes, agent registries, HITL protocols, orchestration layers, and provenance/audit systems become infrastructure.
Founders and leaders must think at this scale: Build RL environments for your domain if verifiable; design agent-native processes; ensure "my agent talks to your agent" includes trust, payment, verification.
Institutions (companies, regulators) must adapt to agentic realities—docs for agents, liability for oversight, new education paradigms.
Understanding remains human. Agents amplify it but don’t replace judgment, taste, or accountability.The Road AheadThe party of pure vibes is over, but the real work is more exciting. We gain unprecedented leverage to build new things—entirely novel applications, faster iteration, automation of information processing itself. Success belongs to those who combine deep domain insight, precise specification, rigorous orchestration, and system-level thinking.
Agentic engineering isn’t replacing engineers; it elevates them into conductors, spec architects, and system designers. The floor is higher for everyone; the ceiling, for the disciplined and knowledgeable, is stratospheric. Those who treat agents as interns—capable but needing direction—while owning the vision and verification will define the next decade of software and beyond.
The shift rewards curiosity, rigor, and humanity more than ever. Time to level up.
You describe what you want (often via voice with tools like SuperWhisper), let an LLM-powered agent (e.g., Cursor Composer with strong models like Sonnet) generate, iterate, and debug code, accept changes with minimal review of diffs, paste errors back in, and let the codebase grow organically. It’s ideal for rapid prototyping, throwaway weekend projects, or exploration—lowering the barrier so non-experts or experienced devs can build functional apps quickly without deep syntax knowledge or meticulous oversight. Karpathy demonstrated it by vibe-coding things like a MenuGen app (photo of a restaurant menu → AI-enhanced version with images) in hours, even without prior web/Swift experience.
It took off rapidly because it captured a real shift around early 2025: LLMs had become good enough for coherent, multi-step workflows. It went viral, was covered widely (NYT, Ars Technica, etc.), spawned tutorials and debates, and popularized the idea that "the hottest new programming language is English." Many saw it as democratizing software creation—raising the floor so "anyone can build software." Critics called it reckless for production (bloaty, brittle, security risks), but as a fun/exploratory mode it resonated massively.
Agentic engineering is Karpathy’s evolution (popularized ~early 2026) for professional, high-stakes work. It builds on the leverage of agents but adds discipline, oversight, and quality preservation. "Agentic" because you mostly orchestrate agents (who plan, code, test, debug) rather than writing code directly; "engineering" to stress the art, science, expertise, and rigor required—no compromising on security, correctness, reliability, or maintainability.
Key distinctions from the talk notes and related discussions:
- Vibe coding raises the floor (accessible prototyping); agentic engineering preserves (and raises) the ceiling for skilled practitioners while going faster. The best operators achieve far more than traditional 10x engineers.
- Humans own taste, high-level spec/design, oversight, judgment, and understanding. Agents are like "interns": great recall, weak judgment. You can’t outsource understanding—you direct what you deeply comprehend.
- Verifiability is the unlock: LLMs excel in domains you can check (math, code) and improve via RL in verifiable environments. Much of software is verifiable; the bottleneck shifts to precise specs, evaluation, audits, rollback, and human-in-the-loop (HITL).
- Workflow: Decompose goals, assign to agents/tools, review outputs suspiciously (treat LLMs as "jagged statistical ghosts," not motivated animals), iterate on instructions/specs, maintain governance.
- Broader implications: Agent-native docs, deployments, APIs; multi-agent systems ("my agent talks to your agent"); custom RL for domains; hiring shifts toward big projects testing orchestration/spec skills over puzzle-solving.
But vibes don’t scale to production systems. Generated code can be bloaty, brittle, or insecure. Without deep understanding, you can’t effectively debug, secure, or evolve complex systems. As Karpathy notes, vibe coding raises the floor—great for accessibility—but professional software demands preserving (or exceeding) prior quality bars. The party ends when you ship to users, handle edge cases, comply with regulations, or maintain long-term.Agentic Engineering: Orchestration with RigorAgentic engineering is the disciplined successor. You act as conductor: specifying goals, orchestrating fleets of agents (planning, coding, testing, deploying), providing oversight, and enforcing verifiability. It’s not "let the AI do it"—it’s engineering with agents as powerful but fallible collaborators.
This mirrors an opera conductor: They don’t play every instrument but shape the whole through precise direction, real-time adjustments, taste, and knowledge of each section’s strengths/weaknesses. Humans retain responsibility for architecture, tradeoffs, ethics, and final judgment. Agents handle execution at scale.
Key practices:
- High-quality specs as the source of truth (more on this below).
- Strong loops: context management, tools, evals, memory, rollback, HITL.
- Suspicious oversight: Assume outputs need verification; build auditability.
- Agent-native infrastructure: Docs, APIs, and deployments optimized for agents, not just humans.
For reinventing an industry (e.g., fintech, healthcare, education), a large, cross-functional team is ideal:
deep domain experts for nitty-gritty details, imaginative thinkers for novel architectures, product/UX for human experience, and engineers for feasibility/verifiability. Imaginative people spot new Software 3.0 possibilities (e.g., LLM-generated dynamic wikis or diffusion-rendered UIs) that pure acceleration misses.
Best practice: Domain experts and visionaries craft/refine the spec; agentic engineers (conductors) implement and oversee. The spec lives, evolves, and serves as living governance. This separates high-quality outcomes from sloppy generation. Tools like annotated Markdown specs that "compile" to stacks illustrate the direction.
Vibe coding skips this; agentic engineering demands it. Poor specs lead to agent drift, unverifiable messes, or security holes. Excellent specs unlock reliable leverage.System Engineering: Beyond Code to People and InstitutionsThe highest level integrates technology with organizations. It’s not just machines/agents but aligning incentives, governance, measurement, culture, and human-AI workflows. Pre-cleared integrations, context lakes, agent registries, HITL protocols, orchestration layers, and provenance/audit systems become infrastructure.
Founders and leaders must think at this scale: Build RL environments for your domain if verifiable; design agent-native processes; ensure "my agent talks to your agent" includes trust, payment, verification.
Institutions (companies, regulators) must adapt to agentic realities—docs for agents, liability for oversight, new education paradigms.
Understanding remains human. Agents amplify it but don’t replace judgment, taste, or accountability.The Road AheadThe party of pure vibes is over, but the real work is more exciting. We gain unprecedented leverage to build new things—entirely novel applications, faster iteration, automation of information processing itself. Success belongs to those who combine deep domain insight, precise specification, rigorous orchestration, and system-level thinking.
Agentic engineering isn’t replacing engineers; it elevates them into conductors, spec architects, and system designers. The floor is higher for everyone; the ceiling, for the disciplined and knowledgeable, is stratospheric. Those who treat agents as interns—capable but needing direction—while owning the vision and verification will define the next decade of software and beyond.
The shift rewards curiosity, rigor, and humanity more than ever. Time to level up.
