There is a piece of advice going around that you should retype AI-generated code by hand, line by line, so your brain does not quietly rot while the model does the work. The essay that put it back on the front page this week calls the thing it is guarding against "cognitive debt" — the slow, invisible bill you run up when you let a tool think for you.

It is a good instinct, and it taps a real fear. But the fear has outrun the evidence, and the study most often waved around to prove it turns out to say far less — and far less certainly — than people think. So here is the reality-check: what the research on AI and skill actually shows, what it does not, and whether retyping your code is a fix or a folk remedy.

The mechanism is real. The "damage" is not proven.

Start with what is solid. Offloading mental work to a tool is a normal, well-studied feature of how humans think — not a new affliction. The framework is called cognitive offloading, and a 2016 review in Trends in Cognitive Sciences lays it out: we routinely push effort onto notebooks, calculators and phones, and mostly that is fine. The catch the same review flags is subtle: offloading is governed by our judgement of our own ability, and that judgement is often wrong. We hand work to the tool when we shouldn't, because we misjudge what we can do ourselves.

The classic demonstration is older still. In 2011, Science published "Google Effects on Memory," which found that when people expect to be able to look something up later, they remember the information itself less well — but remember where to find it better. Offloading does not empty your head; it changes what your head keeps. (It is worth noting this famous result has faced replication scrutiny in the years since, so treat it as an influential early finding rather than settled law.)

None of that is about coding, and none of it says a tool makes you worse. It says tools change what you practise. Which brings us to the study everyone is actually thinking of.

The MIT brain-scan study does not say what the headlines say

The scary one is a 2025 MIT Media Lab preprint titled "Your Brain on ChatGPT." Researchers put EEG caps on people and measured brain connectivity while they wrote essays in three conditions: with ChatGPT, with a search engine, and with nothing but their own head. The ChatGPT group showed the weakest, least-connected brain activity; the unaided group the strongest. The authors named the accumulating under-engagement "cognitive debt," and the internet did the rest.

Four things are worth knowing before you cite it:

• It studied essay-writing, not coding. The authors' own coding follow-up — a "vibe coding" study — has had its data collected and is under analysis, not yet published. Using this essay paper as evidence about programming skill is already a stretch.
• It is small. Fifty-four people across the first three sessions, and only eighteen returned for the group-switching session that produced the most-shared finding.
• It is not peer-reviewed. Per the authors' own FAQ, peer review had barely started at time of writing and would "probably take months."
• Its authors are openly begging the press not to overstate it. Their public FAQ asks reporters to avoid words like "brain damage," "brain rot," "dumb," "harm" and "terrifying findings." A published critique has separately questioned the sample size, the EEG analysis and the reporting, arguing the results could be read far more conservatively.

When the people who ran the experiment are the ones pleading for restraint, that is the story. The MIT paper is a first, careful signal that heavy AI use might change how engaged your brain is while you work. It is not a scan of your skill draining away.

The code-specific evidence: mind the gap

So what happens when you look at programmers specifically? The honest answer is that the sharpest study measures the wrong thing for this argument, and the study that measures the right thing does not exist yet.

The sharpest is METR's 2025 randomized trial. Sixteen experienced open-source developers worked through 246 real tasks on their own mature codebases, randomly allowed or forbidden to use AI tools. The result surprised nearly everyone: they were 19% slower with AI — and yet they believed it had made them about 20% faster, a belief they held even after the slowdown. That perception gap is the robust, unsettling finding. But note what it is: a measure of speed on a task, in expert hands on complex repositories. The authors explicitly warn against generalising it, and it says nothing directly about skill you retain or lose over time.

Pull the other way and you find GitHub's own Copilot trial, where 95 developers building a simple web server from scratch finished 55% faster with the assistant. The contrast with METR is not a contradiction — it is the actual shape of the evidence. AI speeds up simple, greenfield work, especially for the less experienced, and can slow down expert work on gnarly, familiar code. Both are true.

For code quality rather than speed, an industry report from GitClear analysed 211 million changed lines from 2020 to 2024 and found copy-pasted "cloned" code rising and refactoring falling as AI tools spread. It is a suggestive trend — but it is a vendor's observational analysis, it correlates timing with quality, and it cannot show AI caused the shift. It also measures the code, not the coder.

And the study you actually want — one that follows developers and measures whether their unaided coding ability erodes — I could not find, because as far as I can tell it has not been done. That gap is worth saying out loud rather than papering over with the essay-writing brain scan.

The one causal result that should give you pause

There is one recent experiment that gets closer to the real worry. A 2026 preprint ran randomized trials with over 1,200 people and found that AI assistance improved performance while it was switched on — but people did worse once it was taken away, and gave up sooner on hard problems, with persistence being a known predictor of long-term learning. That is the most direct causal evidence that leaning on AI can dent your unassisted ability.

The caveats matter, though: the tasks were maths and reading, not programming; the sessions were short; and it too is a fresh, un-reviewed preprint. It is a reason to take the concern seriously, not a verdict.

So — should you retype the code?

Here is where the trending advice half-lands. The instinct behind "don't just accept the output" is backed by real learning science. The generation effect — a finding going back to 1978 — shows you remember material you produce yourself better than the same material read passively. Retrieval practice and Robert Bjork's "desirable difficulties" go further: effortful, awkward practice that feels worse in the moment produces better long-term retention. The through-line of that whole literature is a warning against exactly the AI trap — your performance while the tool is helping is not the same as your learning.

But watch the specific claim. The generation effect rewards generating — deriving the answer, filling the gap, reconstructing the logic yourself. Retyping code you were handed is closer to copying than to generating, which is the passive condition that literature outperforms. There is, as far as I can verify, no study of "retype your LLM's code" at all. So treat it as a reasonable heuristic pointing in the right direction, not a proven method. If you want the learning-science version of the advice, it is stronger: don't transcribe the code — predict what it will do before you run it, rewrite it from your own understanding, and try to reconstruct it later without looking. That is effortful engagement. Retyping is a rough proxy for it.

The honest bottom line

The fear that AI erodes skill is directionally plausible and mechanistically grounded — offloading is real, and one causal study shows people falter when the crutch is removed. But "AI-assisted coding rots your skill" is not, today, a demonstrated fact. The most-cited proof is a small, un-reviewed, essay-writing brain scan whose authors disown the doom framing; the code-quality decline is a correlational vendor report; and the sharpest coding result measures speed, not skill.

If there is one finding to carry around, it is not skill loss — it is the perception gap. Across the evidence, the most reliable effect is that people believe AI helped them more than it measurably did. That is the thing worth defending against. Engage effortfully with what the model gives you — question it, rebuild it, test your understanding against it — because that is how learning has always worked. Not because a study proved that retyping saves your brain.

On The Wire covers these reality-checks often: see what the AI adoption data actually shows and Microsoft's own study of its AI coding agents, where the headline number wasn't the interesting part either.