When AI Makes You Fast… But Also Makes You Forget How Your Own Code Works

I had one of those weeks where you suddenly realise you’re not quite as on top of things as you thought. The kind of week where you think, “Oh yeah, this is why humans still have jobs.”

And the embarrassing part?
I got absolutely blindsided by code I wrote. (”wrote” might be generous.)

The Week I Took AI a Bit Too Literally

We recently updated our process, and without even noticing it, I had drifted into the habit of letting the AI handle more than it should. The output looked great: clean code, passing tests, tidy diffs. My brain basically shrugged and said, “Looks fine, let’s get on with the next thing.”

Spoiler: it wasn’t fine.

Everything behaved perfectly locally.
Then I deployed it to the cloud and walked straight into a wall of chaos.

Managed identity acting up.
Connectivity was doing as it pleased.
Authentication randomly failing.
All the usual cloud quirks that somehow hide until the moment you tell someone the work is finished.

Suddenly, I was hunting down “bugs” that weren’t actually bugs.
The real problem was that I had no mental map of what the system was supposed to do, because I hadn’t really built it the way you normally do through repetition, frustration, and slowly wiring the whole thing into your brain.

It genuinely felt like trying to debug a system I’d only heard rumours about.

When You Don’t Write It, You Don’t Know It

This was the big realisation of the week.
AI generated a lot of the heavy lifting. I skimmed it, thought it looked correct, and cracked on. But because I never really went through the grind of writing it myself, I didn’t have the usual intuition you rely on when debugging.

There were moments where I was staring at a piece of code thinking, “Did I do this… or did I hallucinate reviewing it at 5 pm on a Friday?”

I spent more time reconstructing how things worked than I would’ve spent writing the code manually. And that was a wake-up call.

AI can give you clean code, but it can’t give you the internalised understanding that makes debugging efficient. Without that, you’re basically wandering through your own system like a tourist with a blurry map.

AI Isn’t Magic. It’s a Power Tool.

This week forced me to re-ground myself.

AI absolutely helps productivity, but it doesn’t remove the need for the fundamentals. You still need to understand how the system fits together. You still need to think about the environment you’re deploying into. You still need to consider failure modes, configuration differences, and behaviour outside of happy-path tests.

Cloud issues don’t care how tidy your code looks; they care whether it’s built to behave correctly in a messy world.

A chainsaw is brilliant when used properly. It’s less brilliant when you’re half paying attention.

The Quiet Fear That Sneaks In

If I’m totally honest, I think part of why I leaned on the AI too much is because of that little voice developers have been hearing lately:

“This thing writes code way faster than I can… where does that leave me?”

But the moment you hit a real-world problem involving identity, connectivity, latency, environment differences, or system design, you’re reminded very quickly that raw code is only a small part of what engineering actually is.

AI can generate code.
Engineers design systems, spot subtle issues, understand how components behave together, and know where failures hide.

They aren’t remotely the same skill.

And that difference is exactly why we still matter.

The Reset Button

So I’ve taken a breath and reset this week.
Back to using AI as a tool, not an autopilot.

It’s there to support my thinking, not replace it.
It helps me move faster, but it doesn’t free me from needing to understand what I’m building.
It can generate solutions, but it can’t be accountable for them.

This reminded me that the real value in engineering isn’t typing speed.
It’s the thinking, the planning, the understanding, and the ability to navigate the unpredictable parts of the real world.

AI handles the easy stuff.
We handle the stuff that actually matters.

And honestly, that’s a comforting thought.