I’m one of those developers who’s had the privilege of writing code by hand in its rawest form, the kind who wrote every line by hand. No copilots. No prompts. Just raw logic, 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 of fulfillment when you’d step back, look at what you built, 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 and 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 one time I've built a complex component I was truly proud of. I called my friend and said:
“You have to see this... Yeah, I know it's 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.
(And no, vibe coders, I’m not exaggerating.)
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. Productivity charts would love me.
But something feels… off.
It doesn’t feel like I built it.
It feels like the “9k Jr. 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 and rescued the princess 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 social media, and you hit accept, accept, accept.
When you typed code, your brain and hands were synchronized. The struggle encoded the system into you.
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 (I have a couple of them), 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 9k 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 realization 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 internalize it the same way. You reviewed it, but you didn’t forge it.
There’s a cognitive difference between:
- Writing code
- Reviewing code
- Understanding code
We’re slowly shifting from the first to the third.
And that shift changes how deeply knowledge embeds itself.
I’m Not Complaining — I’m Observing
I’m not anti-AI. (Ironically, my initials are A.I.)
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 is not going away. It will get better. Faster. More autonomous.
But the Game Has Changed
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.
- 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?
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.
Top comments (2)
The "ownership gap in production" section is the most honest thing I've read this week.
I had the exact same realization a few months ago. Built a finance planning tool — deliberately chose zero backend, zero AI, everything runs in IndexedDB inside the browser. Not because it's the trendy architecture, but because I wanted to know every path the data takes.
When something breaks at 2 AM, there's a specific peace in knowing "it's in the sync module, around the merge logic" without even opening the file. That mental map only exists because your hands typed every line.
What hit me about your "flow state" point: I noticed the encoding isn't just cognitive — it's physical. The muscle memory of typing out a complex reduce chain actually helps you remember the data shape weeks later. When AI writes it, you review the logic but the physical encoding never happens.
Curious about something practical: have you found any middle ground? I've been experimenting with using AI for tests only — I still hand-write the implementation, but let AI generate edge case tests. The implementation stays "mine" for debugging, but the test coverage goes wider than I'd manage alone. Still feels a bit like cheating though.
"When creation becomes effortless, accomplishment starts to feel weightless" — that line deserves a poster.
The friction-as-encoding-mechanism framing nails something I could not articulate. Removing the struggle also removed the muscle memory that made debugging intuitive.