Prevent Cognitive Debt: Why Manually Retyping LLM Code Beats Copy-Paste

In an era where AI coding assistants promise 10x productivity, a contrarian approach is gaining traction: manually retyping every line of code produced by large language models (LLMs). Developer Ankur Sethi argues this deliberate inefficiency is the best defense against mounting cognitive debt in software projects.

The Cognitive Debt Problem

Using LLMs to generate entire features leaves developers feeling unsatisfied and disoriented, according to Sethi. While he continues using coding assistants on personal projects, he found that allowing AI to roam freely created a "colossal amount of cognitive debt."

The core issue is understanding. Even when a problem is boring—like adding tagging to a Django site—developers fundamentally want to comprehend how the solution works. Simply reviewing AI-generated PRs isn't the answer. Sethi describes this as "poring over hundreds of lines of overly-defensive, badly-commented, subtly incorrect code" that isn't fun, especially for personal projects where joy comes from process, not outcome.

The Manual Retyping Solution

Sethi's solution is elegantly simple: he instructs his coding assistant to never modify files directly. Instead, every proposed edit appears in the chat, which he then types manually into his editor. His agent instructions explicitly state: "I want to understand every line of code that goes into this project. Never create, edit, move, rename, or delete project files unless I explicitly ask you to do so."

The trade-off is significant. Instead of being 10x faster, Sethi estimates he's only about 2x faster. But the benefits extend far beyond speed. As he manually types each line, he builds a mental model of how the code works and fits into his existing codebase. This forces him to slow down, making it more likely he'll detect hallucinations or bad design choices.

Building a Spatial Map

The most critical advantage of this workflow is developing a spatial map of the codebase. Sethi explains this means knowing exactly where every bit of functionality lives. When changes are needed, he knows precisely where to make them. This spatial awareness not only helps him work faster within projects but also improves his ability to prompt and instruct the LLM in the future.

This approach mirrors traditional programming advice. Experienced developers often counseled against copying and pasting code from books or blog posts. Instead, they recommended typing examples manually to ensure complete understanding. Sethi sees his LLM workflow as the same learning process applied to modern tools.

Community Perspectives

The developer community has responded with nuanced takes. A former CS teacher noted that while typing code offers benefits, understanding the example first and then replicating independently might be more effective. Another developer observed that LLMs have evolved significantly—from Sonnet 3.7's "Sorcerer's Apprentice" phase in Winter 2025 to Sonnet 4.5's "excellent minion" status in Fall 2025, which was described as the "sweet spot for minimizing cognitive debt."

Not everyone agrees with the manual approach. Some developers argue that with modern IDE tooling, they can type code quickly enough that they'd rather write it themselves from scratch. The sentiment is that if code is "basically boring and predictable," they don't want to type it at all—they'd rather use completion models for boilerplate.

The Broader Industry Concern

The underlying worry is about the software industry's trajectory. Sethi fears that "the software industry is taking on a large amount of cognitive debt that we'll have to pay back very soon." He warns of a future where developers no longer understand how large parts of our digital infrastructure are put together.

One community commenter framed this as a "WALL-E future" where humans are progressively removed from the loop. The incentives in the industry all point toward taking the human further out of the development process, which many find horrifying.

Practical Implementation

For developers wanting to try this approach, Sethi recommends adding clear instructions to agent files. Key points include: showing proposed edits in chat instead of modifying files directly, displaying commands rather than running them, and avoiding explanations of syntax or APIs unless explicitly requested.

The workflow acknowledges that developers are experienced professionals who don't need hand-holding. When they encounter unfamiliar APIs or algorithms, they can stop to research or ask the LLM for explanation, maintaining control over their learning process.

Why It Matters

This debate touches on fundamental questions about the future of software development. As AI tools become more capable, the tension between productivity and comprehension intensifies. Sethi's approach offers a middle path—using LLMs to accelerate work while preserving the deep understanding that makes developers effective.

The manual retyping method may seem inefficient, but it represents a deliberate choice to value comprehension over raw output. In an industry racing toward automation, this slower, more deliberate approach might be the key to maintaining quality and autonomy in software development.