Does AI use make programmers worse at coding? What the studies show
The question gets asked most often by engineers who notice the pattern in themselves: code ships faster, the AI suggestions feel right, but the underlying skill feels like it's drifting. The pattern is real, the research backs it up, and the fix is practical.
What the research shows
Anthropic's 2026 study on AI coding assistance (Shen & Tamkin) randomized 52 mostly-junior developers learning an unfamiliar Python library, then gave them an immediate comprehension quiz:
- The AI-assisted group averaged 50%, versus 67% for those who coded by hand — about a 17-point gap (the authors note this measures immediate comprehension, not long-term retention or on-the-job performance).
A separate 2025 study — METR's randomized trial of experienced open-source developers, a different population and a different research group — found those developers took about 19% longer on their own tasks when AI tools were allowed, even though they felt faster. (Two different studies; we cite them separately rather than blur them together.)
Futurism's coverage of the Anthropic study added the experiential side: engineers describing feeling faster on output but less able to code unaided over time. Psychology Today's framing sharpens the conclusion: AI-related skill drift is concentrated in new skill formation. Skills you already deeply have stay.
What this means in practice
Three nuances that get missed in the headline.
First, "worse" is the wrong word for senior engineers with strong prior skills. Ten years of writing code from scratch does not disappear in six months of AI use. Those skills are deeply built — they show resilience.
Second, "worse" is more accurate for early-career engineers, for engineers learning new technologies, and for engineers in domains they don't already know. That's where the formation happens; that's where the gap shows up.
Third, the cost is not the AI itself — it's the encoding gap. When you struggle through a problem yourself, you encode the path: where the edges are, which pieces fight each other, what trade-offs are real. When the AI takes the struggle, you encode the output but not the path. The output is what you ship. The path is what you need six months later when a similar problem shows up and the AI's prediction doesn't hold.
What to do about it
The strongest practitioner advice — well-summarized in Addy Osmani's "Avoiding Skill Atrophy in the Age of AI" — clusters around four habits:
- Use AI for conceptual inquiry more than for code generation. The Anthropic study's own breakdown: developers who used AI to understand concepts scored 65%+ on comprehension; those who used it to generate code scored under 40%.
- Read every line of AI output before committing it. This is the cheapest fix and dramatically shrinks the encoding gap.
- Do at least one non-trivial thing a day without AI. A refactor, a tricky test, a logic walk-through. This is exactly what Senwitt's Code Skill supports.
- Pair-program with a human regularly. The conversation forces both of you to encode the problem in a way solo AI use doesn't.
What this is not
AI coding assistance is not net-negative for engineering productivity — there is broad consensus that it ships output faster. The question is about the skill-formation gradient underneath the productivity gains, and that's a more specific question than "are these tools good?"
It is also not a reason to ban AI from engineering workflows. The right response is to use AI deliberately while keeping the underlying skills in practice. That's Senwitt's narrow claim, applied here.
