When I started this blog, I promised myself I’d write here regularly. I even said so in my first post, in public, where everyone could see it. You can probably guess how that went.
That was a while ago, and I haven’t published a single thing since. The easy explanation is that I got busy and lost the motivation. That’s true, but it’s not the whole truth. The honest version is that the thing I wanted to write about is the same thing that made it hard to write at all. So let me finally try.
I’ve been writing code since 2006, first as a hobby and then for a living since 2016. The hobby years matter, because by the time it became my job I already had a running start. I went from junior to mid in about a year.
But the part I actually miss is the junior part. Back then, every day taught me something that rearranged how I saw the whole craft. I would write code line by line. While I was typing one line I was already thinking about the next, and then I would scroll back up and rewrite something from ten minutes ago because I suddenly saw a cleaner way. Write, look back, improve. That loop had been second nature for years. And when I shipped something, I would look at it and think: I made this. That feeling was the whole reason I did the job.
Then AI showed up, and it crept in so gradually that I never noticed the line I crossed.
First it was just a better search. Instead of digging through three pages of Google or a Stack Overflow thread from 2014, I would paste a broken function and ask where the bug was. Faster. Obviously better. No regrets. Then I went a step further and started pasting working code and asking for a better version, more readable, more performant. That was great too. Then the assistants got good. They climbed out of the browser tab and became agents running in my terminal, on my machine, touching my files. And somewhere in there I lost the thread without realizing it.
Today I don’t really write code. I have it written. I describe what I want, and it appears.
For a while I thought this just made me faster. It took me longer to admit what it actually changed: I’m not the author anymore. I’m the approver.
If I’m honest about the split, it’s something like 70-30. 70% of the time, I read what the model produced, it looks right, the thing runs, and I approve it. The other 30%, I actually push back and steer. And here’s the uncomfortable part: approving is not the same as evaluating. Most of the time, approving is just trusting.
People will tell you that prompt engineering is the new craft, that knowing how to describe what you want is a skill of its own. Maybe. But a good prompt only makes the request mine. Knowing what to ask for isn’t the same as understanding what comes back, and understanding what comes back used to be the part of the job that needed me.
And these days, that part is often beyond me anyway. The model regularly writes code I couldn’t have written myself, not just faster but genuinely better. Every now and then it solves something in a way that stops me cold: I would never have thought of that.
Here’s what that does. If I had built the same product by hand, it would probably look identical from the outside, and a normal person would be just as impressed either way. But the foundation underneath, the actual code, would have been maybe a 6/10. Functional, gets the job done, skips half the edge cases. What ships now is closer to a 10/10, as long as the model knows the spec. Someone who doesn’t write code can’t see that difference. Another developer can. They open the code and read, right there on the page, that what’s in front of them is better than what I could produce alone. It’s a bit like putting your name on a book a ghostwriter wrote: the cover says you, but anyone who can read the prose knows you didn’t write it. That’s why this feels different depending on who’s looking. And it’s why I hesitate to open-source some of the things I’m supposed to be proud of.
The second thing is worse, because it doesn’t need an audience. It happens when no one is looking. I’ve started to feel like a stranger in my own code. I will come back to something weeks later to add a feature or change a behavior, and I don’t know where anything is or why it’s shaped the way it is. The worst version is when a teammate runs git blame, lands on my name, and asks why we did it this way here, and I have nothing. I can’t defend a decision that, on paper, was mine. That’s a specific kind of embarrassment, and it’s new.
I want to be careful here, because it would be easy, and a little dishonest, to pin all of this on AI.
Some of it was coming anyway. The pure joy I keep describing belonged to my early years, and a lot of it was the joy of learning, not the joy of coding. When you’re new, almost everything you touch opens a door, and that constant leveling up feels incredible. It naturally slows down; the wow-moments get rarer the longer you do anything. Even without AI, I would be feeling some of this, the quiet flattening that comes with no longer being a beginner. So it’s really two things at once. The beginner’s excitement was already fading on its own, the way it does for everyone, and the thing that’s supposed to replace it, the deeper satisfaction of being good at the craft, of building something clean and understanding every part of it, is exactly what AI has taken from me. I’m left in between, holding neither.
And it isn’t just me. You can watch the same thing happen to the team. Code review used to work because a human wrote the code and another human could read it; both sides fit inside a human attention span. That balance is gone. AI produces more code, across a wider scope, than any of us can realistically read, so pull requests have lost their weight. We skim where we used to study. And more and more, the reviews themselves are done by AI.
That’s a strange place to have arrived. The loop is closing and there’s no human left inside it: code written by a model, reviewed by a model, merged by a person who mostly trusts that the two of them sorted it out. This, I think, is the real shape of the fear people keep waving around, developers being pushed out of the process. It doesn’t look like getting fired. It looks like keeping the job while quietly being moved outside the part where you actually understood what was going on.
I don’t have a clean ending for this, and I’m suspicious of anyone who does. Maybe what I really miss isn’t writing code itself. It’s a particular relationship with it, the one where I was the author. And I’m not sure that word means what it used to.
You might be wondering whether AI wrote this too. The truth is messier than yes or no. I dumped my unfiltered thoughts, and then I shaped them into this with AI, the same way I now shape code. So I didn’t really write this confession either. I approved it.
But the raw feeling underneath was mine. The discomfort that made me open the editor in the first place, no model handed me that. That part, I did alone. Maybe that’s where the line is being redrawn for all of us: authorship isn’t about who types anymore, but about who notices when something’s wrong.