I've been writing code for about five years professionally. If you count the years where I was just Googling "why is my div not centering" at 2am, it goes back to 2017. I started my first real job in 2020. And for most of that time, it was just me and the editor. No autocomplete magic, no chat window, no "here's your entire feature, boss." Just me, the docs, and a lot of console.log.
Then AI happened to me. Slowly, then all at once.
This is the story of how I got faster than I've ever been in my life, and somehow started feeling like a stranger to my own code.
The Copilot warning I ignored
My first taste was GitHub Copilot. And look, it was cool. It finished my thoughts before I finished them. It felt like pair programming with someone who never took a lunch break.
But something weird started happening. I noticed I was forgetting syntax I used to know cold. Small stuff. The exact shape of an array method. How to write a reduce without staring at it. I'd start typing, wait for the gray text, and just... tab.
Wait, am I getting dumber?
I was. Not really dumber, but my muscle memory was quietly rotting. The stuff I built over years was fading because I stopped using it. So I did something that felt insane at the time: I turned it off. Went back to raw typing. Felt slow. Felt good.
I thought that was the whole lesson. Turns out it was just the trailer.
The job that made AI non-negotiable
This year I landed a full-time role as a full stack dev building internal AI tools. And here's the twist: using Claude Code wasn't optional. It was the job.
So for the first time, I wrote an entire feature with AI. Spec to feature to production. And I'm not gonna lie to you, it blew my mind. The speed was unreal. Stuff that used to take me a month was landing in days.
I was hesitant at first. This feels like cheating. But it works, and it ships, and when something ships that fast, guess what happens next?
The expectations move to match the speed.
Suddenly it's two features a week. Two. Features. A week. The kind of pace that, doing it by hand, would've been a month minimum. And the only way to hit that number is to lean all the way in. So I did.
Reader, I leaned so far in I fell over.
The fog
Weeks passed. Then more weeks. And one day I realized I couldn't remember what I wrote.
Not "I forgot a detail." I mean I couldn't remember the parts. The spec of the tools I built. How they fit together. I'd open a PR with my name on it and read it like a tourist. I was writing prompt after prompt after prompt, shipping the whole time, but not really understanding any of it.
It felt like floating. Like the work was happening next to me instead of through me.
And it hit me how different this was from before. Back in 2020 to 2025, when everything was manual, I knew every single line. The code felt like mine. Now? I felt detached from the thing I supposedly built.
So I stopped. I said, okay, I need to figure out what's actually happening to me here.
And yeah, I know how this sounds, but I consulted the AI about my AI problem. Fight fire with fire, I guess.
What we actually figured out
Here's the part that reorganized my brain.
My first instinct was to blame the typing. Like the value of the old way was the physical act of writing the code. Muscle memory, keystrokes, all that.
But that wasn't it.
The real thing manual coding did was force a prediction out of me on every single line. Before I ran anything, I had already guessed what it would do. I had to. That constant loop of "I expect this to return X" and then watching to see if X actually happened, that's what quietly built the model in my head. The typing was never the point. The typing was just the delivery mechanism for the guess.
And AI removes the guess.
It hands you working code before you've formed a single expectation about it. So the prediction step goes from mandatory to optional. And here's the brutal part: anything optional gets skipped under a deadline. Especially a two-features-a-week deadline.
So you ship correct code without ever having predicted what it would do. Which means the understanding never gets built. Which is the fog.
It's not that I got lazy. It's that the one moment that used to compile understanding into my head got quietly deleted from the loop, and nobody sent a memo.
Why it feels like detachment specifically
Because my understanding stopped living in my head and moved into the AI and my notes.
That's why I kept asking things like "wait, what did we do yesterday?" and "is this one done?" and "is it logged?" I was reconstructing my own work from session summaries like I was investigating a stranger.
Here's the distinction that stuck with me: understanding-on-demand is not the same as retained understanding. I could retrieve it. I couldn't hold it. And holding it is the whole reason work feels like yours instead of something you supervised.
You don't own what you can only look up.
The fix (I'm not going back to manual, relax)
I want to be clear, the answer is not "delete Claude and suffer." That's cope. The speed is real and I'm not giving it up.
The answer is to put the prediction back in on purpose, since it's not forced anymore.
So now, before I read the AI's answer, I guess what it's going to say. Before I accept a diff, I state what I expect it to change and why. Out loud, in my head, in a comment, doesn't matter.
- When I'm right, that's a rep. The model in my head gets stronger.
- When I'm wrong, that's the exact spot the fog would have formed, and now it doesn't.
It's slower. Obviously. Which is exactly why a deadline murders it. So I don't do it on everything. I'm not predicting the outcome of "change this button to pink." I do it on the work that actually matters, the stuff I need to own six months from now.
That's the trade. A little friction on purpose, in exchange for staying the author of my own work.
The one-liner I'm leaving with
AI didn't make me a worse developer. It made the moment where I become a better one optional.
The fog isn't the price of using AI. It's the price of using it without guessing first.
So now I guess first. Every time that counts.
And if you felt seen by any of this, that's your sign to go predict your next diff before you tab.
Top comments (0)