I Used to Write Code. Now I Just Watch AI Do It.

I'm one of those developers who wrote code before Copilot existed. Before prompts replaced logic. Just raw implementation, caffeine, and a blinking cursor.

And I'm glad I did.

I used to write code for work, in my free time, when I was stressed, when I was happy. In my dreams, I still write code. I did it because creating something, fixing issues, building systems: it was fun.

That feeling when you'd step back and think, "I'm a genius. I did that."

Back then, you weren't just assembling components. You were constructing mental models. Every function passed through layers of thought. You traced edge cases before they existed. You simulated failure before production ever had the chance to surprise you.

Every bug you fixed made you sharper.

You didn't just write code. You forged it.

We can still do that today. The difference is: we don't have to.

I remember building a complex component I was truly proud of. I called my friend past 2 a.m. Not because anyone asked. Not because it was urgent. But because I had built something difficult, and I needed someone to witness it.

That kind of excitement is hard to fake.

The AI Acceleration Paradox

Fast forward to today.

In the last few months, I've produced more code than I used to produce in an entire year. The output metrics look incredible. AI code generation tools show productivity through the roof. Studies on AI developer productivity would love me.

But something feels off.

It doesn't feel like I built it. It feels like the junior developer built it.

Yes, I review it. Yes, I refine it. Yes, I understand it.

But it didn't originate from that deep cognitive grind.

It feels like someone defeated the final boss for you. You get the credits, but you didn't play the game.

And that's the paradox: when creation becomes effortless, accomplishment starts to feel weightless.

The Death of Flow

There's another side effect no one talks about.

Flow state used to come naturally when writing complex systems. You'd get lost for hours, structuring logic, debugging edge cases, refining abstractions.

Now? You describe what you want. You wait. You get distracted.

The AI finishes the job while you're checking messages or scrolling, and you hit accept, accept, accept.

When you typed code, your brain and hands were synchronised. The struggle encoded the system into you.

Generative AI removes friction, but friction was the encoding mechanism.

Typing Used to Be Joyful

This one surprised me.

Typing used to be satisfying. Mechanical keyboards, rapid thoughts turning into structured syntax, the physical rhythm of thinking through your hands.

Now it's easier to dictate requirements. Easier to describe instead of construct.

But describing isn't the same as building. And building is where the joy lived.

The Ownership Gap in Production

Here's where it gets serious.

A few weeks ago, something broke in production due to recent changes.

The old me would have known exactly where to look. Exactly how to fix it.

This time, I had to re-read my own system like a stranger.

That realisation hit harder than the bug itself.

When code you wrote yourself fails in production, your brain already has a map. You can navigate quickly. You debug with intuition.

You could almost feel it: "File XYZ, line 32. That's where it's failing."

Because the entire codebase had passed through your brain, not just your eyes. You had simulated it. You had wrestled with it. You had lived inside it.

Now when something breaks? You go back and read it line by line. Not because you're incapable, but because you didn't internalise it the same way. You reviewed it, but you didn't forge it.

There's a cognitive difference between writing code, reviewing code, and understanding code.

We're slowly shifting from the first to the third. And that shift changes how deeply knowledge embeds itself.

The Game Has Changed

I'm not anti-AI. I've witnessed the rise of code. I've had the privilege of writing it by hand in its rawest form, and I'm glad I did. And I also see where things are heading.

AI coding tools aren't going away. Models like GPT-5.3-Codex and Claude Opus 4.6 will get better. Faster. More autonomous. The impact of AI on developer productivity is undeniable.

Maybe our role isn't to type faster anymore. Maybe it's to architect better, ask sharper questions, design deeper systems, understand trade-offs more clearly, and own decisions rather than lines of code.

The craftsmanship is evolving. But we have to be intentional.

Because if we fully surrender the act of building, we might accidentally surrender the joy of building too.

So What Do I Think?

This moment feels uncomfortable because we're in a transition era.

The developers who wrote everything by hand feel the shift most intensely. We remember what it felt like when the friction was part of the reward.

Sometimes I catch myself sounding like a grandpa already, talking about "the good old days" of writing code till 2 a.m.

The new generation might never experience that same kind of satisfaction, but they'll probably experience a different one.

The challenge for us OGs isn't to resist AI. It's to figure out how to use it without losing ourselves in the process.

Maybe the solution is simple: sometimes turn it off. Sometimes write the complex thing yourself. Sometimes struggle on purpose.

Because struggle isn't inefficiency. Sometimes, it's meaning.

And yes, for the sake of full transparency: I wrote this article with the help of AI. I dictated most of it instead of typing.

Writing used to be fun too.