Does using AI really make developers worse coders?

The early evidence says it can, depending on how you use it. In an Anthropic study, engineers who learned with an AI assistant scored 50% on an unaided quiz versus 67% for those who used docs and their own brain, a 17-point gap. A 1,000-student study found the same drop once the AI was removed.

Do senior developers lose skills from AI too?

The risk is smaller for seniors. They already hold deep mental models, so using AI for boilerplate or a regex mostly saves time rather than skipping learning. What they tend to lose is low-level syntax recall, which matters far less than a junior failing to build foundational understanding in the first place.

How do I use AI without losing my coding skills?

Keep the thinking in your head and let the AI do the typing. Try the hard part before you ask, read the stack trace yourself, and grill the AI on why its code works and what breaks it instead of pasting and moving on. One rule covers it: only delegate what you could explain to a colleague without looking.

AI Skill Atrophy: Is AI Making Devs Dumber?

Picture a junior dev two years into the job. The GitHub is a solid wall of green, the commit history looks like a work of art, and the resume lists a dozen shipped projects that are all real. Then an interviewer slides over a laptop and asks for a for loop, by hand. Nothing comes. The AI built all of it, and somewhere along the way it took the part that made him good right along with the work.

That story is a composite, but the pattern under it is documented. AI skill atrophy is the quiet cost of handing the hard part to a machine: you get faster today and worse at the job tomorrow. This article walks through what the research actually shows, why struggle is the thing that builds skill, how it breaks the path from junior to senior, and the one habit that keeps the speed without rotting your edge.

What is AI skill atrophy?

AI skill atrophy is the slow decay of a developer’s own coding ability caused by leaning too hard on AI tools like Copilot, Cursor, and ChatGPT. The mechanism has a name in psychology: cognitive offloading. You hand the mental work to an external system, the work gets done, but the part of your brain that would have built understanding never switches on.

This is not the usual moral panic, though, and the difference matters. Plenty of “technology is making us dumb” takes fall apart the second you poke them. This one has data behind it, and the data is specific: it is about the formation and retention of skill, not a vague worry about attention spans. The catch is that the loss is invisible while it happens, because the output still looks fine.

Is AI really making developers dumber?

The honest answer is that AI can measurably degrade your skill, and two recent studies show it in numbers. In January 2026, Anthropic ran a controlled trial: 52 mostly-junior engineers learned an unfamiliar Python library, half with an AI assistant and half with only docs and their own brain. Both groups built the same thing, then sat a quiz with no AI. The AI group scored 50%. The control group scored 67%. That is a 17-point gap, close to two letter grades, in exchange for finishing about two minutes faster.

A bigger experiment found the same shape. A preregistered study of around 1,000 high school students, published in PNAS, gave one group a plain chatbot. They crushed it during practice, then scored roughly 17% worse than the no-AI group the moment the chatbot was taken away and they had to work alone. They looked like they were learning. They were getting a guided tour.

Same result, twice

Anthropic RCT · 52 engineers −17%

The AI group scored 50% on the unaided quiz, the docs-and-brain group 67%. The AI group finished about 2 minutes faster.

PNAS · ~1,000 students −17%

On a raw chatbot they aced the practice, then scored 17% worse the moment it was taken away and they sat the exam alone.

Worst hit The biggest gap showed up on the debugging questions, the one skill you would most want to keep.

Fig. 1 Two independent studies, one number. Saving a couple of minutes during the work cost about 17 points of comprehension on the unaided test, and the debugging questions took the worst hit.

There is a limit here, and the doomers skip it, so I won’t. Nobody has tracked a working developer for five years and watched their skills rot; that study does not exist yet. The famous MIT “Your Brain on ChatGPT” paper everyone cites was about writing essays, not code, and its authors asked people to stop claiming it proves AI makes you dumb. The ground here is real, but it is young. Both of the coding studies measured immediate recall after a single short session, not decades of decay.

