Developers Are Retyping AI Code by Hand. On Purpose.

Copy, paste. Two keystrokes. Yet some developers are spending five minutes typing that same code out by hand — code they didn’t even write. An LLM did. It looks like Luddism with extra steps. The reasoning behind it is more interesting than that.

The Output Went Up. The Understanding Went Down.

Two years into the AI coding tool era, a specific complaint keeps surfacing on Hacker News, in Reddit’s r/ExperiencedDevs, and in engineering retros: shipping more, understanding less.

The symptoms rhyme across teams. You open a file you merged three months ago and it reads like a stranger’s work. A production bug lands and you have no instinct for where to start. You sit down for a systems design interview and your hands stall out.

The term that stuck is cognitive debt. If technical debt is code you’ll pay for later, cognitive debt is comprehension you’ll pay for later. Right now it costs nothing — the code runs, tests pass, the PR is green. The invoice arrives six months out, at 2 a.m., during an incident, when you’re the one on call.

Why Typing, Specifically

The prescription some developers landed on is retyping. Keep the AI output in a side panel. Type it into the editor yourself, line by line.

The logic is blunt. Copying bypasses your brain. Typing forces it through. Typing a variable name makes you ask why that variable exists. Typing a conditional makes the missing edge case visible. A recurring anecdote in these threads: people catch actual bugs in the AI’s code mid-retype. Things that read fine on a skim don’t survive passing through your fingertips.

There’s real learning science underneath. The generation effect — reproducing material yourself beats passively reviewing it for retention — has been replicated for decades. Same principle as why transcribing a passage sticks harder than reading it, even though it’s ten times slower. But typing isn’t magic. The forced slowdown is doing the work. The keyboard is just the mechanism.

The Counterarguments Are Strong

The pushback is not weak, and it comes in three flavors.

It’s a tax on your day. Retyping 500 lines burns hours. Spend that time on architecture review or writing tests and you get more comprehension per minute. Probably true.

Typing isn’t understanding. Anyone who ever copied notes off a whiteboard in high school while thinking about lunch knows that hands and brain can run on entirely separate threads. Retyping can be exactly as mindless as pasting, just slower.

We’ve had this fight before. When compilers arrived, plenty of people insisted you weren’t a real programmer if you couldn’t read the assembly output. Almost nobody makes that argument now. The claim is that AI codegen is on the same trajectory, and today’s retypers are tomorrow’s assembly purists.

That third one is the strongest, and it has a real rebuttal. Compilers are deterministic. Same input, same output, and if it’s wrong that’s a compiler bug someone files and fixes. LLMs are not that. They produce confidently wrong code that looks right. An abstraction earns your trust when you can stop checking underneath it — and LLM output has not earned that yet. Not universally, not in 2026.

Where People Actually Land

Almost nobody retypes everything. What holds up in practice is a triage rule.

Boilerplate, config files, routine CRUD — paste it. Unfamiliar libraries, patterns you haven’t used, core business logic — type it. The filter is one question: am I going to be the one debugging this in six months? If yes, it goes through your hands.

Other developers skip the typing and get the same effect elsewhere. Explain the AI’s code out loud before merging it. Write the tests by hand first, then let the model fill in the implementation. Walk a reviewer through the intent, not just the diff. Different mechanics, identical goal — make the code pass through a brain at least once.

One Question Is Left

Whether retyping is the right answer is genuinely unclear. There’s no good longitudinal data on it, and learning styles vary enough that a universal prescription would be suspicious.

What the argument points at is not unclear. The gap between the code you shipped and the code you understand is widening, and gaps like that don’t stay free. Typing is one way to close it. It is not the only way, and it may not be the best one.

Of the code you pasted today, what percentage could you explain? If you don’t like the number, you need something — and it doesn’t much matter what, as long as it slows you down at the right moment.