The Magnitude 9 Earthquake in Programming (And Why Even Karpathy Feels Behind)
This is the crux of it. The tools exist. The capability exists. But almost nobody has figured out how to actually wield them effectively.
Andrej Karpathy just said something that should make every developer stop and think.
“I’ve never felt this much behind as a programmer.”
That’s not some junior dev venting on X. That’s Andrej Karpathy. Founding member of OpenAI. Former AI director at Tesla. The guy who literally coined “vibe coding” and “jagged intelligence”
If he feels behind, what hope do the rest of us have?
(Probably none. But we are here anyway.)
The Numbers Are Wild. And They Contradict Each Other.
Here’s the headline stat: 84% of developers now use or plan to use AI tools in their workflow. And 41% of all code written in 2025 is AI-generated.
That’s not a typo. Nearly half.
Microsoft’s CEO and Google’s CEO both claim about 25% of their companies’ code is now AI-generated. Dario Amodei predicted that within six months, 90% of all code would be written by AI.
So we should all be 10X more productive, right?
Well. Here’s where it gets weird.
A rigorous study by METR took 16 experienced open-source developers (people with an average of 5 years working on their own repos) and measured what actually happens when they use AI tools.
The result? Developers took 19% longer to complete tasks with AI than without it.
But those same developers estimated they were 20% faster.
They felt faster. They weren’t.
Which is very human, really. We have always been better at confidence than accuracy.
The Perception Gap Is Real
The 2025 Stack Overflow survey paints a similar picture. Positive sentiment for AI tools has actually dropped, from over 70% in 2023-2024 to just 60% in 2025. Only 52% of developers agree AI has had a positive effect on their productivity.
And here’s the frustration that hit home for me: 66% of developers cited their biggest annoyance as “AI solutions that are almost right, but not quite.”
Almost right. But not quite.
That’s the cognitive tax Karpathy is talking about. You are not just writing code anymore. You are also reviewing code, debugging AI suggestions, figuring out if the thing that looks correct actually is correct, and building mental models for systems that behave differently every time you ask.
The DORA report (Google’s annual state of DevOps research) found that speed and stability have actually decreased with increased AI use. There’s a 7.2% drop in delivery stability. Teams are shipping faster in some ways but introducing more bugs and more technical debt.
Everything’s fine. Probably.
The New Programmable Layer of Abstraction
This is the part of Karpathy’s post that really resonated:
“There’s a new programmable layer of abstraction to master (in addition to the usual layers below) involving agents, subagents, their prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP, LSP, slash commands, workflows, IDE integrations...”
Just reading that list is exhausting.
And he is right. We are not replacing the old stuff. We are adding on top of it.
You still need to know how databases work. You still need to understand networking. You still need to write tests (or at least review the ones AI writes for you). But now you also need to understand how to prompt effectively, when to trust AI output versus when to verify, how context windows affect results, which tools to chain together, what MCP servers to connect, how to structure agent workflows.
It’s not simpler. It’s more complex. The complexity just shifted.
(This is the part where everyone pretends to understand.)
The Skill Issue
Karpathy frames it bluntly:
“I have a sense that I could be 10X more powerful if I just properly string together what has become available over the last ~year and a failure to claim the boost feels decidedly like skill issue.”
This is the crux of it. The tools exist. The capability exists. But almost nobody has figured out how to actually wield them effectively.
The manual does not exist. The earthquake is happening anyway.
And the evidence backs this up. Studies show that less experienced developers actually benefit more from AI tools than experts do. Junior developers at Microsoft, Accenture, and Fortune 100 companies saw bigger productivity gains than their senior counterparts.
Because for juniors, AI fills knowledge gaps. For experts, AI sometimes gets in the way of deeply ingrained workflows.
Meanwhile, employment among software developers aged 22-25 fell nearly 20% between 2022 and 2025. The entry-level funnel is shrinking right as the skill floor is rising.
Nobody said any of this would be fair.
The Manual That Doesn’t Exist
“Clearly some powerful alien tool was handed around except it comes with no manual and everyone has to figure out how to hold it and operate it.”
This hits hard because it’s literally true. There’s no certification. No standard curriculum. No agreed upon best practices.
Everyone’s figuring it out in real time. Some developers are crushing it, automating whole workflows, shipping features 3X faster. Others are spending more time fixing AI-generated bugs than they would have spent writing the code themselves.
The difference? It’s not intelligence. It’s not years of experience. It’s pattern recognition for a completely new paradigm.
Some people are good at this.
Most of us are just... here. Trying.
What Actually Works (From What I’ve Seen)
I’m not going to pretend I have this figured out. But here’s what seems to separate the developers thriving in this chaos from those drowning:
They treat AI as a first draft, not a final answer. The almost-right problem means you can’t just accept suggestions. But you can use them as scaffolding.
They’ve developed a “smell test” for AI output. Experienced devs know when code feels wrong even if they can’t immediately say why. That instinct matters more now than ever.
They’re explicit about context. Better prompts, structured inputs, clear constraints. Garbage in, garbage out. The principle applies double now.
They know when NOT to use AI. Sometimes the setup cost isn’t worth it. Sometimes you’re faster just writing the damn thing yourself. This requires honesty most people don’t have.
They’re building systems, not just using tools. Chaining tools together, creating workflows, automating the automation. It’s meta, but it’s where the 10X gains actually live.
The Earthquake Is Still Happening
Karpathy called it a “magnitude 9 earthquake.” And the thing about earthquakes is: they don’t pause so you can catch up.
Trust in AI tools is declining even as adoption increases. 46% of developers say they don’t trust AI-generated outputs. And yet nearly half of all code is AI-generated.
That’s a tension that has to resolve somehow.
My honest take? The developers who will come out ahead aren’t necessarily the ones who use AI the most. They’re the ones who figure out the mental model. Who understand when AI accelerates and when it drags. Who build intuition for a fundamentally stochastic process.
Because here’s the uncomfortable truth: the ceiling has gone up, but so has the floor. And standing still isn’t an option.
Roll up your sleeves.
(Everyone else already has. Probably.)
What’s your experience been with AI coding tools? Are you actually faster, or does it just feel that way? Hit reply. I genuinely want to know.