11 ms·

Prevent cognitive debt by manually retyping LLM-generated code

• deleted 2mo ago
  [deleted]
• daun_gee 2mo ago
  [dead]
  • frankc 2mo ago
    It could easily be the other way around - religious addiction for people can't let go of the code.
    • deleted 2mo ago
      [deleted]
    • podgietaru 2mo ago
      I don’t think so, because it’s being used as a way to try to remedy one of the new problems brought in by agentic coding - loss of context of what code does.
      • tp3358 2mo ago
        But if the code base is constructed in a way which results in strong test suites (human driven), quality evals, robust documentation, and modular implementation, will the human really lose that much context? Given that those things are checked off, I am having a tough time believing a frontier model, in conjunction with a new dev on a project, can't be immediately valuable to determining what is going on in a repo.
        • daun_gee 2mo ago
          [dead]
• orangecoffee 2mo ago
  But this way you move way slowly even on personal projects, like you will not even get the basic UI for the app done in a few days? Is that OK for you?
  • pringk02 2mo ago
    It is meant to offset not knowing why everything degrades and you can't make progress after the first month. Is that OK for you?
    • orangecoffee 2mo ago
      No you misunderstand me. I support such a view but cannot hold it because my pace at work is so much fast. And hand coding like this will make personal projects s slow and choreful with no visible progress. Like where is the joy in that?
      • regularfry 2mo ago
        The bottleneck is very rarely the typing.
    • user43928 2mo ago
      Has this been your first hand experience? And if so, in what work, and have you tried debugging issues with SOTA models? From my experience it is certainly not the case that you cannot make progress after the first month. I work on native mobile applications.
      • noodletheworld 2mo ago
        I work on mobile native applications. Without an active harness (eg. Appium) that can end-to-end deterministically verify the changes you make continue to work correctly it is almost impossible to continue to keep the same pace on the app. Unsupervised LLMs (even fabel) are categorically incapable of running parallel unsupervised mobile app feature development. That is my personal, first hand experience working in a team in this space. What you are (I guess?) experiencing is user-in-the-loop light touch LLM development where you can 80% most tasks quite quickly (much faster than without assistance!) with a small number of human developers working on largely unrelated features and manually verifying they are correct and manually fixing the platform specific issues you encounter. Maintaining a strong appium end-to-end test suite is still extremely challenging with notifications and maps. Honestly, it blows my mind you could even being to claim that of all things, native apps using obscure languages like swift are suitable for this, compared to the much much easier path of web + react. You might say “yeah yeah, but one month? Come on!” …but have you actually seen how much code fabel can write in a month? Its a lot. So sure, you say, work at a slower pace. Don't just endlessly run a frontier model in unsupervised feature development mode. Yes… you see, thats the point. Thats what the op is saying. Move more slowly, and you can avoid building a spaghetti castle (ok sure! If you dont wanna, maybe don't retype every character by hand, but the point of that practice is not upping your wpm typing speed. :p It is to take the time to think, design and collaborate, not rush rush rush)
• deleted 2mo ago
  [deleted]
• deleted 2mo ago
  [deleted]
• jruz 2mo ago
  What I did is kinda similar, I downgraded to $20 plan and just ask questions and almost never let it write the code, and if I can I use the web ui like the good old days and not spend my CLI tokens.
• ozgrakkurt 2mo ago
  You are cooked if you can’t actually write better code than llm. Try reading some books or documentation
  • jdw64 2mo ago
    I think there are far more people who can't write better code than an LLM. Of course, there are a few exceptions, but it's a fact that LLMs are already handling PhD-level mathematics and papers. I also think I write better code than an LLM in certain areas, but in most programming domains, the LLM knows more than I do across many dimensions. As prompts get deeper, LLMs are already producing PhD-level code—and that's been shown in research. The vast majority of people don't have that level of education. Of course, having a PhD doesn't guarantee good coding, but at least it's clear that LLMs can handle that level of capability. People might disagree, but my view is firm on this.
    • maccard 2mo ago
      > I also think I write better code than an LLM in certain areas, but in most programming domains, the LLM knows more than I do across many dimensions. Remember that the quality of the LLMs code in the areas you don’t know is as good as the quality as the area you do know. You’re only able to gauge the quality of what you do know.
      • jdw64 2mo ago
        >You’re only able to gauge the quality of what you do know. That's not true. You can follow the logic step by step, search for similar domains, and form a comparison group. Realistically, if we take this logic to its conclusion, it's like asking: 'You're just a spectator, so can you really judge whether a football player is good at football? Realistically, LLMs write code well. I'm a C# programmer, and as you know, the current trend in modern programming is to refine error handling—using try/catch at higher layers, working with monads, preserving computable contexts, and branching accordingly. That kind of code typically takes 1 to 2 hours of modeling before you even start writing. But an LLM can do it in just 5 minutes. So I think the opposite way: if LLMs can do this well in a domain I'm familiar with, they're probably just as capable in other domains too. And that makes them feel trustworthy. And more importantly, no matter how great a human programmer is, once you step outside your domain, you're in unknown territory. In those areas, LLMs are surprisingly helpful. Epistemologically, it might be true that you can't evaluate code in a domain you don't know. But people keep forgetting the fact that you can learn through that code. This very post is itself an example of learning through LLM-typed code. And programming actually provides clearer results than many other domains. It's not based on subjective UX like UI design. You have: 1.Executable specifications 2.Performance measurements 3.Comparisons with official documentation These are clear engineering outcomes that allow for objective comparison. For example, you can verify whether a program produces results within 5ms when executed. Many epistemological arguments tend to overlook this. A lot of code is open source. You can find mature implementations anywhere. Finding a repo from someone claiming 10 or 20 years of experience and running a differential comparison is not difficult at all."
• jdw64 2mo ago
  This method doesn't seem bad. Realistically, LLMs write code much better than most people. In my domain, there are areas where I still write better code than an LLM, especially when it comes to physical constraints it might not understand, but there are far more domains where the LLM writes much better code than I do. In that sense, writing code with an LLM and keeping track of it feels more helpful than I expected. Practicing solo coding for an hour a day often ends up being mechanical and not very useful. This might actually be more helpful.
• wahern 2mo ago
  Good advice yesterday, good advice today, and good advice tomorrow. I don't remember if I read this advice or just intuited it myself (perhaps after some hard lessons), but it's a programming habit I've kept for as long as I can remember (I started coding in the 90s). If I feel rushed, e.g. someone looking over my shoulder, and I copy+paste something, it always leaves me with a sense of unease. It creates a memory & comprehension hole that sticks out like a sore thumb, even for seemingly simple snippets. You can't really be sure it's simple without stepping through it carefully, and simple can be deceptive because it's usually the interactions and assumptions wrt surrounding code that lead to surprises. Typing out code manually gives you time and space to consider the broader picture.
  • cylee3 2mo ago
    [flagged]
• nzxt210 2mo ago
  Nice workflow! I'll give it a try. I'm struggling with building mental model of AI-generated code. And code review fatigue is real. This may be the way.
• utopiah 2mo ago
  If you copy/paste code from a teaching book, you will probably not learn as well as if you type it. Typing itself is irrelevant, it is the timing spent, even if only seconds, pondering at what each word or syntactic element is and why use it. Being slower does not automatically make you learn better, focus on the learning is what makes the difference. If you don't have the opportunity to learn, the time to actually think, then a faster tool is not helping. TL;DR: what matters is why you are doing something, is it solely to get the task done or is it primary to learn, or both?
• dsign 2mo ago
  I like the "cognitive debt" term. With the latest models, what I've observed is that they are really good, but I don't use them to write main code because I need to know what I'm doing. The article is not wrong though that it pays off to have some imagination on how to use the models. For example, I want to use SIMD instructions in an ESP32-P4 CPU. Those instructions are undocumented for the most part, with just a couple of handwavey blog posts and some infuriatingly vague marketing material. So I just asked an LLM to create a `SIMD_P4.md` document with all the details. Lo and behold, it practically reverse-engineered the ISA. Now I can program in assembler by hand all I want and build that skill in my own brain, and whenever I find a slightly unclear op in the document, I ask the LLM to refine the documentation in that op.
• _davide_ 2mo ago
  there is a simpler way, make a complete mental model of the changes and ask questions to confirm your understanding. so much faster.
• docheinestages 2mo ago
  If you can afford it, why not. For certain phases of projects like a proof-of-concept, you need to move fast and validate several ideas. Once it's locked down, rewrite from scratch, and here, if you can afford it, type or write the code manually.
• bandrami 2mo ago
  As an aside, back in the days of Stack Exchange I would always type out manually whatever answer I found to make sure I understood WTF I was adding to the system.
  • tdeck 2mo ago
    I did this too. Almost always I'd rename variables, change formatting, add or remove comments, etc.. Unfortunately this feels less easy to do with modern tools. For example, Claude Code expects to edit your actual source files, and the Claude chat is much worse at writing code.
    • TremendousJudge 2mo ago
      I use zed for this (you can use vscode as well), just use the side panel chat, take away write permissions, prompt it with "answer with code in chat" or similar, then you can use it as a personalized StackOverflow for your codebase. Even if it outputs an entire new file, you can take your time and go function by function.
