How AI Affects Junior Developer Skills: The Errors You Never Hit
What Anthropic's 2026 trial really found, and how to keep learning while you use AI.
Two junior developers get the same ticket: learn an unfamiliar library and ship a feature. The first asks the AI for the code, pastes it, and is done in twenty minutes without a single error. The second asks the AI what the library's core idea is, writes the code herself, and spends the afternoon fighting stack traces.
Quiz them afterward on the code they just wrote. The second one wins comfortably.
That's roughly what a randomized trial from Anthropic found in January 2026. The headline got shared everywhere. The mechanism underneath it mostly didn't, and the mechanism is the part that changes how you should work.
What the study measured
Researchers Judy Hanwen Shen and Alex Tamkin gave 52 mostly junior engineers two tasks using Trio, an async Python library none of them knew. Everyone had at least a year of weekly Python. Half had an AI assistant that could write correct code on demand; half coded by hand. Then everyone took a quiz focused on debugging, code reading, and concepts.
AI group: 50% average
Hand-coding group: 67% average
Gap: 17 points, roughly two letter grades, biggest on debugging
Speed: the AI group was about two minutes faster, not a statistically significant difference
The part that got missed: who hit errors
The researchers sorted AI users by behavior:
AI delegation (4 people): AI wrote everything. Fastest finish, few or no errors, quiz average under 40%.
Conceptual inquiry (7 people): asked the AI only conceptual questions, wrote the code, hit many errors, fixed them alone. Scored 65% or higher and was the second-fastest group overall.
Generation-then-comprehension (2 people): generated code, then asked follow-ups until they understood it. The researchers note it looked nearly identical to delegation. It scored well anyway.
The hand-coders also hit more errors than the AI group, including errors on exactly the concepts the quiz tested. The authors' hypothesis: resolving those errors independently is what built their debugging skill.
AI didn't make anyone worse. It removed their mistakes, and the mistakes were the lesson.
The mental model: experience is a count, not a calendar
Experience is closer to the number of errors you personally untangled than to years served or lines shipped. Each error runs the same loop:
Error → stuck → guess → fix → pattern. The pattern forms in the stuck-and-guessing middle. A fast AI answer jumps from error to fix. Same working code, no pattern.
It's GPS for your codebase. You reach the right door every time, and a year later you still can't sketch the neighborhood. The wrong turns you never took were the map you never learned.
Every senior instinct is compressed failure. Somebody sat with the error long enough for the pattern to form.
What this predicts
You'll feel productive and plateau. Output rises while your error count, and therefore your pattern count, flatlines.
Debugging degrades first. Writing code can be borrowed. Debugging needs patterns you own. That's where the study's gap was largest.
It surfaces in production. Load-only bugs like deadlocks and connection pool exhaustion are recognized, not derived. You spot them because you hit a smaller version first.
"Years of experience" loses meaning. Two three-year developers can have wildly different error histories.
Limits worth stating
Behavior subgroups were small (4 and 7), and the authors call the patterns associations, not causes.
The quiz came right after the task, so it measures immediate retention, not long-term skill.
Anthropic's earlier work found AI can cut some task times by up to 80% when people already have the skills. So: an accelerator for skills you own, a risky shortcut for skills you're forming.
The trial used a sidebar chat assistant. The authors expect a stronger effect from agentic coding tools.
The framework: keep the errors, delegate the typing
Ask for the concept, not the code. "Why would these transactions deadlock?" builds a pattern. "Fix it" builds a diff.
Let the error land first. Read the stack trace and write one guess before asking anything.
If AI fixes it, make it explain the break. Then close the chat and explain it back in your own words.
Keep a scar log. One line per bug: symptom, cause, and the tell you'll look for next time.
Know your mode. Shipping familiar work? Delegate freely. Learning something new? Protect the errors.
For team leads: in review, ask "what broke on the way here?" alongside "does it work?" This is the career-specific version of letting AI think without it thinking for you.
Key Takeaways
Anthropic's 2026 trial: AI-assisted learners scored 50% vs 67% for hand-coders, with the biggest gap in debugging.
AI use alone didn't determine the score. How people used it did.
The high scorers either hit and fixed their own errors or used AI to understand, not just to produce.
Experience is the errors you untangled. Tools that remove errors remove experience, even while output rises.
Delegate typing on familiar work; protect the struggle when you're learning.
FAQ
Does using AI make you a worse programmer?
Not automatically. In Anthropic's 2026 trial the AI group scored lower on average, but people who used AI for conceptual questions or to understand generated code scored 65% or higher. The drop was concentrated in heavy delegation.
Why did AI users score lower on debugging?
Because they hit fewer errors. The hand-coding group ran into more mistakes, including on the tested concepts, and the researchers hypothesize that fixing those errors independently built their debugging skill.
Should junior developers stop using AI tools?
No. Aim AI at concepts and explanations, let errors happen before asking for help, and have AI explain any fix it gives you. Delegate freely on work you already understand.
How do junior developers build experience when AI writes the code?
By keeping the error loop alive: form a hypothesis before asking, explain every fix back in your own words, and keep a short log of each bug's symptom, cause, and tell.
Is the Anthropic AI coding skills study reliable?
The overall gap came from a randomized controlled trial and was statistically significant. The behavior patterns come from small subgroups, the quiz measured immediate recall, and the authors describe the results as preliminary.
Does AI still make experienced developers faster?
On familiar work, yes. Anthropic's earlier research found AI can cut some task times by up to 80% when people already have the skills. The risk is specific to learning something new.
Related reading
AI Won't Take Your Coding Job. It Will Change It.: why verification is becoming the job
How to Let AI Think for You Without It Thinking for You: offloading vs surrender
The bottom line
The developer with the smooth afternoon and the developer with the bumpy one shipped the same code. Only one of them got the lesson. AI will happily take the typing off your plate. Don't let it take the errors too.
Your mistakes were never what stood between you and seniority. They were the road.
Adam Jaber is a software engineer who writes Simply Explained: complex topics, made simple. No jargon, no hype.
