The comprehension debt

Since I started coding seriously with AI, I keep thinking about what actually changed, and it’s not just speed.

Yes, I’m producing more. Way more. Things that used to take weeks now happen in a day if I stay focused. Entire chunks of work that would’ve required hiring, coordinating, waiting, they just… don’t anymore. That part isn’t subtle, and it adds up.

But the bigger shift is where the understanding comes from.

It used to be inseparable from the work itself. You’d sit with a problem long enough that the shape of it became obvious. Not because you thought it through perfectly up front, but because the act of building forced clarity. Every wrong turn, every refactor, every dead end, it all tightened your grip on the system until you could feel how it behaved.

Now it’s possible to get to something functional without ever really passing through that layer.

You can direct, adjust, refine, and end up with something solid. But there’s a difference between guiding something into existence and actually constructing it yourself. One gives you momentum. The other gives you ownership at a deeper level.

I notice it most when I try to re-enter something later.

There’s a slight hesitation that didn’t used to be there. Not confusion exactly, just less immediacy. Like I’m reacquainting myself with a system instead of stepping back into something I fully inhabit. I can still figure it out quickly, but it’s not the same instinctive recall.

I don’t know what to make of that yet.

The upside is real and it’s not small. Being able to collapse timelines like this changes what’s even worth attempting. Ideas that would’ve died early now get built and tested, and that alone creates opportunities that didn’t exist before. But I can’t tell whether the hesitation I feel when re-entering old code is just a new kind of friction, or the early signs of something more permanent.

Maybe this is what it felt like when people started using calculators for math they used to do by hand. You get faster, you lose some facility, and eventually you stop noticing what you lost because the tool is always there. Or maybe that analogy is too clean and this is different in ways I can’t see yet.

What I keep coming back to is that I don’t have a good way to measure what’s changing. The speed is visible. The output is visible. But comprehension is something you only notice when it’s missing, and by then you’ve already been operating without it for a while.

But honestly, building software this fast is just too fun to resist. I’ve lost comprehension on most code I ever wrote by hand anyway. What I didn’t lose is the understanding of how software works, because I kept practicing the craft and diving behind the curtain. As long as that part stays active, I feel like whatever problems come from the tradeoff, I’ll figure them out along the way.