A few days ago, I was working on a fairly complicated feature: web sockets, AI live sessions, and user media interaction in the browser. I had been at it for about two weeks.
At the start, I created a comprehensive plan with Claude Code. It looked solid. Implementing the plan took about an hour, fixing the initial bugs took another hour, and then I tested it. The feature was ostensibly working, so I moved on. The wrong decision I made: I never actually read the code.
Over the following days, I kept layering more features on top of that foundation without reviewing a single line. Things looked like magic. Until they didn’t.
When Everything Dropped at Once
At a specific point in the implementation, everything stopped working. I tried solving it with AI. It got worse. I spent three days in that loop before accepting that no amount of prompting was going to find whatever was buried in there.
Something was deeply wrong, and I had no idea where, because I had never actually understood the code I was building on.
8 Hours of Reading My Own Codebase
I stepped back and started walking through the flow from the beginning, following the request lifecycle and each socket event manually. No AI. Just me and the code.
It took about 8 hours. Almost every line needed refactoring. I deleted a significant amount of logic: some of it I didn’t understand, some of it looked completely useless. I wasn’t sure which category some pieces fell into, but if I couldn’t reason about why something existed, I removed it.
Then I ran the code.
Everything worked perfectly.
I never found the original bug. I just deleted it. It was hiding somewhere inside code I hadn’t written, hadn’t read, and didn’t understand, and the fix was making the codebase small enough that I could finally hold it in my head.
What I Actually Learned
AI got me moving fast. That part is real. But it also handed me a codebase I had no mental model of, and when something broke deep inside it, I had no way to reason about the problem. The tool that saved me an hour upfront cost me three days later.
The failure wasn’t using AI. The failure was skipping the step where I actually understand what I’m building.
Treating generated code as a draft to read and revise isn’t slower than trusting it blindly. It’s the opposite. Because the hour you spend reading is the insurance policy against the three days you’d spend debugging something you never understood in the first place.
Leave a Reply