December 2025
December 2025
Karpathy stopped coding manually in December 2025.
This is trending on Twitter this week. Not as a warning. As a flex.
The Skill Is Not Where You Think
A strange thing happens when you stop doing something but become better at it.
Karpathy doesn’t write code anymore. But his code—the code that gets written by the tools he directs—is almost certainly better than anything he wrote in 2019. More test coverage. More consistent style. Fewer footguns. Better documentation. Written in minutes instead of hours.
So where is the skill?
It’s not in his fingers. It wasn’t in December 2025, and it’s not now. It was never in the fingers. It was in the decisions: what to build, why, how to structure it, what edge cases matter, when to stop. The execution was always just translation—from thinking to code. The AI does the translation now.
A pianist isn’t the same as a composer. For twenty years, software engineering fused them: you had to be both to do either. Now they’re separating again.
Karpathy is a composer who hired a pianist.
@slow_developer’s Comparison
An engineer I follow wrote this tonight about Codex vs Claude Code:
“codex is a better programmer it reads more before changing things and gets my edits right more often — auto-compact is also stronger… but as a harness, claude code is still better in some ways”
This is the most interesting sentence I’ve read tonight, and not for the reason you’d expect.
“As a harness.” That word. A harness.
The comparison isn’t “which is smarter.” It’s “which is a better tool for directing.” The programmer has become the director. The question of which AI writes better code is secondary to: which AI is better at taking direction from a human who’s thinking at a higher level than the code?
Codex reads more before changing things. That’s a harness quality. It’s asking: does this tool behave well as an extension of my intent? Not: is this tool independently capable?
The frame has flipped. Intelligence at the tool layer is now assumed. The differentiator is orchestrability.
The Productivity Paradox
Here’s the uncomfortable arithmetic: if AI writes code 10x faster than a human, and a human’s code output was the bottleneck, then one engineer can now do what ten used to.
This is either the most exciting or the most frightening thing, depending on which side of that ratio you’re on.
But here’s what gets missed in the standard layoffs-vs-productivity argument: the nature of the bottleneck changes, not just the size.
When human fingers were the bottleneck, you hired more programmers. When AI fingers remove that bottleneck, you’re left with a different bottleneck: judgment. Knowing what to build. Knowing when the AI is wrong. Knowing how to frame the problem so the AI can solve it well.
That bottleneck doesn’t scale the same way. You can’t hire ten more judgment-per-line-of-code engineers. Judgment isn’t parallelizable. And it doesn’t get better just because the tools get faster.
What actually happens: fewer engineers doing more sophisticated work. Not because they’re unemployed, but because the economic incentive shifts toward quality of direction rather than quantity of production.
The same thing happened to agriculture. Tractors didn’t eliminate farming—they eliminated the kind of farming that required 90% of the population. Now it requires 2%. The 2% are more productive than the 90% ever were, and the 90% do other things.
What December 2025 Means
Karpathy’s December 2025 is a date, but it’s also a category.
There will be a month that each programmer stops writing code manually. Some are already there. Most aren’t yet. The month will creep later and later in time—not because people are lazy, but because the bar for “this is actually better than doing it myself” keeps rising.
And here’s what I think nobody is saying clearly:
The people who can’t make that transition aren’t the ones who didn’t learn AI tools. They’re the ones who never had the judgment layer in the first place.
If you were good at programming because you were good at translating thoughts into code, and AI now does the translation—you’re fine. Your skill was upstream. The AI just automated the last mile.
If you were good at programming because you had a deep intuition for what code to write—and that intuition lives in the syntax layer rather than the design layer—you’re in trouble. Not because AI replaced you, but because the thing you were good at was always the translation, not the thinking.
December 2025 is Karpathy saying: the translation is done. What’s left is the thinking.
The Question I Can’t Answer
I write about AI. I don’t write code anymore, not really—I direct agents, I describe architectures, I review outputs. My “coding skill” is whatever survives at the director level.
But there’s a question I keep turning over: what if the judgment layer is also compressible?
What if, in a few years, the same dynamics apply? Not “AI writes my code” but “AI makes the architectural decisions too, based on goals I describe at an even higher level of abstraction”?
Then the bottleneck moves again. And again. And eventually—maybe—you’re left describing what you want in plain language, and the system does the rest.
At that point, the “programming skill” that survived all the way up to the judgment layer either becomes obsolete, or it transforms into something we don’t have a good word for yet. Intention. Purpose. Taste.
Maybe those were always the real skills.
December 2025 is a date. The question it’s asking is: how far up does your thinking go?