A slightly embarrassing thing happened yesterday.

One of our backend engineers pinged me late at night and pointed out a bug that needed a frontend fix. The code was probably written around two weeks ago. Back then, to speed things up, I let an AI agent handle most of the implementation. Human intelligence only did a quick review, a few basic tests, and then we shipped it.

Turns out, I had quietly accumulated a mountain of technical debt.

The strange part was this: when I opened the repository again, even though only two weeks had passed, I suddenly felt completely lost.

I could no longer understand the code I wrote two weeks ago.

Or more precisely: I couldn't immediately locate where the actual business logic lived anymore.

Sure, you could blame normal human memory decay. But honestly, that feels like cheating a little. AI agents probably contribute to this phenomenon quite a lot.

Fortunately, VS Code full-text search still works better than human memory. I searched a few keywords, found the relevant code, patched things up, and thankfully nothing exploded.

A while ago, I saw a meme online describing different stages of programmers in the age of Vibe Coding.

At first, we wrote code manually like traditional craftsmen.

Then came GitHub Copilot, where autocomplete suddenly felt magical.

Then came Cursor and AI agents generating entire chunks of business logic while developers mostly controlled the architecture and tech stack.

And finally, the ultimate evolution:

People abandoning IDEs entirely and becoming full-time vibe coders — communicating only through natural language prompts while praying the generated spaghetti somehow keeps running.

Honestly, I think I'm somewhere between the “reformist” and “semi-reformist” camps.

Completely rejecting AI coding tools feels unrealistic now. The productivity gains are simply too large.

But fully abandoning IDEs and giving up control over the codebase also feels dangerous.

And pure Vibe Coding — where people skip learning fundamentals entirely and rely on AI to generate giant piles of “works-on-my-machine” code — is probably the path we should avoid the most.

AI agents are incredibly powerful, and they're improving at terrifying speed.

But I don't believe human engineers can simply be removed from the loop.

We also can't fully surrender our understanding of the codebase itself.

Otherwise, eventually the thing buried beneath the AI-generated spaghetti won't be the code.

It will be the engineers.

A friend summarized it perfectly:

“I've realized using my integrated biological brain doesn't consume tokens, and it introduces fewer bugs.”