I see a small epidemic spreading through software teams. Developers hired for their technical judgement and understanding of code are submitting AI-generated work they cannot explain.
In six words, “software developers are becoming vibe coders” :)
A vibe coder tells AI what they want and judges the result mainly by whether it works. There is nothing wrong with that; we are in a new age, and to be honest, much of what I do is vibe coding.
But a software developer is hired for more than working code. They are hired to understand it and apply that understanding. They should know why an approach works, where it might fail, and whether it belongs in the system.
And oh boy, I fancy software developers... In a world where everyone can generate code, and fewer people now bother to learn how it works. The developers who already understand the code are at a great advantage. But that advantage only exists if you use it; otherwise, you are either a bad developer or a vibe coder carrying a developer’s job title.
And to be honest, I think it is better to be an excellent vibe coder than a bad developer. But it also means you now belong in the same bracket as some random dude with a punk hairstyle and Lovable. He can also generate code he does not understand. The only difference is that he is not fooling himself into believing he is a developer.
Now, if you’re a developer, you’ll read this in one of two moods: pissed off because you caught your sub, or smiling because I am clearly talking about somebody you know. Or both. We’ll see about that.
There are three types of software developers when it comes to AI.
Bad developers
Good developers
Olden-day developers
The first is the bad developer - the ones AI makes worse.
They use AI like life support. They get a task they do not fully understand, paste it into Claude, accept whatever comes back, and push the pull request with the aura of Thanos after collecting the sixth infinity stone.
The tests pass, and the PR description confidently mentions “webhook signature verification and idempotency”. Then… one I-too-know product manager asks, “What happens if the provider delivers the same webhook twice?”
And the developer runs back to Claude to ask what idempotency means. That’s a bad developer.
The second is the good developer - the ones AI is making better.
They use AI the way Iron Man uses his suit. AI provides the speed and strength, but the developer still provides the direction. They challenge the plan, question the implementation, understand the failure points, and treat a PR as a responsibility rather than a task.
Both developers use AI. And this is not a debate about whether they should. Almost every developer already does. Which now brings us to the third category:
The “Olden-day developers” - the ones who don’t use AI.
They are the remaining monks protecting the sacred art of hand-written syntax. I personally don’t see anything glorious about it, and I believe they will eventually catch up.
To sum up my long introduction, the real difference is that:
- A bad developer uses AI to escape thinking, so AI makes them worse.
- A good developer uses AI to think further, so AI makes them better.
- Olden-day developers don’t use AI, and that’s more of a disadvantage.
Keep going in any direction and one group will eventually become useless. The other will eventually be forced to catch up. And the third will become the beast directing the most powerful coding machine we have ever had.
Now, let’s look at how these happen.
First, how does AI make bad developers worse?
1. It helps them avoid learning
Before AI, a weak developer would eventually jam what’s bigger than them. They would get an error and spend four hours moving around Stack Overflow like a confused tourist. Along the way, they would see different approaches, read arguments between strangers with anime profile pictures, and discover concepts they did not know enough to search for at the start.
It was inefficient, but the struggle meant you’d learn ten more things while looking for the solution to one.
AI has collapsed that learning approach. You can paste an error into Claude and get a working solution in two minutes. If the code runs, you can move on without understanding why the error happened or what the solution changed.
Do this for five years, and you may complete hundreds of tasks while learning very little from them. Your CV says “five years of experience”, but you have only learnt how to write better prompts.
We don’t have to return to suffering. Nobody needs to spend six hours debugging a missing comma to prove they deserve to be a good developer. But the two-minute answer should still add something to your brain.
2. It helps bad judgment move faster
A weak developer used to produce mediocre code at human speed. AI can now help the same developer generate entire features, tests, migrations, and unnecessary abstractions in an afternoon.
The volume of their output increases. Their ability to judge it does not.
This is difficult to notice because AI-generated code often looks extremely responsible. AI is excellent at producing a plausible implementation of the problem you described. But it cannot automatically know every business rule you forgot to mention or the strange promise somebody made to the CEO on the PRD review call.
A developer without strong fundamentals sees complete-looking code and assumes the thinking is complete too.
Sometimes it is just a longer, cleaner, better-documented way to be wrong.
3. It increases confidence faster than competence
A weak developer used to feel some fear when modifying a system they did not understand. That fear led them to ask questions, call someone who knew more, or leave the poor system alone.
AI gives them confidence.
The model explains the codebase and proposes a change with the calm authority of a senior engineer who has never doubted anything in his life. Then it writes the implementation. The developer pushes it because the answer sounds correct and the markdown headings were beautiful.
But nobody cares how convincing the explanation sounded when customers cannot withdraw their money.
AI can give you a correct answer. It cannot give you competence by osmosis. You cannot sit beside Claude for six months and absorb software engineering through Bluetooth.
Confidence is useful when it helps you explore. It is dangerous when it removes the humility that is required to learn.
Now, how does AI make good developers better?
1. They use AI to remove work, not thought
A good developer does not need to prove their competence by typing every line manually. Nobody is standing behind you awarding points for artisanal, hand-crafted `if` statements.
They let AI handle repetitive work. The time they save goes into the parts that require judgment.
They consider how a feature affects the entire system. They test assumptions before those assumptions become infrastructure. What if a dependency times out? What if a user presses the button twice? What happens when an old client encounters a new API, or when a rollback encounters data written by the new version?
AI does not eliminate their thinking. It gives their thinking more reach.
2. They understand enough to challenge it
Let me say something that might piss off developers…
In raw code production, I do not believe any individual developer is better than any AI model released after June 2025.
These models can write in more languages than one human can learn. They recall patterns from many libraries without searching Google. They can generate several implementations, write the tests, and explain the trade-offs without thinking about lunch halfway through a function.
But writing code is only one part of software development.
A good developer brings the context AI does not have. They can look at a technically valid solution and say, “Yes, this works, but it is wrong for our system.”
Their knowledge is not meant to compete with AI, because it cannot; it’s meant to give the AI direction.
3. They take responsibility for the output
Someone once told me: “I personally think Claude is making my developers produce bad code“.
It is easy to blame AI for bad code. But anytime I see somebody get a terrible result from AI, I know the person did a terrible job.
Yes, AI makes mistakes. But the AI did not enter your codebase, produce its own requirements, write the code, test it, approve its own PR, and deploy itself to production. You did. And if you actually allowed AI to do all that end-to-end, you should be summoned to the village square and flogged mercilessly.
You can delegate the typing, but they never delegate accountability.
So, what should developers do?
1. Use AI aggressively, but deliberately
Use the best models you can afford. Let them write code, generate tests, investigate bugs, and remove every boring task they can. Developers who refuse to use AI are preparing for a world that no longer exists.
2. Understand what you ship
If AI fixes a bug, understand why it happened. The two-minute answer should still leave you smarter than it found you.
If you cannot explain the code without reopening the chat, you’re a dummie. You should just quit for now, go offline for 8 weeks to reset your brain, then come back and restart your career by reading this book: Coding for Dummies.
3. Keep your brain in the conversation
Treat AI like a capable chatty engineer, not a vending machine where the task goes in, code comes out, and you call it a day.
Give it context, challenge its plan, ask what could fail, what it may have misunderstood, and whether there is a simpler approach.
Never let AI retire your brain.
To sum it all up
AI is not creating bad developers from nothing. The bad habits already existed since the days of copy-and-paste programming. AI has simply given them more speed, confidence, and code than their judgment can support.
If blindly generating code with AI is the only thing you contribute, remove “software developer” from your LinkedIn and put “vibe coder”. There is no shame in that; trust me, vibe coders make good money these days.
I understand why olden-day developers can be reluctant to use AI. Their approach to building software naturally forced understanding through construction, whereas AI can let you skip that construction and therefore requires you to deliberately seek understanding.
That old approach created a kind of mechanical intuition. They knew why a system was structured the way it was because they designed it. They encountered bugs, traced them down, fought against constraints, and fixed things themselves. Through that process, they developed strong mental models of memory, execution, networking, data structures, etc.
AI changes the failure mode. You can now produce a surprisingly sophisticated application while having only a shallow understanding of why it works. The code compiles, the tests pass, and you can recognize what the generated code is doing, but you may not be able to construct the solution yourself.
That's the difference between recognition and construction. Reading AI-generated code can help you recognize a solution; building it yourself forces you to understand why the solution exists in the first place.
In that sense, old-school programming had a higher “understanding tax.” AI lowers that tax dramatically, which is great for productivity but it also makes understanding much easier to avoid.
I think developers can have the best of both worlds: use AI to accelerate our work and learning, but never trade away our ability to think. Understand the generated code well enough that when AI loses context, gives you the wrong answer, or keeps proposing complicated fixes, you can reason about, debug, and simplify system yourself.
And one of the best ways to preserve that ability is to have side projects where you deliberately learn the way developers used to: through books, documentation, experimentation, and building things yourself. Use AI when it helps, ask it to explain a difficult concept, challenge your thinking, or help you explore an idea but don't let it design, build, or debug the solution for you. The struggle is part of the learning.
The developers who combine both approaches will have a huge advantage: the mental models and problem-solving ability of the old-school developer, combined with the speed and leverage of AI. They won't just be able to generate more code, they'll be able to direct AI better, recognize when it's wrong, make better architectural decisions, and solve problems it can't solve for them.
That's the best of both worlds: AI gives you leverage, while deep understanding gives you direction. And together, they can make you dramatically more capable than either approach alone.
AI should make you faster, not make you dependent. It should augment your thinking, not replace it.