Developer manually retypes LLM code to avoid cognitive debt
The author of a personal blog describes a workflow he has followed on his personal coding projects for a few months: despite what he says he wrote back in April, he is still using AI coding assistants. What he avoids is letting an assistant one-shot entire features directly into his codebase, a practice that leaves him unsatisfied and disoriented even though he enjoys using assistants to speed through boring, routine work. His concern is what he calls cognitive debt: even when a task is tedious, such as adding tagging to his website using Django, he still wants to fully understand how the resulting code works rather than offload that understanding to a machine.
His method: he asks the coding assistant to generate code inside a chat window rather than letting it edit files directly, then manually retypes every one of those edits into his own editor. He keeps instructions to this effect in the agents files of all his personal projects. By his own estimate, this makes him roughly 2x faster than coding without any LLM help at all, well short of the roughly 10x speedup he believes he would get if he let the assistant write directly into his projects and think for him.
He lists what the manual retyping buys him. As he types each line, he builds a mental model of how the code works and fits into the rest of his codebase. The slower pace makes him more likely to catch hallucinations or bad design choices the assistant introduced. He can reorganize, refactor, comment and otherwise adapt the code to his own taste as he goes. And over time it gives him a spatial map of his own codebase, so he knows exactly where each piece of functionality lives, which speeds up future changes and also lets him prompt the assistant more precisely.
He frames the habit as an echo of advice he got from experienced programmers as a teenager learning to code: never copy and paste code into a project; instead, type out examples from a book, blog post or forum answer so the material is actually understood rather than just reused. Manually typing LLM-generated code into his own projects, he says, feels like the same learning process. He calls it inefficient, but says he values comprehension over raw productivity, and plans to keep using the workflow.
He extends the point past his own habits: he fears the software industry as a whole is racking up a large amount of cognitive debt that will have to be repaid soon, as more and more developers simply review AI-generated pull requests rather than write and understand the code themselves, a norm he sums up as robots raise PRs, humans review them. He says he cannot personally change the industry's direction, but can make sure he fully understands whatever software he ships himself, and calls anything less professional malpractice.
Key facts
- A developer describes a months-long personal workflow: his coding assistant generates code in a chat window, and he manually retypes every line into his editor rather than letting the assistant edit the codebase directly.
- He estimates the habit makes him about 2x faster than coding without LLM help at all, against the roughly 10x speedup he believes he would get by letting the assistant write directly into his projects.
- Retyping the code by hand, he says, builds a mental model of the codebase, helps him catch hallucinations or bad design choices, and lets him refactor and comment as he goes.
- He likens the method to older advice against copying and pasting code: type out examples from a book or blog post so the material is actually learned rather than just reused.
- He worries the software industry is accumulating cognitive debt as developers increasingly just review AI-generated pull requests, and calls anything short of fully understanding his own shipped code professional malpractice.
Why it matters
It captures a live tension around AI coding assistants in 2026: as more teams settle into a pattern where, in the author's words, robots raise PRs and humans review them, this piece is one developer's concrete pushback against fully offloading understanding of his own code to a model, rather than an abstract complaint about AI.
Who it affects
Individual developers, especially on personal projects, who want to keep using coding assistants without losing track of how their own codebase works; more broadly, any team weighing how much AI-generated code should be merged on the strength of a review pass alone, given the author's worry about cognitive debt building up industry-wide.
How to use it
The method itself: have the coding assistant produce code inside a chat window instead of editing files directly, then manually retype the changes into the editor by hand. The author keeps instructions to that effect in the agents files of his personal projects. This is a personal habit rather than a product, and no price, tool name or licence is given.
How solid is it
This is a single first-person account, not a study, and the only figures are the author's own self-reported estimates: roughly 10x faster if the assistant writes code directly, versus about 2x faster with manual retyping. He does not name which coding assistant he uses, does not say what he wrote in April that he is now walking back, and gives no timeframe more precise than a few months of personal use.
Risks and caveats
The author calls his own approach grossly inefficient, and it explicitly trades speed for comprehension. He limits it to personal projects; for an employer, he says he does the same PR review most developers are already expected to do, which suggests the method may not scale to team settings or larger codebases. The piece is a personal opinion and workflow anecdote, not a benchmarked comparison.
“Instead of being 10x faster, I'm probably only 2x faster.”
— the author