Judgment Doesn’t Scale With Speed
A few months ago I realized I was merging code faster than I could explain. Everything passed CI. Nothing was broken. But days later, I couldn’t always tell you why I’d approved certain decisions over simpler ones.
One example stuck with me. I merged a refactor last week that passed CI without issue. Three days later, I had to reread the diff to remember why I chose that approach over a simpler one. Nothing was broken, but I wasn't sure it was the right call and that bothered me more than an actual bug would have.
Comprehension Debt
Technical debt is what happens when the codebase degrades. There’s another kind: when your understanding of it degrades. I think of that as comprehension debt. You don’t notice it building until something breaks at 2 a.m., and then you realize you can’t reason about code with your name on it.
I’ve been using AI coding tools aggressively for over a year: agentic tools, chat workflows, autocomplete, all of it. I’m faster than I’ve ever been. I’ve shipped enough code I couldn’t explain a week later to know going faster without understanding it is a trap. Anthropic's own research backs this up. AI tools can absolutely increase output. They can also weaken your ability to reason about the code you ship.
If comprehension debt is the problem, the real question is: what am I protecting when I review AI-generated work? I’m not sure I have this fully answered.
What I Protect, What I Don’t
Most of the discourse is useless binary stuff: either you use AI or you don’t, either you’re a “real engineer” or you’re dependent. You don’t want to be the person flooring it toward a wall with blinders on to everything but the speedometer. But I also don’t want to be the one still taking a horse to work clutching punch cards. The actual skill is knowing which tasks need your full attention and which ones don’t.
What I won’t delegate. Architecture. System design. Tracing a production issue through three services at midnight when something’s on fire (log parsing aside, which AI is fantastic at). All this stuff comes from reps, and I don’t think reviewing AI output builds it the same way.
What I’ve let go. Exact API signatures. CRUD boilerplate. Stuff I've written a hundred times and will never learn anything new from writing again. It's long division at this point. Knowing it exists and when to reach for it is enough.
The middle ground. First drafts of tricky logic. Reading docs vs. asking an AI to summarize them. Manually stepping through a stack trace. I still do these because they keep my instincts sharp… but, the line does move. The question I keep coming back to: is doing this manually still teaching me something, or is it just habit? I don’t always know.
How I Actually Work With These Tools
LLMs list the options. I pick. In unfamiliar territory, I ask for approaches, tradeoffs, and failure modes instead of “the best solution.” If I let the AI make the design decision, I’ve skipped the part of the work that matters most. I’ve caught myself doing this more than I’d like to admit.
I don’t touch code until I can describe what “done” looks like. What am I building? How will I know it works? What’s out of scope? No amount of prompting fixes unclear thinking on my end.
Small pieces, reviewed like someone else wrote them. Because someone else effectively did! I break work into chunks small enough to hold in my head. That’s usually the moment I either catch it or let it compound.
If I’m getting faster but less sure, something’s wrong. These tools should make me faster and more confident. If speed is climbing while certainty drops, I need to change something in the process.
Staying Honest
After doing this long enough, I’ve learned to watch for certain signals in myself. Copying prompts without thinking about what I’m actually asking. Accepting a design I don’t fully understand because the output looks right. Skipping review because the tests passed. That low-grade unease about a piece of code that I convince myself isn’t worth investigating.
When those show up, I take the next piece of work and do it manually. Not because hand-writing code is inherently better, but because the discomfort is telling me I’m losing the thread.
Honestly, the biggest fear is needing AI because I can no longer do the work without it. I want it to make me faster, not to become something I can’t function without.
Where This Lands
I don't have this fully figured out, and it shifts as the tools do. But I've got a framework that’s started to move with it. I keep coming back to this: speed is the easy part now. In my experience, judgment is the hardest thing to build and the easiest thing to weaken if you are not paying attention.