AI Coding and Context Tax
Generation is not Comprehension
When writing code using AI assistance, it’s easy to generate a lot of code in a very short amount of time. As the development process goes on, even more code will be created. This gets complicated when it comes to maintaining and expanding the code base. Over time the person working on the code has to get back into that code to address bugs or add features. Getting to the point where you understand the code well enough, again, takes time. I have seen that while it’s easy to create a lot of code with AI, it’s not as easy to come back into that code after it’s been created.
One thing we need to keep in mind when using AI to generate code is that now there becomes a difference between writing the code and understanding the code. In pre-AI software development, where you needed to manually write the code, there was a certain understanding of what you were writing while you were writing it. With AI, that process goes away. The code is created, and you then need to understand that code and become familiar with it so that you can then make updates.
When you write the code yourself, your brain is creating an internal model of that system that you’re creating. When you step away from that code and come back, some of that that internal model, will persist. Interacting with something, rather than just reading it, tends to be retained in the brain longer. Since you’ve written the code yourself, it’s easier to come back into that code and continue developing. If you have not gone through that process, if you are reviewing code that was written by AI or by another person, then you’re establishing familiarity with the code each time without having that pre-existing internal model. This makes it more difficult and takes longer to come up to speed with that code so you can continue development.
Protecting Comprehension
The answer isn’t to use AI less. It’s to recognize that AI handles code generation but cannot handle comprehension. Comprehension doesn’t transfer. Each of the techniques below are just a mechanism for forcing you to build a genuine internal model of the code, not just review it from the outside. If you spend 2 hours building something with AI that would have taken 2 days manually and then spend 45 minutes re-establishing context every time you return to it, the break-even on that speed gain comes faster than you think.
1. The spec-first inversion
The conventional flow is: prompt → code → review. Reverse the order. Before asking the AI to generate anything, write a 3–5 sentence description of what the code should do and why. Not a formal spec — just externalizing your intent. That document becomes your re-entry anchor, and it forces the model to work from your understanding rather than producing something you have to reverse-engineer.
2. Treat code review as active encoding, not QA
When you review AI-generated code, the goal shouldn’t just be catching bugs — it should be deliberately building the internal model you didn’t get from writing it. Don’t rubber-stamp diffs. Walk the logic path. Rename things that don’t reflect your mental model. The review is the learning; skip it and you’re adding to the context debt, not paying it.
3. The commit message as cognitive snapshot
Write commit messages as if you are explaining the change to yourself six months from now — not what changed, but why and what you understood about the system at the time. This is cheap, async, and gives future-you a scaffold that’s tied to the exact moment of maximum context. Git log becomes a context recovery tool, not just a change log.
4. AI-assisted re-entry
Use AI to rebuild context, not just create code. Paste the module into a fresh session and ask: “Explain what this does, what it assumes, and what would break if X changed.” That AI-generated explanation — corrected where wrong — becomes your working model. You’re using the same tool that created the debt to help pay it down.
What we’re seeing with AI assisted software development is that it is not a panacea. AI is changing the mental effort required to maintain understanding over time. It’s not just about how quickly we can create the code. It’s about being able to sustain that comprehension. The key takeaway here is to use AI to accelerate coding, but don’t outsource the understanding of that code. It needs to be understandable and comprehensible over time by humans after the code is written.