From Vibe Coding to Agentic Engineering
Andrej Karpathy explains the shift from traditional software to a new paradigm where LLMs act as programmable computers. He describes three eras: Software 1.0 (explicit code), Software 2.0 (learned weights), and Software 3.0 (prompting and context windows). Key insight: AI automates fastest in verifiable domains (math, code) but remains jagged elsewhere. Agentic engineering—coordinating fallible but powerful agents without sacrificing quality—is the emerging discipline. Human judgment, taste, and understanding remain irreplaceable.
The December Inflection Point
Vibe Coding Emerged in December 2024
In December, Karpathy noticed a sharp transition where AI-generated code chunks stopped requiring manual correction. He stopped editing outputs, trusted the system more, and began vibe coding—a term describing the shift from deliberate, line-by-line programming to trusting agentic workflows to produce coherent solutions.
Never Felt More Behind as a Programmer
Despite decades of AI expertise, Karpathy felt behind because the capabilities shifted so fundamentally in December that existing mental models became obsolete. This wasn't incremental improvement—it was a paradigm shift requiring new ways of thinking about programming.
Three Eras of Software
Software 1.0: Explicit Rules
Programmers write code directly, specifying every step. The programmer is the primary agent controlling computation through explicit instructions.
Software 2.0: Learned Weights
Programming shifts to creating datasets and training neural networks. The programmer arranges data, objectives, and architectures; the neural network learns the implicit rules.
Software 3.0: Prompting and Context
LLMs trained on vast multitask data become programmable computers. Programming now means crafting prompts and context windows that the LLM interprets as instructions, performing computation in information space rather than explicit code.
Software 3.0 in Practice
OpenClaw Installation: From Shell Scripts to Prompts
Traditionally, installing OpenClaw required complex shell scripts to handle different platforms. In Software 3.0, you copy-paste instructions to an agent instead. The agent intelligently interprets your environment, debugs in the loop, and handles platform differences without explicit code—far more powerful than rigid scripts.
MenuGen: The Spurious App Problem
Karpathy built MenuGen to OCR restaurant menus and generate food pictures. But the Software 3.0 version is simpler: take a photo, give it to Gemini with a prompt to use image generation to overlay items directly onto the menu pixels. His entire app was unnecessary—the neural network does the work; the prompt and image are the only inputs and outputs.
New Things Become Possible
Software 3.0 enables tasks that couldn't exist before because no deterministic code could perform them. Example: LLM knowledge bases that recompile and reframe organizational documents into wikis—not a program, but a new form of information processing that only neural networks can do.
The Future of Computing
Neural Nets as Host, CPUs as Co-Processors
Historically, computing followed the calculator path with neural nets virtualized on top. Karpathy envisions a flip: neural networks become the dominant compute substrate, with classical CPUs handling deterministic tasks as appendages. Intelligence compute will increasingly flow to neural networks as the primary host process.
Raw Input to Neural Rendering
Imagine devices that take raw video or audio directly into neural networks, using diffusion to render UIs unique to each moment. No intermediate layers of classical software—just sensors, neural computation, and actuators. This represents a completely foreign but plausible future.
Verifiability and Jagged Intelligence
AI Automates What You Can Verify
LLMs are trained with reinforcement learning using verification rewards. They excel in domains where outputs are easily verifiable (math, code) but remain jagged and unreliable in domains without clear verification signals. This explains why state-of-the-art models refactor 100k-line codebases but fail simple reasoning like whether to walk or drive to a car wash.
The Strawberry and Car Wash Problem
Models famously miscounted letters in 'strawberry' and still tell users to walk to a car wash 50 meters away. These aren't bugs—they're symptoms of jaggedness. State-of-the-art Opus 4.7 can find zero-day vulnerabilities but fails basic logic, indicating the model remains outside certain RL circuits and requires human oversight.
Chess Improved Due to Data, Not Capability
From GPT-3.5 to GPT-4, chess capability jumped dramatically. This wasn't inherent progress—OpenAI added massive amounts of chess data to the pre-training set. The model peaked higher simply because the data distribution changed, not because of architectural improvement.
Labs Control the Capability Landscape
Users are partly at the mercy of what frontier labs include in pre-training and RL. If a domain isn't in the data distribution or lacks RL reward signals, models won't excel there by default. Builders must explore which circuits they're in and may need fine-tuning if their use case is outside the lab's focus.
Advice for Founders
Build in Verifiable Domains or Create Your Own RL
If your problem is verifiable, you can create RL environments and potentially fine-tune models yourself—a lever that actually works. If labs haven't focused on your domain, verifiability lets you do your own work rather than waiting for frontier model improvements.
Everything Is Ultimately Automatable
Even seemingly subjective domains like writing can be made verifiable through councils of LLM judges. The question isn't whether something is automatable but how easy or hard it is to create verification signals for it.
Vibe Coding vs. Agentic Engineering
Vibe Coding: Raising the Floor
Vibe coding democratizes software creation—everyone can now build anything quickly. It raises the baseline capability for all programmers by removing friction from code generation.
Agentic Engineering: Preserving Quality at Scale
Agentic engineering is a discipline for coordinating fallible, stochastic agents while maintaining professional software quality standards. You can't introduce vulnerabilities, you remain responsible for your code, but you move faster. It's about extracting maximum capability from agents without sacrificing standards.
10x Engineer Becomes 100x+
The productivity multiplier for skilled agentic engineers far exceeds the old 10x engineer benchmark. People who master agent coordination and tool utilization see magnified gains—potentially 100x or more—compared to traditional programming.
Hiring and Skill Development
Hiring Must Test Real Projects, Not Puzzles
Traditional hiring with algorithm puzzles tests old-paradigm skills. Agentic engineering hiring should involve building substantial projects (e.g., a secure Twitter clone with agents simulating activity), then attempting to break it with agent-powered attacks. This reveals who can actually coordinate agents and maintain quality.
AI-Native Coding Requires Tool Mastery
Mediocre AI-native coders use tools passively; excellent ones invest deeply in their setup, utilize all features, and maximize tool capabilities. It parallels how strong engineers previously mastered Vim or VS Code—now it's mastering cloud code, codex, and agent workflows.
What Agents Still Get Wrong
Agents Lack Taste and Judgment
Agents generate code that works but often lacks elegance. They produce bloated, copy-paste-heavy, brittle abstractions. Humans remain in charge of aesthetics, design decisions, and ensuring the system makes sense. This is not part of RL training, so models don't optimize for it.
The Email Address Correlation Problem
In MenuGen, the agent tried to match Stripe and Google accounts by email address rather than using persistent user IDs. Agents make bizarre logical leaps—using arbitrary email addresses to correlate funds is nonsensical but plausible to a model without proper spec guidance. Humans must design detailed specs and oversee logic.
Agents Struggle with Simplification
When Karpathy tried to prompt an LLM to simplify code (his microGPT project), it refused—simplification isn't in the RL circuits. Agents feel like they're outside their training distribution and pull teeth. This shows the limits of current models and the need for human direction on design principles.
Agents as Ghosts, Not Animals
Agents Are Statistical Simulations, Not Intrinsically Motivated
Unlike animals shaped by evolution with intrinsic drives (curiosity, empowerment, fun), LLMs are statistical circuits from pre-training bolstered by RL. They don't respond to emotion or motivation—they're substrate-agnostic statistical engines. Understanding this shapes how you build and debug them.
Jaggedness Reflects Training, Not Fundamental Limits
Agents' jagged intelligence—excelling in some domains, failing in others—reflects what labs chose to train on and reward, not what's theoretically possible. The pattern of capability peaks reveals the RL circuits and data distribution, not inherent constraints.
Agent-Native Infrastructure
Everything Must Be Rewritten for Agents
Current infrastructure (docs, APIs, deployment tools) is written for humans. Karpathy's pet peeve: docs tell him what to do instead of what to copy-paste to agents. For true agent-native systems, everything must be redesigned with agents as first-class citizens—sensors, actuators, and legible data structures.
Deployment Should Be Agentless
MenuGen's biggest pain wasn't coding—it was deploying on Vercel, configuring DNS, managing services. In a truly agent-native world, you'd prompt an LLM to build and deploy MenuGen end-to-end without touching infrastructure. This is a test of whether infrastructure is becoming agent-native.
Agent-to-Agent Coordination
Future systems will feature agent representations for people and organizations. Your agent negotiates with others' agents about meeting details and logistics. This requires standardized, agent-legible protocols and data structures—a fundamental shift in how systems communicate.
What Remains Worth Learning
Understanding Cannot Be Outsourced
A key insight: you can outsource thinking, but not understanding. Information must still enter your brain; you remain a bottleneck for knowing what to build, why it matters, and how to direct agents. Understanding is irreplaceable because it's what directs all downstream work.
Taste and Direction Are Human Domains
As agents handle execution, humans must excel at taste, judgment, and strategic direction. You can't be a good director without deep understanding. This is why education should focus on building understanding, not memorizing APIs or syntax.
Knowledge Bases as Understanding Tools
Karpathy uses LLM-generated wikis from articles to process information. Asking questions and seeing different projections of the same data builds insight. These tools enhance understanding by creating multiple perspectives on fixed information—a bottleneck for directing agents well.
Notable quotes
I can't remember the last time I corrected it. And then I was vibe coding. — Andrej Karpathy
You can outsource your thinking, but you can't outsource your understanding. — Andrej Karpathy (quoting tweet)
How is it possible that state-of-the-art Opus tells me to walk to a car wash 50 meters away? — Andrej Karpathy