• klaussilveira 2mo ago
  Whenever I don't know something, I ask it for a tutorial, programming-magazine style. Then I just follow the tutorial.
• witx 2mo ago
  We're living in such a stupid time.
  • RALaBarge 2mo ago
    It’s just bonkers
  • globular-toast 2mo ago
    Took 36 years to go from computers being a "bicycle for the mind" to manually copy/pasting to prevent brain rot.
• K0nserv 2mo ago
  I'm taking a slightly different approach. I've started a project where I intentionally don't use agentic coding. I use LLMs for researcher and to learn, but write all the code by hand. The goal is to maintain the taste, for lack of a better word, that I've developed over decades of programming. Claude put me on to the concept "Étude", so I've taken to calling it my Étude project.
• f311a 2mo ago
  This does not sound fun. It's better to work on your side projects with manual coding. You will learn more. Retyping things is inefficient for learning. It's like trying to retype calculus solutions — you don't learn from it. Even if there is an explanation of why the code is written in such a way, you did not come up with it, and you don't know alternative solutions. It is a practice for memorizing, not for building your intuition. A better option is to write it yourself first and ask LLMs for better options. They are pretty good at it, especially when you need to optimize hot loops.
  • ainch 2mo ago
    I'm not sure I agree about retyping calculus solutions. I often find that writing out a proof or derivation forces me to engage with some minor detail that I hadn't fully appreciated beforehand. That usually raises productive questions.
    • mathgeek 2mo ago
      Retyping calculus solutions is a great way to remember your LaTeX.
    • WJW 2mo ago
      In which case it would be the engagement with minor details that does the productive work. Retyping is merely a gateway to (sometimes) trigger the engagement. The solution in TFA feels like an on-ramp to cargo culting somehow; observing that manual typing and good results often go together, but then thinking that it's the typing that directly causes the good results rather than the thought process that accompanied the typing. There's a much better article hiding inside the current one that's titled "Prevent cognitive debt by understanding deeply the code that your LLM spits out", but that sounds like hard work and would probably not be very popular. It's much better for audience engagement to provide a simple solution that anyone can do and does not require a lot of deep thought like "manually retype everything the LLM generated", even if it doesn't actually work.
    • JeremyNT 2mo ago
      I think the disconnect here is that you can't only retype the solutions. You have to already sort-of know what's going on and you have to also care to understand the gaps. So transcription can definitely be helpful when part of a broader, intentional process, while also being insufficient to do much on its own. And the next logical question to ask is whether there's a better form of intentional behavior that might be more effective.
• Garlef 2mo ago
  nah thanks; my workflow: - ask not only for a solution to a problem but also for specific code (= tell the agent about your mental model of the codebase) - ask for small stacked 'PRs/branches' and review/refactor heavily also using the agent (= refine your mental model of the codebase)
• KSteffensen 2mo ago
  Why use LLMs at all if you're doing this?
  • trucks-refinish 2mo ago
    For learning? You can use llms to help you with stuff and still learn new things in the process. Its really surprising that so many people don't understand this. Are people really out there just mass copy pasting llm code without even trying to understand it! lol
  • tdeck 2mo ago
    Because typing is a small percentage of the time spent writing software.
• baalimago 2mo ago
  "Prevent sub-optimal code by manually retyping compiler-generated assembly" I don't think this is a practice which will be sustainable for very long
  • pritambaral 2mo ago
    LLMs are plenty far from compilers.
• pcwelder 2mo ago
  The most I enjoy working with AI is my special workflow. I ask it to plan the feature in a separate worktree. In parallel I start coding without being biased by AI and vice versa. At some point I read its plan and iterate on it all the while I am in implementation mode. This helps me improve my own vision. Finally I ask the AI to review my implementation. It flags off bugs and gaps which are usually straightforward for it to fix.
• throwthrowuknow 2mo ago
  Pair programming with the LLM is a better approach. You can take either role and even take turns. It’s slower but gives ample time to read everything and push back on decisions or receive feedback and review on your own decisions.
• dncornholio 2mo ago
  I just give them smaller tasks
• gste 2mo ago
  I already wrote my opinion on this, which I don't think anyone read, but my idea is to let AI code the working system, and then prompt it to teach you, give you challenges, and grade your work. If you write, you should write in your own words, to demonstrate your own understanding - the so-called Feynman technique. Never verbatim. That's as true for coding as it is for study notes.
  • Thanemate 2mo ago
    My counterpoint to that is, you never know when the factuality of its analysis is mistaken because you're making it the point of authority over knowledge you should be working to acquiring. In math classes back at school, it didn't matter how much the math professor explained how the formula works. What mattered is me putting in the effort to understand it. The implication to your example is, I should already be familiar enough to understand the generated code to the point where all the explanation that it's doing is effectively a "Quality of Life feature".
  • arstructinc 2mo ago
    [dead]
• ArekDymalski 2mo ago
  I wonder how effective it finally will be. At first glance it reminds me painting by numbers a d I'm not sure if that will help the real painter to keep his skills and surely won't teach aspiring painter much about the craft.
  • jeltz 2mo ago
    This is not about an aspiring painter though. This method is intended for an already accomplished painter. Not saying how effective it is but your comparison is not relevant.
• r0ze-at-hn 2mo ago
  When I was younger and took over a codebase I open it up in one window and then type it back into another window. Not only did I catch/fix a crazy number of bugs, but I became a near expert overnight. Doing the typing would cause me to question everything, ask why we import something, why x is used and not y, etc. I also tried where I would print out the code (with color) and then go read it with a red pen. Faster and similar results of forcing me to be able to read it enough to be "an editor" to the code. And I have done the same for LLM-generated code and text, back in '23 this meant more taking their so-so output and then turning it into my own, but between now and then come up with a number of techniques to improve the AI output to more acceptable out of the gate so more learning than being inspired. These are good techniques as it causes your own brain to rapidly learn the material, but no matter how good it is I have never met anyone else that does it so the real ponderable is assuming that everyone else doesn't do this and what does that mean?
• podgietaru 2mo ago
  I feel like this will do almost nothing? Mindlessly typing something is not much better than copy and pasting? I could maybe see it if you asked it to spit out pseudocode you had to rewrite. At least there’s some translation there… But this is bizarre. Write it yourself at that point. Is it any faster (or faster at all frankly) to prompt what you want, manually write it out, and maybe even make adjustments as you go? I’d argue not. The way I wrote code in the past was to just first comment out what I wanted to do, and then underneath write the syntax for it. You could maybe do this too? Take the LLM code, and go through commenting what each section does to be able to effectively break it up? It still seems dumb.
• m4xp 2mo ago
  Hard disagree, it's proven that its the actual discovery process that's makes us improve at tasks. Blindly typing will make you just good at typing. I do think there is absolutely no way a learner should be using ai for code generation. I think code analysis is the only acceptable usecase.
