Avoiding Cognitive Debt: The Case for Manually Retyping AI Code

By Ankur Sethi's Lab Notebook | August 2, 2026

Despite my previous reservations expressed back in April, I continue to integrate coding assistants into my personal development workflow. While I find that using them to "one-shot" entire features leaves me feeling disconnected and confused, they remain incredibly useful for accelerating through the monotonous segments of a project.

However, granting an AI unrestricted access to my codebase creates a massive amount of cognitive debt.

The Dilemma of the "Boring" Task

I might find the prospect of digging through Django documentation to implement a tagging system tedious, but I still possess a fundamental desire to understand the underlying mechanism. There is a critical difference between a task being boring and a task being something I want to completely outsource to a machine.

The alternative—reviewing every line of AI-generated code—is a nightmare. In this "cursed" year of 2026, this is the standard expectation for developers. However, auditing hundreds of lines of code that is often:

Overly defensive
Poorly commented
Subtly flawed

...is simply not enjoyable. While I might endure this for a paycheck (while simultaneously searching for a new job), I refuse to do it for my hobbies. For me, the value of a personal project lies in the process, ~~not the final result~~.

"The joy of working on personal projects comes from the process, not from the outcome."

The Solution: Intentional Inefficiency

To avoid ceding my cognition to the "slop machine," I have adopted a method that is admittedly inefficient and perhaps a bit absurd: I ask the AI for the code in the chat, then I manually type every character into my editor.

To enforce this, I include the following strict guidelines in my agent configuration files:

I want to understand every line of code that goes into this project.

1. Never create, edit, move, rename, or delete project files unless I explicitly ask.
2. Show me every proposed edit in the chat so I can type it in manually.
3. Do not run commands that modify files, install dependencies, or change the repo state.
4. Show me those commands in the chat so I can execute them manually.
5. Do not explain syntax, APIs, or concepts unless I specifically ask.

Workflow Comparison

Feature	AI Auto-Pilot	Manual Retyping
Speed	Extremely Fast	Moderate
Comprehension	Low (Surface level)	High (Deep)
Error Detection	Reactive (Wait for bug)	Proactive (Spot during typing)
Mental Map	Fragmented	Spatial & Cohesive

The Cognitive Benefits

While I am slower than those who let the machine think for them, I gain a profound understanding of my software. The act of typing creates a mental model of how the new logic integrates with the existing system.

The benefits include:

Active Learning: If an algorithm or API is unfamiliar, I stop to research it or ask the LLM for a specific explanation.
Quality Control: Slowing down makes it easier to catch "hallucinations" or architectural mistakes.
Customization: I can refactor, reorganize, and add comments in real-time to suit my personal style.
Spatial Mapping: I develop a precise internal map of where every piece of functionality resides.

This spatial awareness not only speeds up future manual edits but also allows me to write better, more precise prompts for the LLM.

A Return to Fundamentals

This approach mirrors the advice I received as a teenage coder. Experienced mentors always warned me against the "copy-paste" trap:

Copy examples from books and run them manually.
Type out forum answers and adapt them to the specific codebase.
Ensure total comprehension before moving to the next step.

Retyping LLM output is simply a modern version of this pedagogical discipline. I prioritize $\text{Comprehension} > \text{Productivity}$ .

The Bigger Picture

I worry that the software industry is currently accumulating a systemic level of cognitive debt. We are heading toward a future where the architects of our digital infrastructure no longer actually understand how it is constructed.

$\text{Cognitive Debt} = \sum (\text{AI Generated Code} - \text{Human Understanding})$

I cannot change the trajectory of the entire industry, but I can ensure that I remain the master of the software I release into the world.