Why struggle is how coding skill gets built

Skill comes from friction, which is exactly what an AI assistant removes. Your brain builds expertise by getting stuck, holding a messy problem in working memory, trying the wrong thing, and clawing toward the right one. Psychologists call this desirable difficulty, and the effortful part is not a tax on learning. It is the mechanism. Skip it and there is nothing for a durable mental model to form around.

An AI assistant is brilliant at deleting that struggle. You reach the hard part, the moment your brain was about to do its reps, and the answer simply appears. You walk off with working code and none of the understanding, because the process that builds understanding never ran.

You struggle through it

Hit a hard problem Wrestle it: wrong turns, retries Pattern wired into memory Skill built

You offload it to AI

Hit a hard problem The answer just appears The brain never switched on Nothing built

Fig. 2 The same hard problem, two routes. Wrestling it wires a pattern into long-term memory. Offloading it to the AI leaves the slot empty, however clean the code that comes back.

And before you reach for the obvious fix, typing the code out yourself does not save you. Anthropic checked. The people who hand-typed the AI’s output instead of pasting it remembered no more than the pasters; they just lost the time. Transcribing characters is not the same as thinking about them. The reps that matter happen in your head, not your fingers.

The trap you can’t feel: skill down, confidence up

The reason this is more dangerous than a calculator is that you get no warning. When your skill erodes, you do not feel the drop. What grows in its place is confidence. There is a Stanford study where developers using an AI assistant wrote less secure code and rated their own code as more secure. Wrong, and surer about it.

That combination, less skill paired with more confidence, is poison, because confidence is the internal alarm that is supposed to tell you to slow down and look closer. AI quietly cuts the wire on that alarm.

The receipt In a Stanford study, developers using an AI assistant wrote less secure code and rated their own code as more secure. Wrong, and surer about it.

Fig. 3 As the tool does more of the work, real skill falls and confidence climbs to cover it. The lines cross at a blind spot, where you feel most capable exactly as you become least able to catch a mistake.

It shows up first in debugging. The move is familiar: an error pops up, you paste it into the chat, paste the next error into the chat, and loop, never once reading the stack trace yourself. One senior described watching a junior do four rounds of that before stepping in. The junior had never read a stack trace in his life. He did not know it was a thing you could do.

How AI breaks the junior-to-senior pipeline

Scale this from one developer to a whole field and the worry stops being personal. Senior engineers do not arrive senior. They get there by spending years stuck, reading other people’s code, and breaking things at 2am until they understand why. That boring struggle is the factory that builds a senior, and AI is very good at letting a junior skip the entire line.

What comes out the other side is a developer who ships like a mid-level engineer and understands like a beginner. One engineer described a new hire who was a 5x developer in year one and should have been 20x by year three, except he stopped learning the day the tool started doing the learning for him. The AI did not make him productive so much as dangerous: confident code nobody could vouch for, himself included.

The factory

Stuck for hours Reading others' code Breaking things at 2am Senior

The AI bypass

Junior Hollow

Ships ●●●● like a mid-level dev Understands ●○○○ like a beginner

Fig. 4 The slow factory of struggle is what forges a senior. The AI bypass routes a junior straight to the exit, shipping like a mid-level dev with the understanding gauge near empty.

Aviation already ran this experiment. As autopilots got good in the 1990s, instructors started calling a new kind of pilot the children of the magenta line, glued to the glowing route the computer was flying for them. Switch the automation off and their hands did not know what to do. Skills they were certified to have had drained away from disuse, and it was cited as a factor in real crashes. Run that forward for code: if juniors never build the deep skill, who becomes the senior who catches the AI when it is confidently wrong? The whole setup assumes a human in the loop who understands what they are looking at, and the junior jobs where you used to learn that are the first thing the autopilot is eating.

Isn’t this just compilers and calculators again?

