# Retyping AI Code Is a Symptom, Not the Cure > Source: > Published: 2026-08-03 12:08:54+00:00 [AI](https://sourcefeed.dev/c/ai)Article # Retyping AI Code Is a Symptom, Not the Cure A viral plea to hand-copy every line of LLM output gets the mechanism wrong and the diagnosis right. [Mariana Souza](https://sourcefeed.dev/u/mariana_souza) This weekend, a short post from [Ankur Sethi's lab notebook](https://ankursethi.com/blog/prevent-cognitive-debt-by-manually-retyping-llm-generated-code/) hit the Hacker News front page with a proposal that sounds like satire: forbid your coding agent from touching the filesystem, make it show every proposed edit in chat, and then retype each line into your editor by hand. His agent instructions are blunt — "Never create, edit, move, rename, or delete project files unless I explicitly ask you to do so." He estimates the practice caps his AI gains at roughly 2x instead of the advertised 10x, calls it "grossly inefficient and perhaps slightly comical," and does it anyway, on personal projects, to avoid what he calls cognitive debt. The easy response is the one half the [comment thread](https://news.ycombinator.com/item?id=49153374) reached for: good luck justifying this to management. The more interesting response is that Sethi has rediscovered a forty-year-old idea, attached it to the wrong mechanism, and still ended up closer to the truth than most of the industry's current defaults. ## The debt is real, and it predates LLMs In 1985, Peter Naur argued in "Programming as Theory Building" that a program isn't its source text. The real asset is the theory in the heads of the people who built it — why the code is shaped this way, which changes are safe, which invariants are load-bearing. When the theory-holders leave, the program is effectively dead: teams can still patch it, but every patch is guesswork against an artifact nobody understands. Naur was describing staff turnover. Agentic coding industrializes the same failure mode, except now code can enter a repository without ever having passed through a human head at all. The phrase "cognitive debt" comes from a 2025 [MIT Media Lab study](https://arxiv.org/abs/2506.08872) that put EEG headsets on 54 people writing essays with ChatGPT, with a search engine, or unaided. The LLM group showed the weakest neural connectivity, the worst recall of their own text, and the lowest sense of ownership over it. The honest caveats: it's essay writing, not programming; the sample is small; it's a preprint. But it gave a name to something working programmers already report anecdotally — you can ship an agent's feature on Tuesday and be unable to sketch its control flow on Thursday. The productivity side of the ledger is murkier than either camp admits. [METR's randomized trial](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/) of 16 experienced open-source developers across 246 real tasks found they were 19% *slower* with early-2025 AI tools — while believing they'd been 20% faster. That perception gap is the scary part for comprehension: if developers can misjudge their own speed by nearly 40 percentage points, their sense of how well they understand agent-written code deserves zero benefit of the doubt. METR's [2026 follow-up](https://metr.org/blog/2026-02-24-uplift-update/) shows point estimates flipping to speedups, though the researchers themselves call the new data unreliable — partly because so many developers now refuse to work without AI at all, which is its own data point. The direction of travel is clear enough: the speed objection is dissolving. Comprehension is the trade that remains. ## Retyping is the wrong mechanism Here's where Sethi's critics have a point. Cognitive psychology's "generation effect" — invoked repeatedly in the HN thread — says memory and understanding accrue when you *produce* content, not when you transcribe it. Retyping someone else's solution is transcription. It's the same reason copying out worked calculus problems teaches you less than struggling through them, and why the type-in program listings in 1980s computer magazines mostly taught patience. Zed Shaw's [Learn Python the Hard Way](https://learnpythonthehardway.org/) famously banned copy-paste, but that discipline targeted beginners acquiring syntax fluency. A senior developer maintaining a theory of a codebase has a different problem. What Sethi actually gets from his ritual isn't the keystrokes. It's that code enters his project one decision at a time, at human reading speed, with a mandatory checkpoint where he can rename, refactor, or reject. He notes he catches hallucinations mid-line and restructures code as he goes — which means he's not transcribing anymore, he's editing. The typing is scaffolding for attention. You can keep the scaffolding's function and drop the ceremony. ## What to do instead The generalizable principle is: *be the write path for code you have to own.* Concretely: **Chat-only or plan-first modes.** Sethi's instruction block works verbatim as a rules file in most agent tools, and plan modes exist precisely for this. Have the agent produce the design; apply the diff yourself, or write the implementation from the plan with the chat closed. That's actual generation, not transcription.**Ownership tiers.** Hand-write or substantially rework the load-bearing core — domain logic, auth, data models, anything with concurrency. Let agents own the periphery (test scaffolding, migrations, glue code) gated by tests you trust.**The explainability gate.** Don't merge a diff you can't explain line-by-line without asking the agent. It's the cheapest version of Sethi's forcing function, and it scales to teams as a review norm in a way "everyone retypes everything" never will.**Budget the 2x.** Sethi's arithmetic is the useful part: he's consciously paying half his potential throughput to stay comprehension-solvent. Most teams are making the opposite trade without noticing they're making a trade at all. ## The verdict Retyping every line won't survive contact with a sprint board, and it shouldn't — the mechanism is theater. But the diagnosis is sound, and the industry default it's reacting against — agents writing straight to disk, humans skimming 500-line diffs, nobody holding the theory — is accumulating a liability that no dashboard tracks. Cognitive debt doesn't show up in velocity metrics. It shows up at 3 a.m., mid-incident, when the person on call opens a module no human has ever actually read. Sethi's 2x-with-understanding is a defensible bargain. 10x-with-amnesia is a bill that hasn't arrived yet, and the repayment terms are brutal. ## Sources & further reading - [Prevent cognitive debt by manually retyping LLM-generated code](https://ankursethi.com/blog/prevent-cognitive-debt-by-manually-retyping-llm-generated-code/)— ankursethi.com - [Prevent cognitive debt by manually retyping LLM-generated code (discussion)](https://news.ycombinator.com/item?id=49153374)— news.ycombinator.com - [Your Brain on ChatGPT: Accumulation of Cognitive Debt when Using an AI Assistant for Essay Writing Task](https://arxiv.org/abs/2506.08872)— arxiv.org - [Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/)— metr.org - [We are Changing our Developer Productivity Experiment Design](https://metr.org/blog/2026-02-24-uplift-update/)— metr.org [Mariana Souza](https://sourcefeed.dev/u/mariana_souza)· Senior Editor Mariana covers the fast-moving world of machine learning and generative AI, with a particular focus on how these technologies are reshaping development workflows. When she isn't stress-testing the latest foundation models, she's usually at a local hackathon. ## Discussion 0 No comments yet Be the first to weigh in.