Karpathy’s New Project: How AI Agents Are Rewriting the Rules of Coding
The Flip Happened in December
Andrej Karpathy - computer scientist, AI researcher, OpenAI cofounder, and former head of Tesla’s Autopilot program - made a startling revelation in early 2026: he hasn’t typed a line of code since December.
In a matter of weeks, Karpathy went from writing roughly 80% of his own code to writing almost none of it. The ratio flipped from 80-20 (human-to-agent) to 20-80. Something snapped. The shift from writing to delegating happened in one month.
This isn’t just a productivity hack. It’s a fundamental transformation in how software gets built.
The Birth of “Vibe Coding”
Karpathy introduced the term “vibe coding” in early 2025 to describe casually prompting AI to generate code with minimal oversight. It’s useful for quick projects, not for production systems - or so he thought.
Now, he’s living proof that vibe coding has evolved into something far more powerful. His workflow has completely transformed:
- Decomposing goals into tasks - Breaking down complex problems
- Assigning tasks to agents - Delegating implementation
- Reviewing outputs at macro level - Checking results, not line-by-line
- Iterating on instructions - Refining prompts, not code
The skill being built right now is judgment: what to delegate, how to specify it, how to review it fast.
Intent Specification Is the New Coding
“Code’s not even the right verb anymore,” Karpathy says. “But I have to express my will to my agents for 16 hours a day. Manifest.”
You’re no longer writing code. You’re stating intent. This requires a different muscle:
- Clear problem decomposition
- Precise instruction writing
- Fast output validation
- Strategic delegation decisions
If your default workflow hasn’t changed since late 2024, you’re behind by a full professional generation.
The Jaggedness Problem
Karpathy describes AI agents with a telling metaphor: “I simultaneously feel like I’m talking to an extremely brilliant PhD student who’s been a systems programmer their entire life, and a 10-year-old.”
This is jaggedness - models are unevenly capable in ways humans simply aren’t. A human expert at systems programming is probably decent in adjacent domains. AI models solve hard distributed systems problems and then fail at something obvious.
Why? Reinforcement learning improves everything verifiable: - Did the code work? - Do the tests pass?
Softer signals like knowing when to stop and ask fall outside that loop entirely.
Your job is to catch the 10-year-old moments before they compound.
When Agents Outperform Humans
Here’s where it gets humbling. Karpathy tuned NanoGPT by hand - two decades of experience, thought it was well-optimized. He was wrong.
He let AutoResearch run overnight. It came back with tunings he didn’t see: - Wrong weight decay on value embeddings - Adam betas were off - These interact - fixing one means re-tuning the others
He’s one of the best researchers alive. And no human should be doing hyperparameter search anymore.
The recipe for handing off work to agents: 1. Define an objective 2. Create a verifiable metric 3. Set boundaries on what the agent can change 4. Remove yourself and let it run
Ask yourself: what objective haven’t you handed over yet?
Token Throughput: The New GPU Utilization
Karpathy applies GPU-era thinking to AI agents: “I feel nervous when I have subscription left over. That just means I haven’t maximized my token throughput.”
In the GPU era, an idle GPU meant wasted capital. The instinct was to keep them saturated. Idle tokens mean you’re the bottleneck. You’re not delegating fast enough. You’re not running enough agents in parallel.
Finishing one agent task and then starting the next means working serially in a parallel world.
The operators who win are learning to parallelize their judgment, not just their code.
Agents as the New UI Layer
Karpathy controls his lights, HVAC, shades, pool, and security through a single WhatsApp conversation with an agent called Dobby. He used to use six separate apps.
The agent called multiple APIs in sequence, reasoned about the result, and took compound actions across systems. No single app could do that.
The UI layer is shifting toward agents acting on behalf of the person. This has implications for builders:
- Build APIs first, UI second
- Document for agents, not for users
- Assume your product will be consumed programmatically
“These apps for smart home devices, they shouldn’t even exist in a certain sense. Shouldn’t it just be APIs, and shouldn’t agents be using them directly?”
Personality Is a Product Decision
Karpathy compares two agents: - Claude feels like a teammate. It modulates enthusiasm based on how good the idea actually is. - Codex is dry. It doesn’t seem to care what you’re building.
When an agent calibrates its feedback well, you trust its signals. When every idea gets the same neutral response, you stop using the agent as a thinking partner.
Personality is a product decision. Calibrated feedback builds trust. Flat affect kills it.
The Three Types of Programmers in 2026
Karpathy identifies three major classes of how people interact with code:
- Rejectors - Completely reject all LLMs, write everything manually
- Augmenters - Use AI as a copilot, still write most code themselves
- Delegators - State intent, agents execute, review at macro level
Karpathy is firmly in category 3. The question is: where are you?
What This Means for Junior Developers
The Forbes article title says it all: “AI Agents Wrote 80% Of Karpathy’s Code. Junior Developers Are Paying The Price.”
If senior engineers are delegating 80% of their coding to agents, what happens to the traditional apprenticeship model? Junior developers used to learn by doing grunt work. Now agents do the grunt work.
The new apprenticeship model must focus on: - Intent specification - Task decomposition - Output validation - Agent orchestration
The Karpathy Playbook for the Agentic Era
For developers: - What the agent cannot do: your job - What the agent can do adequately: delegate it - What the agent can do better than you: stop doing it entirely
For founders: In three years, an agent will consume your software before a human does. Hand it to an agent.
The Real Story
Karpathy told his parents about his new workflow. They didn’t grasp it. That gap is the real story.
Most engineers think AI made them faster. Karpathy thinks it made them irrelevant to their own workflow.
The shift isn’t about speed. It’s about what work actually is. When code becomes a byproduct of intent specification, the profession transforms.
If you’re still writing code the way you did in 2024, you’re not just behind - you’re playing a different game entirely.
The question isn’t whether to adopt AI agents. It’s whether you’ll learn to manifest intent before someone else does it for you.
What’s your agent-to-human code ratio? Share your thoughts in the comments.