I used to debug my own code in my head. A year of building with AI took that away.
TL;DR: For thirty years the thing I was quietly proudest of as a developer was being able to debug code in my head. Away from the keyboard, I could usually tell you which file and which few lines were to blame. After a year of letting AI write most of my code, that’s gone. The code is mine, I chose every feature in it, and I now read it like a stranger wrote it. I gave that up on purpose, and most days the trade is worth it. But it’s a real loss.
A friend asked me whether I was getting tired of all the AI stuff. I am. I use it all day, every day, and I’m sick of reading about it and hearing about it. So this isn’t another post about how much AI can do. It’s the one thing from that conversation that stuck with me, and it isn’t a happy one.
What I could do for thirty years
I’ve been writing software for over thirty years. The skill I rated myself on wasn’t speed, and it wasn’t clever code. It was holding the whole system in my head. I could be away from the computer, washing up or out walking, and a thought about a bug I’d seen that morning would surface on its own. I’d roughly know which file it lived in and which bit of code was the likely culprit before I sat back down. That came from writing the thing line by line over weeks. You carry the map because you drew it.
Why I hand the whole change to the AI now
This came up because a friend was telling me about a game he’s building. He’d moved some characters around by hand, then changed how they walked their routes, and the manual fix broke. Small thing, very familiar. I told him I could completely relate, because that’s exactly the point where I’ve had to give everything to the AI. Once I can’t see the cascade, where one change quietly breaks three things I’m not looking at, editing by hand stops being safe. So I stop. I describe what I want, let the AI make the change across the codebase, and let the tests tell me what actually moved.
It’s worse when I didn’t write the code in the first place, which now is most of it. The cascade is hard enough to trace in code you wrote yourself. In code an AI wrote while you watched, you never built the map to begin with.
It’s like someone else’s code, except it’s mine
But that’s basically the same as picking up someone else’s code for the first time.
That was my friend’s line back to me, and he’s right, mostly. You can’t hold a stranger’s codebase either, so you lean on tests and search to find your way around. The mechanics are identical. You read, you grep, you run it, you poke at it until it tells you something.
But it doesn’t feel the same, and the difference is ownership. When you join a project someone else built, you never expected to know it cold. With this, I chose every feature. I made every product call. I named the files. And I still can’t hold it. The game is well over 100,000 lines now, across hundreds of files, so maybe holding all of it was never realistic. But I used to at least hold the shape of the parts I’d written. Even that’s gone. It’s mine in every way except the one that used to matter most to me.
I gave it up on purpose
This isn’t a complaint, and I’m not going back. I traded the model in my head for volume, and the volume is real. I ship more in a week than I used to ship in a month, and the game exists at all because of it. The replacement for the map I used to carry is the harness around the code. Thousands of tests, a skill that traces the impact of a change outward before I commit it, and a tight loop where the AI makes a small change and I review it before the next one. I don’t trace the cascade in my head anymore. I get the system to show it to me.
Here’s the whole shift in one place:
| The old way | Now | |
|---|---|---|
| Where the map lived | in my head | in the tests and the harness |
| Finding a bug | recall the file and the line | describe it, let the AI change it, read what the tests say |
| Making a fix | surgical, by hand | hand the whole change over |
| What I trust | my memory of the code | the cascade the system shows me |
That’s a worse feeling and a better outcome, and I’ve made my peace with it. Most days I don’t even notice. It only surfaces in a conversation like that one, with someone who remembers coding the old way too.
What I’d tell another developer
If you’re building this way too, three things I’ve landed on:
- The harness is the new mental model. Build the tests and checks before you lean on the AI, because that’s what you’ll trust instead of your memory.
- Stop hand-editing once you can’t see the cascade. That’s where the bugs come from. Describe the change and let the tool trace it.
- The skill that survives is review, not recall. You’re reading code you didn’t write, all day. Get good at that.
What actually got lost
Nothing measurable got worse. I’m faster, the code is fine, the tests catch what my head used to. What’s gone is harder to put on a chart. It’s a kind of closeness with the thing I’m building, and a specific pride that came from knowing it all the way down. Maybe that’s just nostalgia, the same way some people miss writing assembly. Or maybe every developer is slowly turning into a manager of code they don’t fully hold, and we haven’t worked out yet whether that’s a loss or just the job now.
I genuinely don’t know which it is.
I used to be able to find the bug with my eyes shut. Now I can’t.
I build Inselnova, a free browser strategy game, this way. Play here.
