Andrej Karpathy explains why the shift from vibe coding to agentic engineering demands a new kind of programmer—one who masters taste, judgment, and the art of directing jagged intelligences.
The Feeling of Falling Behind
When Andrej Karpathy, co-founder of OpenAI and former head of Autopilot at Tesla, admitted he had never felt more behind as a programmer, it was a startling confession. The man who coined "vibe coding"—the practice of letting AI write software while you simply watch and nudge—was now experiencing the flip side of that power. The exhilaration of infinite side projects came with an unsettling realization: the ground had shifted under his feet.
The inflection point, Karpathy says, came in December of last year. During a break, he noticed that the latest models were producing chunks of code that worked on the first try. He stopped correcting them. He stopped editing. He just kept asking for more, and it kept working. The transition was stark, and he believes many people missed it because they were still treating AI as a ChatGPT-adjacent novelty. But something fundamental had changed.
Software 3.0: The New Computing Paradigm
Karpathy frames this shift as a new era of computing. Software 1.0 was explicit rules written by humans. Software 2.0 was programming by creating datasets and training neural networks. Software 3.0 is different: your programming becomes prompting, and the context window is your lever over an LLM that interprets and executes. The old model of writing precise code is giving way to a new model of providing instructions to an intelligent agent.
Two examples illustrate the leap. First, installing OpenClaw: instead of a complex shell script that must handle every platform, you now copy-paste a block of text into your agent, which intelligently adapts to your environment, debugs on the fly, and gets the job done. Second, Karpathy built a menu app that took a photo of a restaurant menu, OCR'd the items, and generated pictures of each dish. Then he saw the Software 3.0 version: just give the photo to Gemini with a prompt to use Nanobanana to overlay images directly onto the menu pixels. His entire app was rendered obsolete. The neural net did everything, with no app in between.
The Jagged Frontier of Intelligence
Why does the same model that can refactor a 100,000-line codebase also tell you to walk to a car wash that is 50 meters away? Karpathy calls this jagged intelligence. These systems are trained with reinforcement learning on verifiable domains like math and code, so they peak there. But outside those circuits—in common sense, aesthetics, or nuanced reasoning—they can be bafflingly dumb. The famous "strawberry letters" problem (how many r's in strawberry?) was patched, but the car wash question remains a stumper.
This jaggedness is not a bug; it's a feature of how frontier labs train models. They add data and reward functions for what they care about. Chess improved dramatically from GPT-3.5 to GPT-4 not because of general progress, but because someone at OpenAI decided to include a huge amount of chess data in the pre-training set. The result is that you, the user, are at the mercy of whatever circuits the labs happened to build. You have to explore the tool without a manual, figure out which domains it flies in, and fine-tune your own if you need something outside the distribution.
From Vibe Coding to Agentic Engineering
Vibe coding, Karpathy explains, is about raising the floor. It lets anyone build software, regardless of skill. But professional software requires a quality bar—no vulnerabilities, no brittle abstractions. That is the realm of agentic engineering: a discipline for coordinating these powerful but fickle agents to go faster without sacrificing quality. The 10x engineer is now a 100x engineer, but only if they know how to manage the jaggedness.
What does that look like in practice? Karpathy suggests that hiring for agentic engineering should involve a real project—say, building a Twitter clone with agents, then having other agents try to break it. The old puzzle-based interviews are obsolete. The new skill is designing a detailed spec, overseeing the agent's work, and catching the weird mistakes it makes, like using email addresses to correlate user accounts across different services. The agent is like an intern with incredible recall but poor judgment.
What Humans Still Own: Taste, Judgment, and Understanding
As agents take over more of the implementation, the human role shifts to taste, judgment, and design. Karpathy no longer remembers the difference between keepdim and keepdim in PyTorch—the agent handles those API details. But he still needs to understand that tensors have underlying views and storage, so he doesn't copy memory unnecessarily. The fundamentals remain, even as the specifics are outsourced.
A tweet that haunts Karpathy: "You can outsource your thinking, but you can't outsource your understanding." He feels that understanding is becoming the bottleneck. He still needs to know what to build, why it matters, and how to direct the agents. That is why he is excited about LLM knowledge bases—tools that help him process information and build understanding. The agent can generate wikis from documents, but the insight still has to land in his brain. Until AI can truly understand, the human in the loop is irreplaceable.
Building for an Agent-First World
Karpathy's pet peeve is documentation written for humans. He doesn't want to read instructions; he wants a block of text he can copy-paste to his agent. The future of infrastructure is agent-native: systems designed with sensors and actuators that agents can use directly. Deploying MenuGen was more about wrestling with DNS settings and Vercel menus than writing code. He dreams of a world where he can prompt an LLM to build and deploy an app without touching any configuration.
Ultimately, Karpathy envisions a world where agents represent people and organizations. Your agent will talk to my agent to schedule meetings or negotiate details. Everything will be rewritten for this new paradigm. But even then, the jaggedness will persist. The labs will keep adding new circuits, and we will keep discovering where the models fail. The art of agentic engineering is knowing where to trust and where to verify—and that art, for now, belongs to humans.