In early 2026 Anthropic published a research paper that became briefly inescapable in developer circles. The headline finding — roughly a 17-point comprehension-quiz gap (50% vs 67%) favouring the hand-coding cohort — got picked up by InfoQ, Futurism, CIO, and a wave of developer commentary including Addy Osmani's Avoiding Skill Atrophy in the Age of AI and VirtusLab's How AI coding tools silently erode developer understanding. The reactions ranged from this is the moment we knew to this is one small study, calm down.
Both reactions overshoot in opposite directions. Here is a careful read of what the study did, what it found, what it didn't find, and what working developers should actually change.
What the study did
The Anthropic paper randomized 52 mostly-junior developers (all with at least a year of Python) learning Trio, an unfamiliar async library. Two cohorts: AI-assisted and hand-coding. Both had access to documentation, standard tooling, and search. The AI cohort additionally had AI coding assistance during the learning phase. Immediately after the learning phase, both cohorts took the same comprehension quiz — without AI. The authors are explicit that this measures immediate comprehension, not delayed transfer or long-term retention.
The headline result: on the quiz, the hand-coding cohort averaged 67% versus the AI cohort's 50% — about a 17-point gap (roughly two letter grades, Cohen's d ≈ 0.74). The AI-assisted cohort produced better code during the learning phase and weaker independent comprehension afterward.
InfoQ's coverage frames the finding cleanly: AI assistance during learning produces better artefacts and reduced skill formation, in the specific learning-to-transfer window measured. The two are not in tension. They describe the same finding from two angles.
What the 17% gap is and isn't
The 17% gap is real, statistically meaningful at the study's sample size, and directionally consistent with the broader cognitive-offloading literature. It is also narrow in scope. Four things to keep in mind.
It's one library. The quiz was on the specific Python library (Trio) participants had been learning. The study does not generalize to all programming, all languages, or all kinds of code work.
It's a learning context. Participants were learning something new. The findings are about skill formation, not about working developers maintaining existing skill. A senior developer using AI assistance to ship features in a language they already know is not the population the study measured.
It's a single study, in a single population. 52 developers is a defensible sample size for the design, and not large enough to settle the question on its own. The Anthropic paper itself flags this scope.
It's about unaided comprehension. The quiz was taken without AI. The study measures immediate comprehension when the AI is removed — not long-term retention. In workplaces where AI assistance is permanent, "skill when AI is taken away" may matter less than "skill when AI is present" — though working developers point out that the AI is meaningfully unavailable more often than people realize: regulated environments, on-call debugging at 2am, code review of someone else's pull request, interviews, postmortems.
Why the finding is consistent with the broader literature
The Anthropic result lands in a context. Three contemporaneous pieces frame the same direction.
Addy Osmani's Avoiding Skill Atrophy (2026) argues that AI assistance optimizes for shipping at the cost of the under-the-hood skill — the kind of skill you only need when something breaks in a way the AI can't fix. Osmani's frame is the warning signs of skill atrophy, not catastrophism.
VirtusLab's cognitive-debt code piece (2026) describes the workplace pattern: AI-assisted teams ship faster and accumulate code that nobody on the team can reason about deeply. The artefact quality is fine; the team's ability to debug or extend the artefact when needed has dropped.
CIO's 2026 reporting documents the management-side view: organizations seeing speed gains in code generation, and skill flattening among junior developers who never built the foundation that senior developers built before AI.
The Anthropic study is a controlled measurement of a pattern that the field had been observing in unstructured ways. The convergence of the controlled study and the qualitative reports is what gives the finding its weight, more than the single 17% number.
What the study does not show
A few hedges, because we always hedge here.
It does not show AI assistance is bad for working developers. The study measures skill formation in learners, not productivity in working developers. A senior developer using Claude or Copilot to ship features in a stack they've mastered is doing different cognitive work than the study population.
It does not show 17% is the size of the effect across all settings. The 17-point gap is the specific comprehension-quiz result in this study, on this library, with this sample. Replication, broader samples, and different libraries will tighten or widen the estimate.
It does not predict the future. AI assistance is changing fast. The cognitive cost of using it in 2026 may look different from the cost in 2028. The study describes the current state, not a permanent state.
It is not a clinical claim. The study measures unaided comprehension-quiz performance. It does not measure brain structure, working memory, or any clinical variable. Conflating skill-formation gaps with broader cognitive harm is a misread.
What developers should actually change
The practical takeaways, sorted by how well the evidence supports them.
Build the foundation unaided. When you're learning a new library, language, or tool, do at least the first pass unaided. Read the docs, write the first version yourself, fail, recover. Then bring AI in. This is the version of generation-after-thinking adapted to the developer context. The Anthropic finding is most directly an argument for this rule.
Maintain a daily unaided code-reading rep. Read someone else's code — open-source, your own old code, a teammate's pull request — without AI summarization. The reading skill is the foundation that the writing skill rests on, and it's the skill AI most readily replaces in the daily workflow.
Keep a "no AI" debugging block. When something breaks, give yourself fifteen unaided minutes before reaching for the assistant. The unaided debugging window is where the under-the-hood understanding gets built and maintained. If you blow past fifteen minutes, fine — open the assistant. But the block exists.
Take the on-call practice seriously. The skill that matters most in the moments AI isn't available is the skill the Anthropic finding is most directly about. If your job has on-call rotations, treat the on-call shifts as the load-bearing test of whether your skill has kept up.
Don't catastrophize about juniors. The cleanest read of the Anthropic result is that AI use during learning is the variable to manage carefully. Working developers who already have the foundation are in a different situation. Junior developers and self-taught learners are the population where the study most directly applies — and the response is calibration, not exclusion from AI tools.
What this means for hiring and team practice
Three things working teams have started to do that line up with the evidence.
Foundational tasks unaided in interviews. A growing number of teams now run a portion of technical interviews without AI assistance, specifically to test the foundation that AI assistance can mask. This isn't an anti-AI stance — it's a measurement of the foundation.
Code review without AI summarization. Some teams now require that code reviewers read the diff themselves before consulting AI summaries. The cognitive act of reading the diff is what makes a useful reviewer, and the AI summary can substitute for that act in ways that make code review less effective over time.
Pairing assignments for juniors. Pairing a junior with a senior on substantive features remains the highest-evidence way to build the foundation that AI assistance can mask. The Anthropic finding doesn't change this; it reinforces it.
