Meet the new boss, same as the old boss.
I've never felt this much behind as a programmer...
— Andrej Karpathy (@karpathy) December 28, 2025
It’s easy to feel behind right now.
The vocabulary appears to shift daily. MCP, LSP, context engineering, agentic workflows—terms that didn’t exist two years ago. The patterns haven’t crystallized. Even experts are navigating through intuition, waiting for the fog to lift.
Karpathy’s tweet shows that this feeling resonates all the way to the bleeding edge. We’re still getting started with these tools– and they look very different at a glance. A “powerful alien tool” handed around with no manual. A “magnitude 9 earthquake” rocking the profession. He said there’s a 10x boost waiting if you can just figure out how to claim it. A failure to claim it, he said, feels like a “skill issue.”
Karpathy built Tesla’s autonomous driving stack. He led AI at OpenAI. He understands neural networks at the level of gradient descent.
And he feels behind.
Not because he doesn’t know what an LLM is. Because the interface layer—agents, subagents, prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP, LSP, slash commands, workflows—is evolving faster than anyone can document it.
But here’s the thing. That list isn’t the skill issue.
A few days later, Karpathy dropped this:
Aggressively JIT your work...
— Andrej Karpathy (@karpathy) December 30, 2025
“Aggressively JIT your work. It’s not about the task at hand X, it’s a little bit about X but mostly about how you should have had to contribute ~no latency and ~no actions. It’s digital Factorio time.”
Factorio isn’t about clicking faster. It’s about throughput, bottlenecks, ratios, buffers. You design the factory. Then the factory runs. The game rewards systems thinking, not mechanical execution.
“Digital Factorio time” means the same thing for LLMs: stop regenerating the same work. Crystallize it. Build a jig that does the repeatable part so the LLM is freed up for novel synthesis.
But you can’t build a jig if you don’t recognize a repeatable pattern. You can’t express constraints if you don’t know what a constraint is. You can’t manage state if you’ve never thought about what state means.
The skill issue isn’t about learning Claude’s slash commands.
The skill is still the same, fundamentally– data structures, concurrency, design patterns, and schema. It’s understanding the paradigms of a language and knowing what makes a function pure. When the process demands strong consistency vs when eventual consistency is good enough.
These are still the same skills as before– using battle tested data structures and algorithms to build pipelines that build, verify, and publish your work.
Buried in the replies, Karpathy described what this actually looks like in practice:
Claude has been running my nanochat experiments since morning...
— Andrej Karpathy (@karpathy) December 30, 2025
“Claude has been running my nanochat experiments since morning. It writes implementations, debugs them with toy examples, writes tests and makes them fail/pass, launches training runs, babysits them by tailing logs and pulling stats from wandb, keeps a running markdown file of highlights, keeps a running record of runs and results so far, presents results in nice tables, we just finished some profiling, noticed inefficiencies in the optimizer resolved them and measured improvements. It looked at all PRs to the repo and categorized and prioritized them, made commits against some of them etc.”
“I’m still very much in the loop. It made subtle mistakes that I had to point out. It got confused a few times and (amusingly) admitted that what it said was a ‘brain fart’ (verbatim quote hah). It has missed a few ideas that I had to pitch. It made a bunch of bad design decisions that bloat the code and coupled abstractions that I had to revert. It’s not perfect but I’m used to doing all of these things manually, so just seeing it running on the side cranking away at larger scope problems and coordinating all these flows in relatively coherent ways is definitely a new experience and a complete change of workflow.”
This is the JIT workflow in action. The LLM isn’t writing the architecture. Karpathy is. The LLM is running the factory floor while Karpathy manages the constraints, catches the mistakes, reverts the bad abstractions.
The 10x isn’t in the LLM doing the thinking. It’s in the LLM doing the latency—the mechanical execution—while the human stays in the loop on judgment.
Vibecoding offers something genuinely new: the ability to spin up working software fast. A microservice in an afternoon. A CLI tool before lunch. A prototype that actually runs, not a design doc that sits in a folder.
This is real. The constraint used to be “can I build this at all?” Now it’s “should I build this, and can I maintain it?”
Because vibecoded software has a shelf life. The LLM doesn’t know where the boundaries are, so it creates dependencies everywhere, reaches into files it shouldn’t touch, builds brittle, coupled parts. You end up with something that works today and becomes a maintenance headache next month.
The freedom is real. But so is the cost.
This is where the old discipline comes back.
Not as gatekeeping. Not as “you must understand pointers before you’re allowed to code.” As the solution to the maintenance problem.
When you recognize a repeatable pattern, you can crystallize it. Turn the vibe session into a jig—a small, hardened tool that does one thing reliably. Now that operation runs at machine speed, zero variance, and the LLM is freed up for novel synthesis instead of regenerating the same transformation with slightly different bugs each time.
Build enough jigs and you have a library. String them together and you have a pipeline. This is what Karpathy means by “JIT everything”—not just-in-time compilation, but just-in-time tooling. The task appears, you build or grab the tool, the tool handles the latency, you stay in the loop on judgment.
The jigs aren’t everything. They’re cheap. That’s the point. A transpiler that used to take months now takes hours. A validation step that used to be “too expensive to build” is now trivial. The cost matrix changed, so the calculus of what’s worth hardening changed with it.
Pipelines are built from these production modules. CI/CD, build systems, verification steps—they’re all jigs wired together. The skill is knowing which parts to crystallize and which to leave flexible. When to let the LLM improvise and when to lock it down into something repeatable.
This is the same skill it’s always been. It just matters more now.
Karpathy’s earthquake metaphor is apt. The ground is shifting.
But what survives earthquakes?
Structures built on solid foundations.
The vibe coders who are struggling aren’t struggling because the tools are too new. They’re struggling because they never learned the discipline underneath. They can’t compress intent because they don’t know what compressed intent looks like. They can’t crystallize process into jigs because they don’t recognize repeatable patterns. They can’t manage complexity because they never learned what complexity actually is—just the symptoms.
Karpathy is right that there’s a 10x waiting. But it’s not in the tooling. It’s in the knowhow.
None of this is new. It’s functional programming. It’s schema-driven development. It’s the old discipline, applied to a new substrate.
Karpathy is probably not actually lost. He’s signaling solidarity with those who are.
That fog is real. The cognitive load of mastering a new vocabulary before clarity arrives is exhausting. People are suffering under it. Karpathy knows this because he talks to them, because he reads the replies, because he’s watching the profession buckle under the weight of too much change too fast.
His framing is humble. It says: I feel this too. We’re all figuring it out.
But here’s the thing about fog: it lifts.
And when it does, the landscape underneath will look familiar. State machines. Pure functions. Constraints and invariants. The old discipline, waiting where we left it.
The “powerful alien tool” isn’t that alien. It’s a very fast, very approximate collaborator with no memory and questionable judgment.
We’ve been managing collaborators like that forever.
The skills for doing it already exist. The people who have them are the ones claiming the 10x. The people who don’t are the ones feeling the earthquake.
The skill issue is real. But it’s the same skill issue it’s always been.
Meet the new boss. Same as the old.