I've had this argument three times this month. Once with a client who wanted to skip hiring a junior dev because "Claude can just do it," once with a friend who's convinced his job is gone by 2027, and once with myself at 2am, staring at a pull request full of AI-generated code that looked perfect and was quietly broken in a way I almost missed.
So let's actually talk about it. Not the hot-take version. The real one.
The claim everyone's making right now
dev.to blew up this week over a post arguing AI is already better at coding than most software developers. It pulled 190+ reactions and 150+ comments in a few days, which on that platform is basically a riot. The core argument: coding was never the valuable part of the job anyway, so once AI writes the code faster and cleaner than you, what's left to defend?
It's a good hook. It's also only half true, and the half it leaves out is the half that actually matters if you're trying to ship real software.
Where AI genuinely wins, no argument
I'm not going to pretend AI coding tools aren't good, because they are, and anyone who tells you otherwise hasn't used them seriously.
AI is fast and reliable at:
- Boilerplate, CRUD scaffolding, config files
- Routine unit tests and documentation
- Recalling messy API signatures you'd otherwise be tabbing over to check
- Translating logic between languages you already understand
- First drafts of anything with a well-known shape
If the task is narrow and the output is easy to check, AI pulls its weight every time. I use it daily for exactly this in client work — nobody needs me hand-typing a WooCommerce hook signature from memory when a model can spit it out in two seconds.
That's real. That's not hype.
Where it falls apart, and this is the part nobody screenshots
Here's where it gets uncomfortable, because the numbers aren't flattering.
A 2025 METR study had experienced developers use frontier AI tools on real tasks. They took 19% longer to finish — while feeling 20% faster the whole time. That gap between what people feel and what actually happened is the whole story in one sentence.
It gets worse. AI-generated code is about 1.7x more likely to introduce bugs than human-written code, and nearly 2.7x more likely to introduce XSS vulnerabilities specifically. And the bugs it introduces aren't the obvious kind. They're not syntax errors that scream at you in red. They're the quiet kind — an off-by-one, a missed edge case, a race condition that only shows up under load three weeks after deploy. Code that looks completely fine and runs completely fine, until it doesn't.
Only 3.1% of developers actually trust AI output without checking it. And 45.2% say debugging AI-generated code takes more time than just writing it themselves would have. If you've ever spent forty minutes untangling a "working" function you didn't write, you already know this in your bones.
There's a name for what happens next: comprehension debt. You review code long after you've stopped being able to write it from scratch, and at some point review quietly turns into rubber-stamping. One engineer described merging a feature Claude wrote, nodding along as he skimmed it, and three days later realizing he couldn't explain how it actually worked. That's not a productivity win. That's a liability with a delay timer on it.
A January 2026 study measured this directly — developers who passively accepted AI-generated code scored 50% on comprehension tests. Developers who'd written the code by hand scored 67%. That 17-point gap is what you're trading away every time you skip the "wrestle with the problem yourself first" step.
So is AI actually better than "most developers"?
Depends entirely on what you think the job is.
If the job is typing syntax fast, sure, AI wins, it's not close, and it never was going to be close.
But that was never the job. IDC data puts the actual code-writing part of a developer's day at around 16% of their time. The other 84% is requirements that don't quite make sense yet, trade-offs nobody's written down, architecture decisions that'll matter in eighteen months, and knowing which corners are safe to cut under a deadline and which ones aren't.
AI doesn't know your business. It doesn't know that the client changed their mind about the checkout flow twice last quarter, or that the "quick fix" you're being asked for is going to conflict with a caching layer that isn't documented anywhere except in your head. It generates confident code. Confidence and correctness are not the same thing, and AI has never once been able to tell the difference between them.
What this actually means for you
Not "learn to code less." The opposite, honestly, just aimed differently.
- Read code like it's your job, because it is. The ability to look at AI output and immediately spot what's subtly wrong is the actual skill now.
- Write some of it yourself, on purpose. Not out of stubbornness — because typing it out is still how understanding gets built. Skip that step enough times and you lose the ability to catch the model's mistakes.
- Use it to check your thinking, not replace it. Ask it to poke holes in your own solution before you ask it to hand you one.
- Treat "it runs" as the starting line, not the finish. Especially on anything touching auth, payments, or user data — the exact places where that 2.7x XSS number stops being an abstraction.
I'm not anti-AI. I use it every day, in almost every project I ship. But the developers who are going to be fine aren't the ones who can prompt the fastest. They're the ones who can tell, in the ten seconds after the code generates, whether it's actually right — and who still remember how to write it themselves when the answer is no.
AI didn't get better than developers. It got better than developers who stopped paying attention. Those aren't the same thing, even though right now, from a distance, they look identical.
Top comments (0)