This is the strongest counter-argument, and it deserves a fair hearing. Every layer of abstraction in computing got this same eulogy. When compilers arrived, the old guard swore programmers would go soft because they would never hand-write assembly or manage their own memory. They were right that the skill faded and wrong that it mattered. We climbed a level and built bigger things. Calculators were going to wreck kids at math, and when researchers measured it across dozens of studies, used well, they did not. The skill just moved up the stack.

By that logic, mourning a forgotten for loop is nostalgia. The value is in knowing what to build and whether it is right, and the machine can handle the syntax. A lot of the time, that is the correct call.

Here is where the analogy breaks. Every one of those older tools was deterministic. A compiler gives the same right answer every time, so you can trust the layer below without looking. An AI assistant will not. It hands you something usually good and occasionally, confidently, wrong. So “trust the layer below and move up” has never been riskier advice, because this layer lies, and catching the lie takes the exact skill it is busy eroding.

Which way of using AI keeps your skills sharp?

The tool is not the problem; how you use it is. The same Anthropic study recorded how people interacted with the assistant and sorted them into patterns. The split is stark. People who treated the AI as an oracle, pasting prompts and copying answers, landed at the bottom. People who generated code and then aggressively interrogated it scored at the top, above the no-AI control group.

How you use the AI	What it looks like	Quiz score
Iterative debugging	Paste the error back, repeat, never diagnose it yourself	24%
Progressive reliance	Start solo, then surrender the whole task when it gets hard	35%
AI delegation	Treat it as an oracle: copy the output, move on	39%
Conceptual inquiry	Write the code yourself, ask the AI about concepts	65%
No AI at all (control)	Docs, web search, and your own brain	67%
Hybrid code + explanation	Demand the code and a breakdown of the logic	68%
Generate, then interrogate	Grill it: why does this work, what breaks it, what else could I do	86%

Treat the 86% gently. Those subgroups were tiny, a handful of people each, and the researchers drew no causal claim. The honest reading is suggestive, not proven: the same tool, used as a sparring partner instead of a vending machine, tracked with much better retention. The 1,000-student study found the same escape hatch from the other direction. A chatbot rigged to give hints instead of answers wiped out the damage entirely.

Where does the thinking happen?

You think, AI types

You hold the hard part in your head and use the AI to type, check, and speed you up.

You grow

AI thinks, you type

You hand the AI the problem and sit there transcribing its answers without owning them.

You're automated

The one rule Only hand the AI work you could do yourself and explain to a colleague without looking. If you can't explain it, you didn't delegate it, you hid that you couldn't do it.

Fig. 5 The line between the tool sharpening you and hollowing you out comes down to where the thinking happens, plus the one rule that keeps you honest about it.

It all reduces to one question: where does the thinking happen? Keep the struggle in your head and let the AI do the typing, and you still grow. Push the struggle onto the AI while you sit there transcribing its answers, and you are the one being automated.

Does coding skill come back after it atrophies?

Probably, though no study has proven it for developers yet. The encouraging read of the evidence is that the skill goes dormant, not dead, more like a language you stop speaking than a muscle that vanishes. It is still in there, waiting, which means recovery is not about out-disciplining the entire industry. It is about doing the reps the machine keeps offering to do for you.

Some of the fixes have real evidence behind them. Try the hard thing before you ask. Use the AI to quiz you rather than answer you. Go a stretch without it on purpose, the way pilots are made to hand-fly so the skill does not drain. Others are popular but unproven, the no-AI Fridays and read-every-line pledges; they might help, but treat them as habits, not guarantees.

So that is the deal, and it is not as final as it looks. AI skill atrophy is real, the evidence is young, and the loss is invisible while it happens. But the same tool that hollows you out can sharpen you, depending entirely on whether you keep your hand on the part that made you good. Stay the one drawing the map, not the passenger with the windows painted over. For the full version with every beat animated, watch the companion video below.

Watch the explainer