--- title: Prevent cognitive debt by manually retyping... description: A developer shares a personal workflow for using LLM coding assistants without accumulating cognitive debt: instead of letting the AI write code directly into... canonical: https://daily.dev/posts/prevent-cognitive-debt-by-manually-retyping-llm-generated-code-4oe0roqnz twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Prevent cognitive debt by manually retyping LLM-generated code | daily.dev og:description: A developer shares a personal workflow for using LLM coding assistants without accumulating cognitive debt: instead of letting the AI write code directly into... og:url: https://daily.dev/posts/prevent-cognitive-debt-by-manually-retyping-llm-generated-code-4oe0roqnz og:image: https://api.daily.dev/og/posts/4Oe0rOqNZ.png og:image:alt: Prevent cognitive debt by manually retyping LLM-generated code og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Prevent cognitive debt by manually retyping LLM-generated code **[Lobsters](https://daily.dev/sources/lobsters)** · 4 min read · 1 upvotes · 1 comments ## Summary A developer shares a personal workflow for using LLM coding assistants without accumulating cognitive debt: instead of letting the AI write code directly into the codebase, they generate code in chat and manually retype every line themselves. This slower approach (roughly 2x faster than no LLM, not 10x) preserves deep understanding, helps catch hallucinations and bad design choices, and builds a spatial mental map of the codebase. The author draws a parallel to the old advice of never copy-pasting code when learning, and warns that the software industry is accumulating dangerous cognitive debt by letting machines think for developers. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Community take How the wider developer community reacted, aggregated from 2 discussions and 13 comments across lobsters, hackernews (as of 2026-08-03). **TL;DR:** Commenters broadly agree that LLM-assisted coding creates real 'cognitive debt' and skill erosion, but debate the best mitigation strategies — from retyping LLM output, to manual/plan modes, to using LLMs purely as thinking partners while writing code yourself. **Sentiment:** 20% positive · 55% mixed · 25% skeptical **The case for** - Using LLMs in a constrained, interactive way (e.g. manual/plan mode, or as a thinking assistant) can boost productivity 2–3x while preserving understanding. - Skill re-acquisition after LLM-induced atrophy may be faster than original learning, mitigating long-term concerns somewhat. - LLMs can serve as an 'eternal student' to explain things to, which exercises a useful (if different) cognitive muscle. **The pushback** - Cognitive debt compounds over LLM generations — fully agentic coding leaves the human entirely out of the loop and produces code no one understands. - AI-generated code tends to be overly defensive, badly commented, and subtly incorrect with no traceable 'because' for its mistakes. - Alert fatigue and normalisation of deviance will eventually erode even the critical engagement that makes LLM-assisted learning worthwhile. - Vibecoded output is essentially opaque to its own author, requiring significant re-investment to understand or modify later. **By community** - lobsters (mixed): A rich, nuanced thread where commenters share concrete personal strategies and generational LLM observations, broadly worried about cognitive debt but actively searching for sustainable workflows. - hackernews (skeptical): The single comment focuses on the frustrating experience of reviewing AI-generated PRs full of subtle, inexplicable errors. **Hottest debate:** Whether the right mitigation for cognitive debt is retyping LLM code, using manual/plan modes, or abandoning LLM code generation entirely in favor of using LLMs only as conversational thinking assistants. **Open questions** - At what point does LLM capability make it impossible to stay meaningfully 'in the loop' even with deliberate effort? - How should teams handle the cultural problem of developers responding to code reviews with AI-generated replies? - Will skill re-acquisition remain efficient as LLM dependence deepens across an entire generation of developers? **Highlights** > "Cognitive debt" is real. As someone who wants to understand what LLMs can do, I have been putting each new generation through its paces for a few years now. (Mostly on a backlog of minor utility projects that I want to _use_ but don't especially feel motivated to _write_. I have cooler things to write myself.) And what I noticed was a clear generational picture: - **Winter 2025.** Sonnet 3.7 was a Sorceror's Apprentice. I'd give it instructions, and it would promptly go screaming off the rails. This was far too frustrating to use for anything serious. - **Fall 2025.** Sonnet 4.5 was an excellent "minion". I had to understand the code and give clear instructions, but it would grind through a big refactoring quite competently. Or take an existing Rust trait, and implement it for a new cloud provider. I think this may have been the sweet spot for minimizing cognitive debt. It was sort of like having a novice pair programmer who knew all the common APIs and who typed _really_ fast, but who still deferred to the human partner for the stuff that mattered. - **December 2025.** Opus 4.5 came out just after Thanksgiving. And this is the generation that made "agentic coding" explode. This was genuinely a pretty interesting experience for a few weeks, but I could _feel_ the cognitive debt building up. And this got several unimportant projects of mine into an awkward state. - **Summer 2026.** When Fable 5 came out, I asked it to build a few minor tools. I'd give it a couple of paragraphs of specification, answer a few clarifying questions, insert $20 or $50 worth of tokens, and walk away to clean the kitchen or something. And in an hour or two, Fable would have a completely working APK ready to install on my phone. **But the cognitive debt was _total_.** I literally wasn't in the room for the coding. Now, not even Fable can be trusted on a realistically sized project. It still does dumb, expedient stuff. But Fable is sort of like having a talented senior dev who likes to lock themselves in an office and not communicate, except to occasionally walk you through exactly how clever they are. Now, personally, I'm not going to start retyping LLM code. I can type code _really fast_ with modern IDE tooling. And if you give me a few-lines-at-a-time completion model like Zed's Zeta2, I can go faster still. (Zeta2 will autocomplete a few lines of boilerplate but only if it's really predictable.) So if I'm going to type the code at all, I'll write it myself. My main personal use case for LLMs is "that code is basically boring and predictable and I don't wanna type it all out." But I agree that the trend line around cognitive debt is pretty worrisome, and that the incentives all point towards taking the human further out of the loop. This is a WALL-E future we're looking at, folks. And I don't blame programmers for being horrified by it. I certainly am. But the Fall 2025/Sonnet 4.5 class models were really interesting, in terms of cognitive debt. You know that saying that "the best way to really learn something is to teach it to someone else?" A Sonnet 4.5-class LLM was sort of an eternal student that never actually learned anything. For the local LLM crowd, the people who want MIT-licensed weights and a whole stack they control from end-to-end, here's how I'd classify the top local models as of this week: - Qwen3.6 27B is essentially a bit weaker version of the **Fall 2025** / Sonnet 4.5 experience. It will happily do grunt work, and it's genuinely capable at debugging. But if you don't understand what you're asking it to do, you will _lose_. If you want to learn by explaining things to an "eternal student", there you go. - DeepSeek V4 Flash 0731 has only been out for two days, but I've been pushing it hard. And it feels much more like the **December 2025** / Opus 4.5 experience. You need to make a conscious decision to stay in the loop. If you don't, you _will_ get in trouble. But the trouble will happen a few weeks in, when it's too depressi > — [emk on lobsters · 7 points](https://lobste.rs/s/ui2vor/prevent_cognitive_debt_by_manually#c_im9cia) > Hey, former CS teacher here. In addition to being somewhere in the middle for speed, you are also likely somewhere in the middle for understanding. The actual benefits of writing it out versus manifesting it yourself are quite diminished in my experience with students doing the same. Generally, I observed students having more success by reading the example, understanding it, then replicating it independently. This is still at the loss of building intuition for planning out your own solution, but if you're going to use these tools regardless, that might also help. That all being said, this excerpt gives me a modicum of hope: > If I don't understand an API or algorithm, I can stop to look it up, or just ask the LLM to explain it. While I think this exercises a different brain muscle than the original programming practice, it indicates critical engagement that will still help you learn from the experience. Nevertheless, you will eventually fall into classical human traps (normalisation of deviance, alert fatigue, etc.) that will reduce your efficacy in this eventually. (Used to such posts being submitted by authors. Feel free to replace 2nd person pronouns with 3rd :p) > — [addison on lobsters · 22 points](https://lobste.rs/s/ui2vor/prevent_cognitive_debt_by_manually#c_atwjfo) > Interesting approach. A piece to comment on: > Using LLMs this way allows me to work faster than not using LLMs at all, but I'm still slower than those who are willing to allow the machine to think for them. Instead of being 10x faster, I'm probably only 2x faster. But what I lose out on in terms of speed, I gain in terms of a deeper understanding of my code. Have you thought about writing all the code by hand and mainly chatting with an LLM about the design, possible edge cases and API/library examples for what you are not familiar with? To be honest, that is the sweet spot that has been working wonderfully for me: * I talk with an LLM about what I would like to implement; depending on the urgency and importance, I sometimes throw a few ideas on it, sometimes ask for them immediately, without providing my own * I then usually ask a few follow-up questions (depending on the output) to explore some of the implementation paths * If I do not know certain API/library I explore them here as well - in the concrete context of features we are implementing * Might as about suggested classes/functions and test cases - usually on the high level, pseudo-code style * At this point, it is pretty clear to me what implementation path is the best - I go and write the code myself :) Using something akin to it, *treating LLMs as thinking assistants*, I find myself stuck much less often, which probably gives me like 2 - 3x productivity boost (depending on the task), but still retaining the exact same - deeper even, I would argue - understanding of the things I am implementing and working with :) It is pretty interesting and fun to be honest as well! > — [BinaryIgor on lobsters · 1 points](https://lobste.rs/s/ui2vor/prevent_cognitive_debt_by_manually#c_y7omry) > This to me feels like a slightly more awkward way of switching to "Manual" mode in Claude Code (which, for those who are delightfully unaware of these machines, pauses output at every edit made by the LLM, shows you the diff, and allows you to accept, abort, or ask for something else). My personal approach (at work, because I made a point not to use LLMs at home) which I feel achieves the same purpose as OP, but without (what at least to me appears to be) hassle is to strive to use the machine mostly just ask questions and write the code myself. And, in the exceptions where if I do want it to write code, I always use Manual or Plan mode, not only because manual gives you a chance to understand what's going on while auto-edit will make anyone's eyes glaze over, but also because it gives you zero opportunity to steer the model in a different direction, if you realize it's going in a completely wrong way. I feel this has made me more productive than before, because my baseline remains the same, but if I get stuck, I generally don't have to pester my colleagues as much as before and before I present my work to them, I have a reasonably good filter that lets me iron out the obvious issues that would have caused multiple commit-rereview cycles before. > — [nemin on lobsters · 5 points](https://lobste.rs/s/ui2vor/prevent_cognitive_debt_by_manually#c_zb6zqx) > But I don't enjoy reviewing AI-generated PRs. Poring over hundreds of lines of overly-defensive, badly-commented, subtly incorrect code is not fun. Ain't that the truth. There's no "because" there. A field in the middle of a struct is missing initialization? Whoops! Bitfield indexes start at 1 when bits 0 and 1 are explicitly noted in the docs as "reserved"? Whoops! A whole struct representing one of many items (the other structs are all there!) and it's supporting parsing and init functions doesn't appear? Whooops! My python-programmer co-worker makes pretty consistent mistakes when dealing with Go map types, but LLMs don't have any reason for their behavior. No "because" at all. > — [bediger4000 on hackernews](https://news.ycombinator.com/item?id=49150272) **Source threads** - [lobsters](https://lobste.rs/s/ui2vor/prevent_cognitive_debt_by_manually) · 25 points · 12 comments - [hackernews](https://news.ycombinator.com/item?id=49146214) · 2 points · 1 comments ## Community discussion Top comments from developers on daily.dev. **@troydentx** · 0 upvotes > I thoroughly enjoyed this read, i had never considered the 'cognitive-debt' until now ## Similar posts on daily.dev - [A Single Reason To Not Vibe Code](https://daily.dev/posts/a-single-reason-to-not-vibe-code-qtvi65njq) · Lobsters · 4 upvotes · 0 comments - [I can never fully embrace LLMs for code](https://daily.dev/posts/i-can-never-fully-embrace-llms-for-code-aw1v4ccnc) · Ibrahim Diallo · 15 upvotes · 3 comments --- Tags: [#llm](https://daily.dev/tags/llm), [#ai-coding](https://daily.dev/tags/ai-coding), [#code-review](https://daily.dev/tags/code-review) [View this post on daily.dev](https://daily.dev/posts/prevent-cognitive-debt-by-manually-retyping-llm-generated-code-4oe0roqnz) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Prevent cognitive debt by manually retyping LLM-generated code","url":"https://daily.dev/posts/prevent-cognitive-debt-by-manually-retyping-llm-generated-code-4oe0roqnz","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/prevent-cognitive-debt-by-manually-retyping-llm-generated-code-4oe0roqnz"},"datePublished":"2026-08-02T18:00:09.151Z","dateModified":"2026-08-03T03:01:02.076Z","description":"A developer shares a personal workflow for using LLM coding assistants without accumulating cognitive debt: instead of letting the AI write code directly into...","image":"https://media.daily.dev/image/upload/s--OHB84bZF--/f_auto/v1722860399/public/Placeholder%2010","thumbnailUrl":"https://media.daily.dev/image/upload/s--OHB84bZF--/f_auto/v1722860399/public/Placeholder%2010","isAccessibleForFree":true,"articleSection":"Lobsters","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Lobsters","logo":"https://media.daily.dev/image/upload/s--tl8v_Fku--/f_auto,t_logo/v1698841318/logos/lobste.jpg","url":"https://daily.dev/sources/lobsters"},"commentCount":1,"discussionUrl":"https://daily.dev/posts/prevent-cognitive-debt-by-manually-retyping-llm-generated-code-4oe0roqnz","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":1},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":1}],"keywords":"llm,ai-coding,code-review","timeRequired":"PT4M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Lobsters","item":"https://daily.dev/sources/lobsters"},{"@type":"ListItem","position":3,"name":"Prevent cognitive debt by manually retyping LLM-generated code"}]} {"@context":"https://schema.org","@type":"WebPage","@id":"https://daily.dev/posts/prevent-cognitive-debt-by-manually-retyping-llm-generated-code-4oe0roqnz","comment":[{"@type":"Comment","text":"I thoroughly enjoyed this read, i had never considered the ‘cognitive-debt’ until now","datePublished":"2026-08-04T14:41:41.356Z","url":"https://daily.dev/posts/4Oe0rOqNZ#c-MnE4MzaqD","author":{"@type":"Person","name":"Troyden Tx","url":"https://daily.dev/troydentx","image":"https://lh3.googleusercontent.com/a/ACg8ocJXu6rzXjjd9Yuoji7VsW_dr0VCbLw4G9AH7lhS7iifvRfm04z6=s96-c"}}]} ```