• jatins 2mo ago
  I don’t disagree with this if you code for a hobby. Buy if you code for a job, good luck justifying this to management. “Yeah Claude already gave me the solution, I’ll take the rest of the week to type it out”
  • customguy 2mo ago
    I use LLM code for hobby/fun projects only (I also don't code for a living) and I still wouldn't want to type up the code it gives me. Instead what I dream of doing is one day to rewrite all the little things from scratch (well, with a blueprint of a working result). Your management wouldn't even talk to me, rightly so :P
• petcat 2mo ago
  > manually retyping LLM-generated code This is just a miserable career of "paint-by-number" because people can't be bothered to have a creative thought about their professional work or programming hobbies. Software developers think that they are being clever with these kinds of strategies to "keep their skills sharp", but unfortunately the entire industry knows about this, and especially the upper management who are already eliminating these assembly line, JIRA-ticket-taker software jobs en masse.
  • bonoboTP 2mo ago
    Right, it's just pretending to be able to delay the inevitable. It's like the assembly programmers of the 70s and 80s keeping their assembly-fu sharp. Yes it might come handy, and it's good to have a grasp of the concepts, but most careers have shifted to not needing to use assembly. Yes, I know that better knowledge of the low level would improve performance and efficiency. But people don't work with this any more, and the goal back then also wasn't to keep retyping a GCC output to keep the skill fresh. It was to get to a higher level of control and think about the organization of structured code, code maintenance issues, thinking at the level of how to make the C++ implementation. With AI, our role also shifts. It's mainly to know what to spend effort on, to set priorities and, to be able to verbalize requirements, missing social context and unwritten rules, to anticipate what additional documents the agent needs, to prioritize deadlines, feature necessity, and other judgment calls. We are right at the stage where our coding ability and review ability is still needed though, but this stage won't last long. Soon there will be as little point to a human diving into the code as to trying to beat a chess engine, or humans constructing buildings by hand. Of course the discussion and prioritization may involve looking at the code itself, to get a better idea of why the agent says that a certain feature would be tedious to implement in the current architecture, but then most people will just learn to take its word for it, just as you may want to understand a chess engine's step, but you typically wouldn't want to override it.
    • skydhash 2mo ago
      > With AI, our role also shifts. It's mainly to know what to spend effort on, to set priorities and, to be able to verbalize requirements, missing social context and unwritten rules, to anticipate what additional documents the agent needs, to prioritize deadlines, feature necessity, and other judgment calls. Did you not do that before AI? It’s so strange to me when people are calling out these kind of tasks like they were not already a requirement for the job. What were you doing before? > Soon there will be as little point to a human diving into the code as to trying to beat a chess engine, or humans constructing buildings by hand Chess is way less complex than coding. The rules are like a few pages. While the specs for an 8 bit chip like the AVR is in the hundreds of pages. Books like “The Linux Programming Interface” are thousand pages long. Also humans are using tools for building. Tools that do exactly what you control them to do. When you use a drill for a hole, you don’t have to worry that pressing the trigger have a good chance of sending the bit in your guts.
• deleted 2mo ago
  [deleted]
• Kim_Bruning 2mo ago
  Manually typing in code is an underappreciated trick in a lot of circumstances. It's one of the fastest ways to get to grips with a certain piece of code, a new library, or some methodology. This was true when I first learned to program, and is still true today. And I do find myself manually typing in really critical code. In those cases even if I do have an LLM alongside these days, LLM suggestions also then get manually typed.
• sltr 2mo ago
  I am also worried about "cognitive debt". I hardly remember what I had Claude do, even hours later. Back in May, I advised of a similar mitigation, citing the "generation effect" as the reason typing the code would make you remember it better: > For your next ticket or feature, engage with your LLM as you normally would to produce a design and implementation plan, but with that plan in hand, make the mechanical edits yourself...You can expect this to improve your knowledge retention compared to merely reading a diff. You want to go slower now so that later you can go at all. https://www.slater.dev/2026/05/type-your-code/ https://www.slater.dev/2026/05/type-your-code/
• jspdown 2mo ago
  I never had so little free time as I have these days. Most of my time is spent at work or with my lovely family.Love my family, and work is great. The thing is that, probably like many of you, I love going deep in a side project, even if it lands nowhere. With so little time, working on them has become a very frustrating activity. This is where I found my trap... do more with very little time by delegating to an LLM. You get dopamine shots, the feeling of achieving something but the cognitive dept is just crazy. So much that the activity becomes almost meaning less. After couple of months doing this, I'm not even sure it's a good use of this time. I get very little satisfaction on the long run. I don't have a solution to this problem, not even sure there one. I think I have to accept that this is an activity that takes time, and only time gives the real gratification.
• a2128 2mo ago
  As someone who, at a point, would copy homework from someone else, copy book reports from online, and use the answer sheets to complete assignments, I can tell you this strategy is long known to accumulate and not prevent cognitive debt
  • morganf 2mo ago
    How so?
  • muhamsyaddad 2mo ago
    u sure?
  • mexicocitinluez 2mo ago
    > I can tell you this strategy is long known to accumulate and not prevent cognitive debt When you say "long known" it sounds like this is established science. Is there a link you can share?
  • blitzar 2mo ago
    > would copy homework from someone else I was pretty good at it - mostly remembered to change the name at the top of the paper too. Struggled at moderated exams; think it must have been the time pressure or something.
  • dwaltrip 2mo ago
    If you do it mindlessly, I'm sure you are right. But one could try to understand and integrate each piece of code as they "copy" it over. May be hard to sustain though.
• PunchyHamster 2mo ago
  ...what, that's terrible advice. If you gonna waste time on that just waste time on writing the code from scratch
• Greenpants 2mo ago
  Alternatively, what I tend to do after receiving generated code is a lot of asking "why?". I've learned things I wouldn't otherwise have learned because I hadn't considered using the tools the LLM recommends. It's also a way to eliminate some hallucinating, given that critical questions are posed as unbiased as possible. For that, I also like to open a new chat with a different model and asking open-ended questions about a recommended tool I don't know much about, to double-check that the original LLM was likely correct in its recommendation in the first place.
• jdw64 2mo ago
  I don't think it's bad to manually retype code as a way of learning. Isn't a working program itself the best textbook? It's just a difference in learning methods. Depending on Stack Overflow is also a dependency, and searching for code on GitHub is also a dependency. How much dependency you allow is purely a personal difference, and it varies depending on your own study habits and learning style. Whether your learning method is superior or not likely depends on how your brain works. People tend to think that the more painful something is, the better it is. I don't deny that there are talented people who can read the manual and build everything from scratch. But I think that analyzing and rebuilding a working template step by step is also valuable. I agree with the view that LLMs may cause cognitive decline. But if you go down that path, Socrates already criticized writing for weakening human memory. And how did that turn out? Books became a universal medium for knowledge. Then the internet came along. When Stack Overflow appeared, there was opposition, but it also had explosive adoption. LLMs are just the next step in that sequence. If there is cognitive decline, I think there's also compensation in other areas. Using LLMs clearly causes some cognitive decline. And I think there are areas that need to be reinforced to compensate. But having a baseline to work from—modifying already-working code—is genuinely helpful. I don't see what's wrong with using that as a way to learn.
• _benj 2mo ago
  This resonates with me. The concept of cig it I've debt was something I've been experiencing but didn't have a name for it. I think it is worth noting that not all code is equal... One could argue that adding a library is in some ways similar to copy/pasting code in as much as, one doesn't know what the code is doing, and yet that doesn't leave me with a sense of unease! So it might be that as I'm working with an LLM there are parts (boring, as the author calls them) that are not worth "knowing" how they work, something uninteresting or that a correct output is all that us needed, I'm totally fine having the agent write that code, but the sections I need to know how they work, I think it might make sense to write those by hand!
  • pritambaral 2mo ago
    > One could argue that adding a library is in some ways similar to copy/pasting code in as much as, one doesn't know what the code is doing, and yet that doesn't leave me with a sense of unease! It does, to me. Been burned enough times that I now, at minimum, audit the source code of third-party libraries before I use them.
    • _benj 2mo ago
      Fair enough... I think it really depends about what dependencies we talking about. NPM decencies is a bit of dumpster fire, supply chain attacks galore! A well known python (think numpy) certainly is less discomforting, and a "industry standard" C library like GSL or SDL3, I just use it and move on
• chrischen 2mo ago
  This is the workflow that Vs Code Copilot does. All the AI generated code changes are in a git worktree and you can step through them all. This is what I missed after Claude forced third parties to start charging API pricing and now I have to use Claude directly and I have to do this same review process in a clunkier way via my git client.
• risingsubmarine 2mo ago
  I've used LLMs in a similar way and I'm reminded of learning to draw / paint. At the very beginning stages you might be tempted to trace over an image but this builds a very shallow understanding. Instead you should quickly move onto replicating work you admire by sight. Consider the form, volume and values, conceptualise them in your mind and try to apply them in whatever medium you are using. This helps form your own mental model of the process. Eventually you can start using those techniques on original works. I'm currently rethinking language learning too in a similar manner. Comprehensible input, shadowing. That sort of thing.
• anymouse123456 2mo ago
  Funny that there's another trending post titled, "Don't be a meat proxy," just above this proposal that we literally meat-proxy all the code. Whenever I encounter an especially preposterous proposal like this one, I like to imagine a USMC Drill Instructor wandering into the open plan office and having an interaction something like this: USMC Drill Instructor: "What the actual fuck are you doing?!" Smelly Recruit: "Sir, I'm hand typing the LLM output. Sir!" USMC Drill Instructor: "Are you fucking with me recruit?! I said I wanted a SASS App, not a typing tutor! Drop and give me 20!" Smelly Recruit: "SIR, YES SIR!"
• yk 2mo ago
  Related, a writing advice I stole from Neal Stephenson is to write the first draft by hand. The thing is, there are a lot of small corrections where you kinda should change the text but nah, and if you already committed to copy the entire thing than you are already working at that sentence anyhow.
• holtkam2 2mo ago
  My rule is: I only let AI code for me, I don’t let it think for me. Since writing is thinking, coding is thinking since coding is writing. That means any time I am not certain how I’m gonna implement some feature or bug fix, I have to code it myself because that’s the only way I can force myself to think through it. Only when I get to a point where I’m line “ok I know exactly what to do now- all that’s left to do is type it out” that’s when AI can be employed - essentially as a autocomplete. This is only for projects where I will be held responsible for outcomes and must understand how it works. For hackathon / personal projects, I vibe away. I also use AI to brainstorm at the outset of the task when I don’t know where to start at all. Is this inefficient? My take: no. It’s maximally efficient. Over the long term it gives me an edge over any teammates who just vibe code everything because I actually, you know, understand how stuff works. I become the guy who can save the day at 3am when the team’s business critical app goes down. I become the guy that gets pulled into meetings so the suits can ask “is this possible?”. I see opportunities and problems before my teammates because I have a relationship with our code and system that they never took the time to develop or think about.
• diekhans 2mo ago
  Would one retype assembly language for C generate code? Having LLMs write out their design and reviewing it seems more efficient. Have LLMs, maybe with a different model, check that the implementation meets the design.
• yanis_t 2mo ago
  As others mentioned retyping is not fun. My approach is to let it write the code, but only in small portion. Not "implement this feature". But "open this file and make these changes". Each small change is easily reviewable and often times I end up asking it about better options and iterate a bit. Still feels like I'm in charge. Still feels like I'm learning stuff.
  • exodust 2mo ago
    Agree with this. Small steps towards the feature. Review, iterate, learn and optimise as you go. If the project is a mountain, I want AI to assist with the climb so I can learn the mountain, its trails and details. Hitching a free helicopter ride to the summit would leave me with little understanding about the mountain other than the view from the top.
• blitzar 2mo ago
  Sounds like a devious plan to turn me from a self diagnosed 10x developer (& Founder, CEO, Serial Entrepreneur) into a plain old 1x regular Joe.
  • bigbuppo 2mo ago
    More like a 0.1x tokenmaxxing subscriber.
• alfonsodev 2mo ago
  I don't know if retyping is the solution, but for me is clear that we need something additional to a terminal and a code editor. I envision a software that an agent can use and showcase to you how it did implement the changes and why. The same way a colleague would do, focusing on the important bits, then ending with the trivial stuff. Something in between pair programing and code reviews.
  • chrbr 2mo ago
    Diffity has a “tour” feature that can be directed to explain a local code change. Walks you through the important bits of the change with explanations. https://github.com/nilbuild/diffity https://github.com/nilbuild/diffity
  • bonoboTP 2mo ago
    Right. I want an AI that sees my screen, sees my mouse cursor, has my audio transcript synced to the mouse movements, and it can similarly do TTS and and pointer movements or put things like circles and rectangles and background highlights on things while it talks, and slows down if I say so etc, like a human discussion partner.
• agentmoney 2mo ago
  [flagged]
• chmorgan_ 2mo ago
  [dead]
• RickJWagner 2mo ago
  When I got my first corporate job, I was placed in a group of 20 trainees in a rigorous COBOL course. We were given assignments and a schedule to complete them. Most of us read the specs, then raced into the coding phase, hands to IBM mechanical keyboards. One guy took a different approach. He took a legal pad and pencil, and wrote his whole program on paper before he ever approached a terminal. He’d do his own bug checking and syntax checking, instead of having the compiler do it ( compiles took longer in those days, and required JCL ). He avoided the entire compile/wait/read-with-dismay/quickly-try-again loop. He was one of the top students, of course. And a lot less stressed, as I recall.
• twoquestions 2mo ago
  This is what I'm doing right now to learn Electron, I essentially had Opus write me a tutorial to write the application I want to have, and I'm modifying bits and pieces as I go. It's been enlightening thus far, and the bot isn't always right so I still need to look up documentation on occasion.
• estebarb 2mo ago
  This will cause cognitive debt anyway. As mentioned in https://arxiv.org/pdf/2509.21972v1 https://arxiv.org/pdf/2509.21972v1: "When students rely on these outputs as a substitute for their own reasoning or critical engagement, the learning process is fundamentally compromised. Genuine learning requires the active construction of meaning, integration of knowledge, and reflective engagement with content. These processes cannot occur through passive consumption of syntactically correct but semantically hollow responses. Without this deeper cognitive work, learners risk mistaking linguistic fluency for understanding, thereby undermining the very goals of education". Personally, I don't think we will ever be able to reconcile using LLMs and cognitive debt. Even before LLMs we were aware if it: we knew people moving to managerial/PM roles eventually get their coding skills rusted. Well, now we are all in those managerial roles...
  • RealityVoid 2mo ago
    What do you think would be the effect on people that already have the skills and abilities. The LLM would build these systems using the skills that are largely understood by the programmer but piece them in new ways suitable for the system. This could lead to new enmergent behaviors that are not understood by the programmer. I still think that you can build this model in your head even with LLM's but I'm not sure neither one way or the other.
    • vouaobrasil 2mo ago
      There's always some component of a skill that is not merely knowing something but practising something seemingly procedurally. Even if I understand integration well and have done it thousands of times, if I don't continually practise it from scratch, I begin to forget tiny bits and pieces and that accumulates to an eventually lack of understanding. So it is true for all mental tasks. There really isn't such a thing as understanding something completely without working it out by hand, from scratch. AI exacerbates a lack of understanding in this regard, although admittedly layers of abstraction in the coding realm already do that to some extent...
    • Izkata 2mo ago
      To repeat their last two sentences: > Even before LLMs we were aware if it: we knew people moving to managerial/PM roles eventually get their coding skills rusted. Well, now we are all in those managerial roles...
• effnorwood 2mo ago
  [dead]
• HarHarVeryFunny 2mo ago
  It's better than nothing perhaps, but reminds me of UK highschool in the 80's (is it any different now?) where we had to manually copy everything down that the teacher was writing on the blackboard rather than the teacher giving handouts so you could pay attention to the teaching. The act of copying everything down was a negative rather than a positive. Of course agentic coding tools are not trying to peer code or teach/inform you what they are doing, so being present in the moment doesn't help, but I suspect that copying it all down later doesn't help much either. When you are/were developing software without AI, even for pretty large projects you do end up internalizing (memorizing, but not deliberately so) a lot of detail, but from my own experience I'd say it's more the design than the code. The design is what you put effort into, thought about, etc, so is both what you naturally end up memorizing, and is what you need to know to have a mental map of the project and therefore understand how best to modify it. The code itself was naturally always the last thing you did, and followed automatically from the design and module/component interfaces - not something you typically think much about other than while in the flow of just "coding it up". By retyping LLM-generated code, it seems you are mostly going to be gaining familiarity with the wrong thing - the code and not the design. Memorizing the code is not going to help much in grokking the design.
• AndreiCalazans 2mo ago
  It seems to me this is the same problem we previously had: how do we understand codebases we didn't write? Creating while writing allowed us to build a mental context but in a unproductive way, it never scalled. I believe we need to move onto a new way of reading codebases that go beyond reading line by line. I know people have explored representing code in 3D spaces. I don't know the solution. But I believe that is the problem.
  • jerf 2mo ago
    Ask your AI to chart the data flow through the program. Not that that's a magic solution but it's a pretty good start. By default, if you ask an AI to "generate documentation for this code" it generates the same broken documentation all the humans do too; an enumeration of all the modules in the code and what their API is. I'm not surprised, the training data is biased probably at least 25:1 in favor of this rather than the useful data flow documentation. Fred Brooks was complaining about this over 50 years ago and the discipline as a whole still gets this wrong. I'm not saying this is a future solution to all problems, but it is a now solution to some problems. 3D doesn't help. We live in a 3D world but our vision is 2D with a bit of augmentation from a second view point just a bit away. We derive some depth information from that, but we don't really "see in 3D". To do that we'd need to be 4D beings. There's a lot less juice in the 3D squeeze than meets the eye.
• npras1 2mo ago
  Big no for retyping llm generated code by hand. But a big yes for still typing code by hand, and not leaving it to the llm. Except it has to be the code generated by your brain. That is what will create new neurons and new connections, which is what will keep away the cognitive decline. And the constraint of not having to use llms will enhance creativity. Actually, the constraints llms add to your code are more in number than the former. llms code in only the specific ways they've been trained on. So you won't ever come across of other ways. Off the top of my head.. here's RubyQuiz.com [0] which I came across when I was learning ruby more than a decade ago. Looking at the many user-submitted solutions (you have to download the zip file!) you'll see completely different ways the problems were solved. Sure, many won't be deemed efficient or standard by today's llm or rubocop checks, but looking at their code.. and retyping them and seeing them work.. was crucial in how I was able to think in Ruby for solving coding problems. I did the same with Go too, with the "learn go with tests" guide [1]. [0] - http://rubyquiz.com/ http://rubyquiz.com/ [1] - https://quii.gitbook.io/learn-go-with-tests https://quii.gitbook.io/learn-go-with-tests
  • kakacik 2mo ago
    There are jobs where llms can massively speed up delivery. Think about tiny/one man indie games for example, they can also get (stolen) assets almost for free. Helping with hobby projects, a subtype of that one man show. Then there are sluggish corporate jobs. Here, even 10x speed up of development won't change delivery dates significantly or at all. I am in one such job, team leader has claude code higher tier and basically uses it for some more complex bash scripts and thats mostly it. Given this topic, I dont complain much, I value my long term senior skills way more than those new agentic ones. The middle is... well somewhere middle.
    • Zambyte 2mo ago
      Copying is not theft.
      • ebcode 2mo ago
        Can we get that added to the US Constitution and the UN Declaration of Human Rights?
• sharpnick 2mo ago
  [flagged]
• deleted 2mo ago
  [deleted]
• FailMore 2mo ago
  I empathise with this. I run a little open source project called SmallDocs [1][2] which Claude/Coding Agent invokes to generate easily human readable Markdown documents (and render code files). You can ask Claude to "sdoc me an annotated code walkthrough of this MR" and it will produce something like this: https://smalldocs.org/s/Ju9GOmWZ0JXTtzqCVfgt1q#k=6HBrpcCjIu7cDaHvs1GihbPVhQAhbAfhdTmIc0hg7qk https://smalldocs.org/s/Ju9GOmWZ0JXTtzqCVfgt1q#k=6HBrpcCjIu7... I use this a lot to stay in touch with the code the LLM is producing. [1] https://smalldocs.org https://smalldocs.org [2] https://github.com/espressoplease/smalldocs https://github.com/espressoplease/smalldocs
  • aua 2mo ago
    This is really cool, ty for posting it. Gonna try it out
• leviyi 2mo ago
  [flagged]
• Alessio97 2mo ago
  [flagged]
• jasonjmcghee 2mo ago
  I don't manually retype the code from pull requests of other engineers. It's important to retain the what why and how as a team to the degree that development can be efficient, extensible, and maintainable. (And ideally a good devx) Needing to manually touch every line of code is not scalable. This was true 10 years ago. It's still true today.
• reacweb 2mo ago
  Generate code using LLM on a small project, then copy manually toward your big project. This reduces the context (and the cost) for the LLM and gives you many small projects where you can experiment ideas with more agility.
• simondotau 2mo ago
  In my current workflow, I've settled into a three tier system when coding: 1. HIGH-VALUE CODE: I write it all myself. I will occasionally use AI for mostly mechanical changes, like cleaning up variable names or mass-changes when a function signature has changed. Either way, every line is read carefully. Sometimes this means isolating my high-value code as a library in a separate repo. Usually it's just a note in AGENTS.md, or even a well-written comment at the top of certain files. I'm not obsessive about it, though, as it can't hide from git. And learning what it's trying to change is sometimes a useful insight. That doesn't stop me from using AI as a consultant. This is the one time I'll use a beast like Fable. Ask it to write a technical/security analysis on a section of code and damn it can pull out some impressive insights. It can't write new code particularly well, but it can inspect code like a boss. But that all stays in the chat window. (And despite being so infrequent, they ends up costing significantly more than all my other AI costs combined!) 2. BOILERPLATE/PROCEDURAL CODE: I'll write the first draft, but once I've set the tone, I'll allow AI to build and maintain it. I keep on top of things like a senior manager, just to make sure it's not doing stupid things. Every few days I tell it to mow its own grass: AI is good at recognising its own stupidity, you just need to give it an opportunity to look. 3. TEST/HARNESS CODE: Bring on the slop. If I get nothing else from the AI revolution, it's not having to write another stupid test unit. Nothing makes me happier than setting the AI to work writing every permutation of test I can think of. I will slop this code all day, and I won't read a single line of it. Why should I? If I ever doubt whether a particular test is correct, I'll test the test by breaking the code, not by reading the test. But I almost never catch it out. In my experience, AI is especially good at writing tests. Perhaps more than anything else. Tests don't just take the form of a few mocks and props in a test harness. In one recent case, my project involved writing a library for the API of an obscure commercial microcontroller-powered device. I took the API documentation and made AI build me a complete simulator. I then made it write a full suite of tests using my client library within the test code. I then got it to run that test suite against real hardware and identify any inconsistencies. From there it could recursively modify the simulator until it became unreasonably good at mimicking the real hardware. I haven't read a single line of its code. But it's now core to the library's CI.
  • someone_eu 2mo ago
    > 3. TEST/HARNESS CODE: > Bring on the slop. Bring on Volkswagen tests, right. Because reliably confirming that your code work is not a critical port of the project at all. /s
• elAhmo 2mo ago
  This is not slightly comical, it is very comical. Side projects are not mandatory, if you are using them to learn something, asking LLMs to generate and for you to type it makes no sense - just do it on your own. If you want to offload tedious boilerplate part to LLM, then by definition no need to learn it as it is tedious, so typing it out is useless.
• dataviz1000 2mo ago
  Do mathematicians and physicists put away the calculator and computer (this always reminds me of the last scene from Star Wars) and do the computation by hand? A physicist isn't going to manually invert a 10,000x10,000 matrix. Exactly as we don't write machine code letting the compiler do that, now and in the near future we won't be writing high level programming language code. We are moving towards working on a higher level of abstraction. When I ask a frontier model to write a loop 10 different ways in Python and TypeScript and test the performance of each using a 1,000,000 iterations, it isn't creating cognitive debt. For the time being, I'm still racking my brain asking the question, how does garbage collection affect the performance.
  • almostdeadguy 2mo ago
    I feel like we're doomed to respond to these lazy analogies ad infinitum. Knowledge abstractions have historically been built by people with a detailed understanding of a problem domain and with a period of vetting the abstraction by many people. That is simply not true with LLM-generated code. We do not really understand what techniques LLMs are using to understand directions, value aesthetic/legibility characteristics, assess tradeoffs, retrieve contextual information, generate output, etc. Embedded in everything LLMs do are small decisions. If you reach for formulas that you don't understand the applicability of, you will similarly get bad outcomes! But a calculator has almost no resemblance to what happens when you give general instructions to an LLM and get a generated code back, because in between that prompt and the result are many layers of decisions you the developer did not make and likely will not understand without carefully assessing the output! If you have no discomfort with being culpable for something and doing none of the work to understand it, by all means, don't do anything to understand the output! Don't read the code, don't re-type the result, etc. I have concerns that you'll have a job in a year, but that's your decision to make!
    • deleted 2mo ago
      [deleted]
    • dataviz1000 2mo ago
      A computer used to be a term for an occupation. [0] > I have concerns that you'll have a job in a year Me too because I might be the best TypeScript coder on Earth and there is no demand for those skills. I'm doing a pivot. [0] https://en.wikipedia.org/wiki/Computer_(occupation) https://en.wikipedia.org/wiki/Computer_(occupation)
• WhyComboNadir 2mo ago
  Lots of reactions here, but if it works for you then that's great. For me I feel that LLMs have exploded (in a good way) my cognitive capabilities. I'm now the general of an army, rather than playing the role of a soldier. Of course that means that I lose the experience of being the lonely soldier, but it is a no-brainer tradeoff for me. Anyway, I have to go now so I can push my car to the grocery store (so I don't forget how to walk), me and my giant calves will be back in a few hours. All meant in good spirit. Keep doing what you're doing, thanks for sharing, and hope people are kind and only give good natured ribbings.
  • theappsecguy 2mo ago
    I feel like you think the car analogy was a clever parallel to draw here but looking at a car centric north american population and the dimensions of a non trivial slice of them that are unable to walk a 5k, id say you made the opposite point.
    • WhyComboNadir 2mo ago
      You have a point based on the way I wrote it. What I was trying to get at: If you're going to walk to the store, don't push you car there! Just walk. So if you want to write code, don't retype what the LLM said, create your code from your own brain.
      • tmnvix 2mo ago
        Haha, your analogy reminds me of one I often make to highlight just how much we undervalue fossil fuels. Imagine filling your car with $1 worth of fuel and then driving it on flat terrain as far as it will take you. Now get out and push your car back. Friction and momentum aside, that's the astounding amount of energy/work we get from a dollar's worth of fuel. Now imagine your car is actually an LLM model. It gets you a great distance on $1 worth of tokens but what happens when you run out and for whatever reason (I can imagine quite a few) further LLM use is not possible. You have to push your car/LLM back all by yourself to finish what was supposed to be a quick, convenient trip to the grocery store. Might've been better off walking. Seriously though, I do think there is a real risk that LLMs are going to lure a lot of people far beyond their ability to swim back. It might even be the case that LLMs help strand people in situations that even the LLMs can't help rescue them from.
• plmpsu 2mo ago
  Jack Kerouac famously sat down and typed "Anna Karenina" on a typewriter because he wanted to feel what it was like to "write a great novel".
  • altmanaltman 2mo ago
    I think you're thinking of Hunter S Thompson, Kerouac really doesn't seem like the person that would have the time or care about doing that.
    • plmpsu 2mo ago
      You're right! Thanks for the correction.
• dools 2mo ago
  I don't understand the concern about "cognitive debt". I frequently have to maintain code I wrote, or someone else wrote, weeks/months/years ago and I have NFI what's going on. Now I say to the LLM "tell me what's going on" and it tells me. I can ask it some follow up questions, and build up my understanding. It's SO much faster than grepping through the source myself and I can do it for as multiple issues in parallel. The notion of reading every line of code is absurd to me, the notion of RETYPING it beggars belief. Surely this is satire.
• champagnepapi 2mo ago
  At that point I feel like you might as well do the implementation yourself and just plan with an LLM
• thundercleeze 2mo ago
  Cognitive debt is an idiotic phrase.
• 1shooner 2mo ago
  This is really the distinction between the mentality of a technical manager and an individual contributor. Managers never got to write and internalize every line of code anyway. Arguably their essential skill is producing useful stuff without needing to do so. So is that 'cognitive debt'? When I use an agent to code, I do the same things: I validate the direction, organization, and core decisions, but delegate the details. It's an intentional calculation of risk, managing the scope of future problems if there's a failure of implementation somewhere. It's a question of where you put the value of cognitive focus. I don't understand 'line by line' how my car's ICE works, even though it will likely impact me at some point, because while I might be able to fix it myself if it breaks, the likely applied solution will be to delegate that work anyway.
• nunez 2mo ago
  > As I manually type every single line of LLM generated code into my editor, I build up a mental model of how it works and fits into my existing codebase. If I don't understand an API or algorithm, I can stop to look it up, or just ask the LLM to explain it. This is part of how I learned how to code! Well, sans LLMs. Instead of copypasta-ing code blocks from books, Expert Sexchange and Stack Overflow, I manually retyped everything, looked up what I didn't understand and changed what I could.
• hneqy2wqls 2mo ago
  [dead]
• 0xdeadbeefbabe 2mo ago
  I ask the LLM to generate the code but mask the last token. Then I do softmax and give it an answer. Pretty soon my perceptrons are more connected than ever.
• mahami 2mo ago
  In my love(?)-hate relationship with "vibecoding", even I tried this approach. For a while it worked, though that "while" didn't last as long as the months OOP has been riding this wave. Though, the vibes have usually been off, so I wish I could keep both thinking of and writing that code which adds negligibly to shareholder value. I say "wish" because a part of me has definitely been hijacked, in much the same way as the addictive type of social media. Sometimes I feel like I need a serious intervention.
  • flawn 2mo ago
    Can't agree more, I feel the same.
  • globular-toast 2mo ago
    LLMs are addictive, no doubt about it. We've found the cigarette of our time.
• pton_xd 2mo ago
  Retyping LLM code sounds absolutely miserable and soul crushing. Like hand copying the HTML produced by page generators... why would you do that to yourself.
• gowld 2mo ago
  better: before submitting the code, ask LLM to quiz you for understanding the code.
• TRiG_Ireland 2mo ago
  I got made redundant shortly before the release of LLM code generators, so I've never used one, but I did occasionally do this for short snippets from tutorials and suchlike.
• fourseventy 2mo ago
  Lets prevent cognitive debt by manually retyping the assembly that is generated by our compilers...
• Rzor 2mo ago
  You do that enough and I bet you'll be labelled "the slow one" in certain circles, so before attempting that as a junior make sure you have some measure of protection.
• m3kw9 2mo ago
  Thats nuts. You are fighting a tool that is supposed to offload that. Is like lets not use the power tool, but do it by hand so your muscles won't atrophy, but you should instead use it to free up your muscles for other tasks like better requirements, architecture, tests, UX design.
• kburman 2mo ago
  [flagged]
• kittikitti 2mo ago
  This is really good advice that I've found to be true, especially if you have autocomplete turned on. At the same time, I'm privileged enough to have a fast typing speed and anything less than 60 WPM would make this practice very annoying. Thank you for sharing this.
• luciana1u 2mo ago
  [flagged]
• phendrenad2 2mo ago
  Seems like a much better idea would be to build it yourself first, then have the AI do it for real? If you don't understand what you're building, you're going to get a lot of surprises when you re-type the AI-generated code and realize it subtly mistook your prompt or made decisions you didn't think to specify.
• dukezzz 2mo ago
  that's a great approach, the bad thing is that (at least I) will forgot my codebase anyway after two more projects. so i'm wondering if it worth the effort. i prefer to impose my vision on the code upfont and then rapidly check the my vision is respected rather than understanding every single line
• smegma2 2mo ago
  Seems like an ok solution, but what about doing something like the opposite? Write out the scaffolding and general shape of the code (classes, interfaces, function signatures), and have the LLM fill it in. That seems more important for understanding.
• sandover 2mo ago
  Print this article out and put it in the scrapbook. File next to that 1970's era classic, "Prevent cognitive debt by manually retyping compiler-generated assembler"
• overthenexttwod 2mo ago
  I share the author's sentiment. I also think it's important to fully understand a codebase I own. So much is naturally lost when you let LLMs generate code for you, and the mental model of what the added code does is one of the biggest losses. When you write code by hand, you build that model as you go, and it's enormously helpful later - when adding a feature, or when debugging behavior you didn't expect. I've been trying to address this by telling LLMs primarily how the code should be structured, rather than only what it should do. Still, any design I hand to an LLM will be underspecified in one way or another (if it were fully specified, it would just be code), and the LLM fills those gaps somehow - which adds to the cognitive debt, slowly but surely. Retyping LLM-generated code is an interesting solution. You'd certainly end up understanding the generated code better than if you merely reviewed it, but I doubt it produces a mental model as reliable as the one you'd build writing the code yourself. The longer you think, the better your mental model gets - and outsourcing the thinking to an LLM means thinking less. That said, I've started to wonder whether I'm solving the wrong problem. Should I really insist on an accurate mental model of the code I own? We'd find it strange for a non-engineering manager to try to fully understand every piece of code their reports produce. If that's the right analogy, then as LLMs' agentic capabilities improve, maybe we should stop treating LLMs as tools that boost our own productivity as a software engineer and start treating them as independent agents we manage and steer.
• andai 2mo ago
  The Zed Shaw method!
• 4b11b4 2mo ago
  Hah I was just thinking I should switch to colemak that I only let myself continue with for 2 months and re-type out all the domain (types, etc) for this project I'm working on
• jmartrican 2mo ago
  In highschool, my history teacher's home work assignments were to write out the notes he created and handed out for us. Essentially the assignments were to read chapters from the text-book, then copy the notes by hand and hand them in. It seemed odd. But I think their is some wisdom to it. As you writing it out, you are slowly reading what you are writing... even if you do not mean to.
• Velocifyer 2mo ago
  I simply never ask LLMs questions specific to my codebase (except for finding what function/file does something, because that is annoying), and instead use generic questions.
• androiddrew 2mo ago
  So I always make sure I take a crack at doing what I want first. Then I ask for an AI review and it usually has a more efficient way to get the job done. For example I had a working linear decay velocity boost function added to a godot scene and it's suggested refactoring actually reduced lines of code just today. So kind of happy when that works out, but yes I also applied the changes manually so I would grok them and hopefully remember it better.
• vavooom 2mo ago
  What's the right middle ground approach to this? I agree that inevitably my more advanced software approaches at work have been compromised by reliance on LLMs, especially given encouragement from management. Are there specific prompts/instructions people find that allow for learning and iterative development without slowing down the actual development cycle too much? I want to keep learning and keep my skills sharp but it feels like a losing battle.
  • 6thbit 2mo ago
    Use it not just as an output tool but as an input as well. You could try doing the high level design yourself at least. Ask for its review and iterate without asking it to do it all. Once it has generated some implementation, critique it and ensure you understand its approach And you agree with it, steer it otherwise. If there’s anything unclear to you say so and have it rewrite it in an easier way to understand.
  • petesergeant 2mo ago
    Yes, use Matt Pocock's /grilling skill to make sure you're thinking about and understanding and signing off on the _technical design_.
• summarybot 2mo ago
  Pretty crazy idea. I know I sometimes just "wave through the motions" when I'm taking notes. For example, when I am reading a book, I often take notes of my favorite quotes/sentences/things that stick out or perk up my ears. Usually if I own the book or it's a used copy of mine I make a note of the page number on the very last blank page(s) and write out the full sentence/quote. Then when I go back months or years later I just open to the last page and can find all my favorite/important quotes. Most 200 page books typically have ~20 useful sentences for me to reference [going forward] - it's basically like making your own index or table of contents. That long aside, just to say, if I'm not "very aware" or "consciously mindful" of what I'm copying down or writing, I'm able to do it very well on autopilot without etching anything into my memory -- as if no recallable moment gets etched into the wet cement of the brain unless I'm actively "hip to it." I wonder if others have this "autopilot" problem.
• snitzr 2mo ago
  At this point, just write the code yourself with your brain.
• Mike-Kelner 2mo ago
  I've been asked several times how I use AI. My answer is - pretty much the same way I worked with developers on my team. I give a task, review the result for a reasonable amount of time - which might be close to zero for a minor front-end change - and then either accept it, change it myself, or ask for revisions. That approach works well for me, so why would I retype AI-generated code? I wouldn't do that with code written by another developer, and their code can be just as buggy or weird in theory. You could argue that at least the developer knows how it works. That's true - for a week, a month, or a few years if you're lucky. Until he forgets or leaves.
• alex7o 2mo ago
  To be honest I am thinking of an entirly different situation, ask the llm to create Red tests for you. Then implement them yourself. You don't waste time writing tests but you still need to spec what you implement properly so the llm can write good tests for it
• VCFundedGenYer 2mo ago
  Just write the code. This weird obsessive dependence on LLMs doing everything will ruin you as a developer and prevent you from progressing in the industry when the AI bubble/fad pops. Don't let your skills atrophy.
  • champagnepapi 2mo ago
    agreed!
• PlayerToo 2mo ago
  I am currently betting on LLMs being significally better than even top engineers with good 'taste' within the next 5 years so I am focused on learning how to drive AI better. Anyone thing I should alter my apporoach/thinkig?How?
• cleverKnight 2mo ago
  > I fear the software industry is taking on a large amount of cognitive debt that we'll have to pay back very soon. There will come a time when we no longer understand how large parts of our digital infrastructure are put together. I might not personally be able to change the course of the entire industry, but I can at least make sure I completely understand the software I put out into the world. Anything else would be professional malpractice. "professional malpractice" LOL. This is so dumb. I can't believe this shit is getting upvoted.
• ltbarcly3 2mo ago
  This is the stupidest thing I've ever heard. "Stay in shape by walking behind your car."
• bodash 2mo ago
  Similar to where we simply ask LLM to leave 20% of the work undone: humantodo.dev
• bztzt 2mo ago
  this is how I did "AI coding" (for unfamiliar languages/frameworks/etc.) back in the GPT-3.5/4 days. Except I'd also test each line to verify it actually did what I thought it did.
• jesse_dot_id 2mo ago
  In the life of the LLM, we're still in the phase where we're all on the floor playing with these toys. It's strange to assume cognitive debt is an absolute outcome in this new paradigm of engineering when nobody really knows what the future holds. Personally, I feel like I have more time to think, not less, but that's also just my experience. Part of the fun of this is that we're all science experiments right now. I'm just kind of enjoying the feeling of riding on the swell of a gigantic wave for once instead of feeling like I'm starting from behind it.
• wnmurphy 2mo ago
  There's value to hand-copying something. Hunter S. Thompson transcribed Hemingway to internalize the cadence of his writing. However, if you're serious about it, then why not hand-write your LLM-generated code? You'll get much better retention and comprehension than typing.
• voidhorse 2mo ago
  I don't think it's possible to eliminate cognitive debt when using LLMs, but you can definitely minimize it. Part of this means recognizing that you will only get, say, a 2x productivity boost instead of a mythical 100x increase, the benefit is, you'll actually know what you're doing versus being a brain addled zombie. First, use the LLM to understand the problem thoroughly. They can be great research aids. I've speed up tons of learning using LLMs. It is essential you ground the discussion in existing texts or code. Ping pong with the LLM asking it to challenge your understanding, how you direct citations for explanations, clarify things, etc. After you've understood, plan. Develop a plan with the LLM/agent by steering it hard. Read the slop text thoroughly. Give it direct feedback. Don't proceed until you have a complete expectation of what you think the agent will do when implementing the plan. Let the agent do all the implementation. Review the agent's work. Again, engage with it and leave direct feedback. Ask for clarification and alternatives if needed. If it was totally off mark, start the process again. You won't be moving at warp speed with this approach but you'll know a lot more than the one shot prompting loop cowboys out there.
• LunicLynx 2mo ago
  The industry does. Not. Care. 64 GB of RAM, nough said?
• 1vuio0pswjnm7 2mo ago
  Not familiar with this term "cognitive debt" A debt implies repayment. But the loss here is not going to be repaid, it's permanent Perhaps a more appropriate term might be "cognitive deficit" or "cognitive loss"
  • TheJuli 2mo ago
    Repayment here means that you eventually need to invest the time to understand the approach used and the code intricacy, to later fix or build upon IF you are to manually/artisanally (for a lack of a better word) go about addressing the issue. ...if you use AI again, then yeah it's a permanent loss.
    • fbrncci 2mo ago
      At this stage with AI and how massive AI generated codebases are growing, the chance of fixing anything manually has already reached 0.
  • dools 2mo ago
    It’s an extension of technical debt. They’re both bullshit in my opinion.
    • 1vuio0pswjnm7 2mo ago
      That's what I thought
• Syzygies 2mo ago
  "In theory, theory and practice are the same. In practice, they're not." I tried this, long ago. I just wasn't getting Haskell, so I'd retype my programs from memory and reconstruction. Obvious for music, why not for code? All these untested opinions? You'd think we were discussing BMWs.
• Kevcmk 2mo ago
  Cognitive debt is a huge problem but this, personally, is definitely not a solution to it
• epolanski 2mo ago
  I do something different, I type everything by hand and have AI provide feedback. It's one of the best ways to kickstart projects that have intrinsic software complexity as you get your hands wet into the design tensions and constraints early. And you get to practice some.
• ablob 2mo ago
  So we are reduced to code monkeys mindlessly re-typing what an LLM wrote to increase potential understanding... Whatever this approaches, it is not a state of software engineering I find desirable.
  • 20k 2mo ago
    heaven forbid we use our meat to actually completely understand it in the first place
  • colordrops 2mo ago
    I think some sort of visual paradigm is where we will end up. Something like Star Trek, where the system architecture and modules are visually represented in 3D space, and you see how the organization changes with realtime low-latency animation representing the changes as they are made. So you are still in control but just at a higher level. I see some prototypes and weak implementations of this sort of thing but surprised at how little is out there.
    • nharada 2mo ago
      Agreed I want an IDE but only architecture. I suspect it’ll get superseded though eventually too.
    • andsoitis 2mo ago
      [flagged]
    • noduerme 2mo ago
      The problem with all existing GUI coding system is that they make it really hard to make anything other than the types of things they were designed to make. You could do it, but you have to leave the path and get into the weeds of how the system works, which usually has several layers of opinionated code structures on top of the underlying language it's compiling to. An AI visual/GUI coding system might be able to address that at a more modular level, but it would still come at the cost of transparency and reproducibility.
• blackqueeriroh 2mo ago
  There is so much bad science about psychology and cognitive debt posted on Hacker News every day. It’s so exhausting.
• bigbuppo 2mo ago
  As someone that learned typing "the proper way", I have doubts about this.
• GuB-42 2mo ago
  Same idea with Stack Overflow solutions before that. But I don't just retype that code verbatim, I rewrite it in my style, add or remove comments, add or remove some checks, sometimes even tweak the algorithm. I want to own the thing. Some copy-pasting may be involved, I am not trying to improve my typing here, but the important thing is to understand every character of it.
• bigbuppo 2mo ago
  Also... if your workflow is "think hard, let LLM write it, read what AI wrote, think hard about what AI wrote, re-type what AI wrote, fix what AI wrote"... Where in the heck are the efficiency gains? Couldn't you just drop the LLM part of it and save the company a trillion dollars in tokens?
  • ncallaway 2mo ago
    I've found I can get quite a bit of use out of it as a basically ever-present rubber duck. Using a cheap model, I usually spend < $1-$2 per day (on API billing) using it a model like. - here's the problem I'm trying to solve: - here's my initial plan for the design: - is there anything I'm not thinking about or my plan is missing? It'll occasionally pop out a suggestion that I like more than my original plan, or it'll give me some new angles to think through the original plan.
    • baliex 2mo ago
      I’m guilty of using this approach too and noticed that an (obvious?) side-effect is that I get fewer wonderful, human, “aha” moments with my colleagues. I mentioned this at a stand-up and only then did others think about it and notice the same of themselves. This, to me, is one of the major downsides of all this: less collaboration, more individualism
      • noduerme 2mo ago
        I think that's true. One caveat: If you're a solo coder like me, you almost never get to talk about implementation details with anyone who (a) understands or (b) gives a flying fuck. I'm more likely to have a meaningful convo about code structure with someone on a laptop sitting next to me at the coffeehouse. So sometimes a stand-in bot to bounce your ideas off of can illuminate corners you're missing, even if it's in some ways no operating just as a chat with yourself.
      • bigbuppo 2mo ago
        > This, to me, is one of the major downsides of all this: less collaboration, more individualism Or put another way, it's replacing collaboration and human connection with your team with a subscription service that isolates you, makes you emotionally and cognitively dependent on the service while making your performance numbers look good. I really don't like the sound of that.
• 3dsnano 2mo ago
  “prevent cognitive debt by manually setting type.” we need to move on
• system2 2mo ago
  While your competitors ship out million-line software, you are going to write down the LLM code. This approach will make a software engineer homeless in a very short time.
  • bendmorris 2mo ago
    LOC is not a good indicator of productivity or quality - or it anything these days it's a negative one. "Million-line software" is meaningless.
    • system2 2mo ago
      From a marketing perspective, I do not agree. The competitors can claim 100 more features than your "lean" code. That by itself makes you lose customers.
• deadbabe 2mo ago
  Better to be a coder in the garden, than a gardener in the code.
• kamens 2mo ago
  I used to do this and called it "Coding with AI the Hard Way" in a nod to Zed Shaw: https://kamens.com/blog/code-with-ai-the-hard-way https://kamens.com/blog/code-with-ai-the-hard-way I no longer do and blogged my updates for fear of being seen as a luddite: https://kamens.com/blog/code-with-ai-the-hard-way-update https://kamens.com/blog/code-with-ai-the-hard-way-update https://kamens.com/blog/code-with-ai-the-hard-way-update-ii https://kamens.com/blog/code-with-ai-the-hard-way-update-ii
  • jaggederest 2mo ago
    Ben if you're going to blog about things with relative timestamps you need to provide a base timestamp, and I would also appreciate that for when you update the post. "3 months ago" is unhelpful without that context. Well done for registering your beliefs publicly and updating them publicly. So many people out here exist in an epistemology-free zone.
    • richardbarosky 2mo ago
      I'm seeing what looks like a date in the top-right corner of the header banner. Not sure if it was added in response to the note, so mentioning just in case!
      • jaggederest 2mo ago
        ah you're right, it was just subtle, mea culpa
• nullbio 2mo ago
  A better interface for code review would be a pseudocode layer that sits on top of all of your code, at the editor level. Basically it would convert all of the chunks of your code using an LLM to simple pseudocode with clickable symbols so you can follow function calls, definitions, then you could expand/collapse it to see the real underlying code.
  • elzbardico 2mo ago
    I know how to program, why do I need things to be converted to pseudo code?
    • nullbio 2mo ago
      It's easier to skim pseudocode than it is to reason about complex logic. When I say pseudocode I'm talking very high level but structured explanations, and less the sort of traditional pseudocode you'd imagine which is basically just a generalization over syntax.
• elzbardico 2mo ago
  I still write lots of code. And there's still a lot of code for the LLM to do. I prefer comunicating with an LLM in terms of code, having it grounded by code that I have already written, it can be a function signature, a struct, an interface, a trait, the skeleton of a test suite. It can even be a sequence diagram in mermaid, but I refuse to let it go. I stubbornly refuse to let the LLM design. I can discuss my design with it, I can even completely discard it, but I am not fucking writing reams of natural language. And know what? I don't think I am less productive than my "looping" colleagues, because, well, code is way less ambiguous than natural language, a validation rule in code can usually be expressed more economically in a programming language than in english prose. It is easier to create a directory and file layout, sprinkle some declarations here in there than it is to EXPLAIN how the flow of dependencies go. It is easier for me to create a hook because I want users of a certain module to be able to change its behavior without having to change the source of the module than explaining the OC principle to the LLM and seeing it miserably failing to apply it, because it doesn't have a theory of what it is fucking doing. And as a side effect, when the 30th day of the month comes, and all the company tokens for the month are used, I can still be productive while others wait for the CTO to negotiate a couple tens of thousands more in API with the CFO.
• mohamedkoubaa 2mo ago
  Please don't do this
• shermantanktop 2mo ago
  I’ve got similar concerns about skill rot, but I also have chronic RSI and some hand arthritis. LLM assistance plus modern voice models are a godsend but it’s not the same as typing every character. But I can’t really type every character anymore. I can read it all but…falling into skimming is very hard to avoid. So I’m grabbing the double-edge sword with my bare hands hoping to stay ahead of the brain rot…somehow.
• tsizz 2mo ago
  Few will remember this is how programming started for many, including me. Wait for that issue of Family Computing to show up, so you could manually type in the program for that Turkey game to run.. Appreciate you bringing up the good ol' days.
• ynab6 2mo ago
  [dead]
• gxs 2mo ago
  I don’t know it feels like some og programmers would say the same thing about people who can’t program machine language Code quality is only going to get better and to be perfectly honest learning how to get the llm to generate quality output is IMO time much better spent vs some misguided attempt to do something by hand — the prompting is the better skill to develop at this point and if you’re worried about atrophy it’s probably your least developed skill Instead I focus on reading the plan and making sure I understand it, opening up a second session for second opinions or questions if I have gem This obviously depends on where in the stack you live but code quality is accelerating at a significant rate - decision making not as much and it’s where your value is imo
• redleader55 2mo ago
  Right ... While we do that, let's also retype the assembly code the compiler produces, do the linking manually and check you got the same result as the linker, and then finally write the bytes yourself. Whether or not you manually bit-bang à la Morse code the bits to storage is left as an exercise to the reader.
  • linuxhansl 2mo ago
    While I agree on some level, this not a great comparison. A compiler/linker/etc is an algorithmic, precise, verifiable, repeatable, debuggable, etc, etc, process. Using an LLM is an inherently stochastic process. It can is very, very helpful, but I think we are arriving at the realization that "vibe coding" wasn't the best idea - unless you are doing a PoC or demo. In any case, neither absolve you from understanding in detail what is going on. Maybe we'll get there, and we can fully trust what the LLM produces, but it seems we are not quite there, yet. Until then we'll have to understand everything the LLM produces and that's what the author is getting at.
• aucisson_masque 2mo ago
  > might not be the most efficient way to work with an LLM, but I value comprehension over productivity. LLM are becoming so good that they are better than us at understanding code. And it's only going to get worst every year. I think that the job of 'coding' is done, it's dying and will be effectively dead in a decade. You better find ways to make yourself usable around LLM work but not by doing what LLM already do.
  • Anamon 2mo ago
    LLMs don't understand a damn thing. They can't. They're not built to. An LLM doesn't "understand" its own slop. It can use that slop as further input for generating more slop on top of it, but at no point of the process does anything like a concept or understanding come in.
    • aucisson_masque 2mo ago
      I know it's not supposed to understand but it's just so good at faking it, and being right, that at some point we can claim it's 'underdtanding' it. Or you'd have to invent a new word.
• backend_dev82 2mo ago
  "... I don't enjoy reviewing AI-generated PRs. Poring over hundreds of lines of overly-defensive, badly-commented, subtly incorrect code is not fun. I might grudgingly do it for an employer—while making sure said employer becomes an ex-employer as soon as possible..." I don't know about where you work, but in my neck of the woods if you want to be employed you will be reviewing AI PRs, there is no escaping that.
• nevertoolate 2mo ago
  Wait you only wanna make llm write the boring parts but after it has written it you retype. Without concrete example this sounds bizarre.
• bramadityaw 2mo ago
  this seems redundant as a methodology. just write the damn code yourself at that point.
• tombarys 2mo ago
  + let LLM generate just scaffolds, skeletons + do not let it generate code (let it generate leading questions instead of answers) + let it test you (try learning-opportunities repo from CatHicks)
• big_paps 2mo ago
  As someone who’s been programming for 20 years, I have to say that programming itself often causes a kind of brain rot. I’m very glad that I can now focus on other aspects of software development. It was only with Claude Code that I realized I never actually enjoyed programming—I enjoyed building things. You can live a perfectly mentally healthy life without programming.
  • radcod3 2mo ago
    > It was only with Claude Code that I realized I never actually enjoyed programming This is so real!
    • reconnecting 2mo ago
      20 or 30 years ago, programming was reserved for people who were truly devoted to it, even when the work was a nightmare of difficulty. Now, when I talk to programmers in their 20s and 30s and ask which program they first fell in love with, there's usually no answer. I'm glad they've stopped pretending otherwise.
      • eulgro 2mo ago
        They fell in love with the money.
      • Melatonic 2mo ago
        Nothing really wrong with that though. The amount of tech used by the average person has also increased dramatically in the same time period. You could argue the same has happened for computer use in general or for many things.
  • Drupon 2mo ago
    [flagged]
    • larodi 2mo ago
      yes, it also exposed lots of hidden talent, which is more important. and fakers are nowhere to go, but LLMs are indeed a litmus test for them.
• gib444 2mo ago
  The cope just keeps coming!
• Alisaqqt 2mo ago
  [flagged]
• bamboozled 2mo ago
  This is like flossing, probably good for you, hardly ever do it.
• ta8903 2mo ago
  I was working on a VS code extension that integrated with claude code to show an overlay for the changes instead of the edit tool calls so you could write everything yourself. The idea was that even if you type 100% of the same code instead of making your own changes, it would still mean you go through the code yourself and have a better understanding that you would have on just skimming through the generated code. Maybe I should start working on it again.
  • ta8903 2mo ago
    (posting this here on the off chance someone makes this instead of me so I can just use their version instead)
• jeffrallen 2mo ago
  Today I added a temporary data source to Prometheus to help me monitor a system closely during a tricky ops task. I would not have done that except that the LLM gave me a small script I could quickly check and immediately use. Without it, I'd have roughly spot checked the service via "tail -f". Our company's policy on LLM use is: use it, disclose it, and take responsibility for the code you commit. There's no way that typing that tool back in would have done anything useful for me or my organization.
• Havoc 2mo ago
  That’s just seems like a worst of both worlds to me. I can see both logic in doing manual coding (perhaps with AI autocomplete) or a vibe based flow. They’re orthogonal approaches though.
• yoanwaidev 2mo ago
  [dead]
• pvtmert 2mo ago
  [dead]
• v5v3 2mo ago
  >Typing the code myself forces me to slow down, which means I'm more likely to detect hallucinations or bad design choices the LLM might have made. I think this depends on your level of expertise with the task. If I'm writing a language I am extremely familiar with and so second nature to me, for example SQL then I can instantly read llm code. But if a new language or a new piece of software then llm generating huge amounts of code can make it difficult to improve yourself and also manage the quality.
• EgorKolds 2mo ago
  Good, but my workplace has a metric of AI-written lines of code, so I need to ask LLM to redo all of my changes after I retyped them from it.
  • softwaredoug 2mo ago
    We need a master list of companies with such stupid metrics :)
• veber-alex 2mo ago
  ain't nobody got time for that
• bhawika_kaushik 2mo ago
  [flagged]
• stevenalowe 2mo ago
  Replace LLM with “intern” and the absurdity should be more obvious The fact that we can’t trust the code outright is a bug
• MetroWind 2mo ago
  > Personal projects must be fun above all else. The joy of working on personal projects comes from the process, not from the outcome. I think that's my fundamental difference with the author. I only write programs I actually need. I enjoy the outcome more than the process.
• geldedus 2mo ago
  you definitely have lots of time in your hands
• tizerluo 2mo ago
  [flagged]
• arsome 2mo ago
  I've given up on coding personal projects because it feels like I could be doing them faster with AI and I just don't care to bother. Completely killed coding as a hobbyist for me. Still have a senior dev job... for now.
• beyondscale-sha 2mo ago
  [flagged]