Andrej Karpathy didn’t “reduce” coding.
He stopped.
Since December 2025, the former Tesla AI director and OpenAI co-founder has been operating at a 20/80 human-to-agent ratio. He calls it “AI psychosis.” 16-hour days directing fleets of autonomous agents that handle the coding, the research, and even his smart home.
This is not a productivity upgrade.
It’s a role change.
The bottleneck moved. Permanently.
For decades, engineering productivity was gated by how fast you could write and reason about code.
That gate is opening.
The new bottleneck is orchestration. How effectively you can direct, manage, and verify a swarm of agents working in parallel.
Karpathy compared it to his PhD days. Back then he was constrained by GPUs. Now the constraint is his ability to think at a higher level of abstraction: defining what should be built and why, not how at the implementation level.
If you’re still measuring yourself by lines of code written, you’re optimizing for a bottleneck that no longer exists.
The constraint didn’t disappear.
It moved up the stack.
Orchestration is not prompting
Most people misunderstand this shift.
This isn’t about writing better prompts. It’s about running systems.
Karpathy describes working with multiple agents that:
- persist context across sessions
- use tools intelligently
- collaborate on subtasks
- iterate toward goals
They behave like a team.
Except:
- they don’t sleep
- they don’t forget
- they scale instantly
This is management without human limits.
Mastery looks less like writing code and more like designing systems of work. You decompose problems into agent-sized tasks, chain them with shared memory and tools, and build verification checkpoints so failures are caught early. You operate at the natural-language layer instead of line-by-line implementation.
Not autocomplete on steroids. Systems thinking applied to agent architecture.
The Dobby example: agents as the universal glue layer
Karpathy built a single agent he calls “Dobby the Elf.”
In one go, Dobby scanned his home network, discovered every connected device, reverse-engineered the APIs for Sonos speakers, lights, HVAC, shades, security cameras, pool, and spa, then wrapped it all into a WhatsApp interface.
Six separate apps collapsed into one conversational system. No manual integration. No glue code.
Now he texts natural-language commands and everything just works.
Agents are becoming the integration layer.
And that layer used to be your job.
AutoResearch: the real inflection point
The most important thing Karpathy shared isn’t a workflow tip. It’s a project.
AutoResearch. Open-sourced. Roughly 630 lines of Python.
It runs a loop:
- design experiment
- write and run training code
- evaluate against clear metrics
- analyze results
- iterate
Repeat 24/7. Zero human in the loop.
When Karpathy ran it overnight on an already well-tuned small model, the agents discovered better configurations (weight decay on value embeddings, Adam beta tweaks) than he had found through weeks of manual work.
This is where the shift becomes uncomfortable.
Agents are now improving the systems that create agents.
That loop is already running.
And it doesn’t require you.
This creates structural asymmetry
Teams that adopt these loops will:
- explore more of the solution space
- iterate faster
- converge on better systems
Everyone else will still be doing manual iteration.
This is not an efficiency gain.
It’s a structural advantage.
And it compounds.
Slow teams don’t catch up.
Why this doesn’t kill engineering. Yet.
Short term, demand increases.
Software becomes cheaper to build. More products become viable. More systems get funded. More engineers are needed to orchestrate all of it.
Classic Jevons paradox.
The thing that makes each unit of work cheaper makes the total volume of work explode.
But the bar changes.
What you’re hired to do changes.
The leverage point shifts upward.
The skills that matter now
If you’re an engineer, this is what now matters:
-
Orchestration over implementation You are directing systems that produce code, not writing most of it yourself.
-
Verification over generation Reviewing agent output like a senior engineer reviews a PR, carefully and skeptically.
-
System design over coding Architecture, constraints, and decomposition now drive leverage.
-
Taste and judgment over raw output When objectives are unclear, human decisions define quality.
Coding becomes a lower-level activity.
Not useless.
But no longer the core leverage.
Where humans still matter: jagged intelligence
Karpathy introduced a useful mental model: AI has “jagged intelligence.”
Superhuman on well-defined, measurable tasks.
Inconsistent to unreliable on nuanced, subjective, or long-horizon work.
Your role is to stay in the loop exactly at the jagged edges:
- where correctness is unclear
- where tradeoffs exist
- where taste matters
- where the agent is drifting off-track
Your value shifts from creation to correction.
Model speciation is coming
We’re not converging on one model that does everything.
We’re moving toward many specialized systems:
- code optimization
- theorem proving
- creative writing
- robotics control
The winning architecture isn’t “send everything to the biggest model.”
It’s routing the right task to the right system.
Open source will matter more than expected
Open models are 6 to 18 months behind closed frontier models.
And closing fast.
They provide:
- control
- flexibility
- customizability
- resilience
Karpathy calls them the “Linux of AI.”
Not always leading.
But foundational.
Don’t sleep on them. Today’s frontier capability is tomorrow’s open-source commodity.
The next frontier is physical reality
Software is being refactored at breakneck speed.
The physical world is not.
Robotics lags badly. Atoms are a million times harder than bits.
But that’s exactly where the next massive wave of value sits.
Sensors. Actuators. Autonomous labs. Real-world data markets.
If you’re building at the intersection of AI and the physical world, you’re on a longer timeline.
But a much larger one.
What you should do right now
Start:
- Spend real hours with coding agents. Push past autocomplete into true orchestration
- Clone AutoResearch. Run it. Understand the loop
- Read AI-generated code the way you’d review a junior engineer’s PR
Stop:
- Measuring productivity by code output
- Ignoring agents because early versions were flaky
- Assuming domain expertise alone is enough
Keep:
- Architecture thinking
- System design
- Taste and judgment
Bottom line
We’re entering what Karpathy calls the “Loopy Era.”
Systems no longer just execute instructions.
They:
- build
- test
- improve themselves
Your role is no longer to write code.
It’s to direct intelligence.
Most people are still optimizing for a world that no longer exists.
That’s the gap.