I'm going to say something that might get me downvoted. AI coding assistants are making developers worse. Not all of them. Not always. But the trend is real, and I think we're not talking about it enough because the productivity numbers look too good to question.
I've been using Copilot, Cursor, and Claude Code for two years. I ship more code than I used to. My PRs are bigger. My features land faster. By every metric that my manager cares about, I'm more productive.
But here's what I noticed last month. I was debugging a race condition in a Python service. It was a tricky one. Shared state across async tasks, a missing lock, the kind of bug that takes an hour to find and five minutes to fix. I stared at the code for ten minutes. Then I opened Cursor and asked it to find the bug.
It found it in three seconds. I fixed it. Shipped it. Moved on.
And then I sat there thinking: would I have found it myself? Maybe. Probably. But I didn't even try. I reached for the AI before I reached for my own brain. That's the habit I'm worried about.
The skill you don't notice losing
Debugging is the most important skill a developer has. Not writing code. Not knowing frameworks. Debugging. The ability to look at broken code, hold the mental model in your head, trace the flow, and find the disconnect between what you expected and what's happening.
That skill is built by doing it. By staring at code for an hour. By being wrong ten times before being right once. By developing the intuition that says "this feels like a concurrency issue" before you can prove it.
AI tools shortcut that process. They're better at debugging than most of us. Faster, more thorough, less tired. So we let them do it. And every time we do, we skip a rep. We skip the struggle that builds the skill.
The result is a generation of developers who can ship features but can't debug their own code when the AI isn't available. I've seen it in interviews. Candidates who can generate a React component in seconds but can't explain why their state update isn't triggering a re-render. They're not dumb. They're just out of practice at the hard part.
The illusion of productivity
Here's the uncomfortable truth about AI productivity metrics. They measure output, not understanding. Lines of code, features shipped, PRs merged. All output. None of them measure whether the developer understands what they shipped.
I shipped a feature last week that I didn't fully understand. The AI wrote most of it. I reviewed it. It looked right. Tests passed. I merged it. Three days later, a user reported a bug. The code was correct in isolation but wrong in context. The AI didn't know about a downstream consumer that depended on a specific side effect. I didn't either, because I didn't write the code. I just approved it.
If I had written it myself, I would have known. Not because I'm smarter than the AI. Because the act of writing forces you to think about the context. The AI skips that step. It generates code that's locally correct but globally naive.
The counterargument I keep hearing
"But I still review the code." Sure. But reviewing AI-generated code is different from reviewing human-generated code. When you review a human's code, you're checking their reasoning. When you review AI code, you're checking its output. You're looking for bugs, not understanding the design. And the design is where the bugs live.
"But I'm learning faster because the AI shows me patterns." Maybe. But learning a pattern by having it handed to you is different from learning it by struggling to implement it. The first gives you recognition. The second gives you understanding. Recognition is useful. Understanding is what makes you a good developer.
"But the AI is just a tool, like autocomplete." Autocomplete suggests the next word. AI assistants suggest entire architectures. The scale is different. The cognitive offload is different. When you let autocomplete finish a line, you're still thinking. When you let AI write a function, you've delegated the thinking.
Where I draw the line
I'm not saying stop using AI tools. I still use them every day. They're genuinely useful for boilerplate, for exploring unfamiliar codebases, for generating test cases, for the mechanical parts of development that don't teach you anything.
But I've started drawing a line. When I'm working on something I don't understand, I don't use AI. I struggle first. I read the docs. I trace the code. I sit with the confusion until it resolves. Then, once I understand the problem, I might use AI to help with the implementation.
The rule is simple: understand before you delegate. If you can't explain what the code does and why, you shouldn't be merging it.
The question I can't answer
Here's what keeps me up at night. If AI tools keep getting better, and developers keep relying on them more, what happens to the next generation? The developers who grew up with Copilot and never had to struggle through a debugging session? Will they be worse than us? Or will the tools have advanced enough that it doesn't matter?
I genuinely don't know. Maybe the tools will be so good that debugging becomes a solved problem. Maybe the skill of reading and understanding code will matter more than the skill of writing it. Maybe I'm the old man yelling at cloud.
But I know this: the developers I respect most are the ones who can sit with broken code and figure it out. Not because they're fast. Because they're patient. Because they've done it a thousand times. Because they've earned the intuition.
I'm worried we're trading that for speed. And I'm not sure the trade is worth it.
What do you think? Am I wrong? Have AI tools made you a better developer, or just a faster one? I want to hear from people on both sides. Especially if you disagree. Especially if you think I'm being dramatic.
Drop a comment. I'll read every single one.
Top comments (0)