When I started using AI tools daily, the speed was real. I was shipping faster, finishing tasks that used to take an afternoon in an hour. I felt amazing, but also… wrong.
Then I looked more carefully at what I was actually producing.
The Good Part Is Real
I want to be honest about this part, because the rest of this article will not make sense without it.
AI genuinely changed the pace of my work. Scaffolding a new feature used to take time — now it takes minutes. Boilerplate code is mostly gone, and when I hit an error, I get an explanation immediately instead of spending twenty minutes reading documentation I half-understand.
The speed is not hype. If you use these tools every day, you feel it.
And that is exactly where the problem starts.
How I Actually Used to Work
Before AI, I was a "paint on canvas" developer. I didn't fully plan features before writing them. I liked to throw something quick and dirty at the wall to get a base layer down, something that roughly worked, and let the shape of the feature emerge as I went. Messy, hacked together, but complete. Once the whole thing was working end to end, I'd step back.
Now I had full context and I could see exactly how the feature fit into the app, what was redundant, what needed cleaning up. That's when I'd refactor.
That allowed me to be fast, because I wasn’t overthinking the feature: get it working first, then refactor it all. Simple.
The messy first pass wasn't a problem to fix, it was the method. Explore fast, understand fully, then clean. That two-stage process was doing most of the real work, and I didn't even realize it until AI quietly erased half of it.
Then AI Broke the Loop
Here's what I didn't expect: AI didn't improve that process. It disrupted the part that made it work.
The first stage, fast and dirty exploration, got even faster with AI, and that part felt great. But the second stage quietly disappeared, and the reason is sneakier than you'd think. AI-generated code looks clean. It's formatted, it's structured, it doesn't scream "this needs another pass."
So I stopped doing the refactor… not consciously, there was no moment where I decided to skip it. The code just looked finished, so my brain treated it as finished.
The problem is that looking clean and being well-thought-through are not the same thing. The messy draft is supposed to be a phase. AI turned it into the final product.
The Prompt Loop Trap
Here is a scenario most developers will recognize.
You have a problem. You write a prompt. The output is almost right, but not quite, so you prompt again with a small correction. Still off. You try a different angle, add more context, rephrase. Fifteen minutes later, you are still working on a problem you could have solved in two minutes if you had just opened the file and fixed it yourself.
At some point, you are no longer solving the problem, you are negotiating with the model. This happens because prompting feels like progress. Every response is something, you are moving. But sometimes the fastest path is to stop prompting, close the chat, and just think.
AI was faster, until I used it to avoid thinking and became lazy. Then it was just slower in disguise.
The Hidden Cost: Thinking Less
This is the part that is hard to see while it is happening.
I started reviewing AI output the same way I skim a news article: looking for obvious problems, checking that it roughly matched what I asked for, then moving on. What I stopped doing was asking harder questions. Not "does it work?" but "is this actually right?"
The code was not obviously bad. It worked, tests passed. But "works right now" is not the same as “clean and maintainable”. I was accepting outputs I would have pushed back on before, because the output was good enough and moving on was easy. Standards do not drop all at once, they slip one small acceptance at a time.
AI Didn't Skip Steps. I Did.
The development process has not changed. You still need to understand the problem before you build, think about the architecture before you write code, refactor the output into clean and maintainable code, and review it all carefully before you ship.
AI does not skip those steps, it only does what you ask, making it way too easy to get complacent. No friction, no obvious cost. The cost shows up later, when something breaks in a way you do not understand, or when you have to modify code you never actually knew.
The Fix Is Not a Tool
When I recognized what was happening, my first instinct was to find a better workflow: a smarter way to prompt, a tool that would catch what I was missing. That was the wrong instinct.
The problem was not the tool. The problem was that I had let the tool collapse a two-stage process into one, without noticing. The fix had to happen at the same level. Not a new tool, but a clearer mental model for how to work.
A few things that actually helped:
I kept the two stages explicit. Fast and dirty with AI is still fine, but I now treat that output the same way I used to treat my own messy first pass. It's a base layer, not a finished product.
I still do the refactor pass. Once the feature is working end to end, I step back and ask: now that I can see the whole thing, what would I actually do differently? That question used to come naturally. Now I have to be deliberate about it. I’ll tell Claude or Codex exactly how I want things to be refactored until I’m satisfied.
When I find myself reprompting the same thing more than twice, I stop. That is a signal that I need to think, not prompt. Sometimes, clearing the context and starting fresh also helps.
When I already know the answer, I just write the code. Not everything needs AI. Knowing when not to reach for the tool is as important as knowing how to use it.
The Real Skill
The developers I see getting the most out of AI are not the ones with the best prompts: they are the ones who know what their process actually is and protect the parts that matter.
For me, the first pass was never where the real work happened. The value was in the second pass, when I had full context and could see clearly. AI made me think I could skip it, but really, I couldn't.
Tools will change and the specific model you use today will look different in a year, but knowing which stages of your process are doing the real work, and refusing to let a tool quietly erase them, that is the skill that does not get replaced. It gets more important.
AI made me faster. It also made me worse, for a while. The difference between those two outcomes was not the tool. It was whether I still did the second pass.
