Vibe coding makes software development easier. But better, too?
With Vibe Coding, almost anyone can build working software in a short time today. That’s impressive and opens up many new possibilities. At the same time, it’s easy to forget that working code is far from the same thing as good software. My take on why AI makes development easier while good software engineering is still becoming more important.

You have an idea for a small web app.
So you open your AI tool and write:
“Build me an app that lets customers upload their documents and see the current status of their order.”
A few seconds later, files start appearing.
One more prompt:
“Make the design more modern.”
Then:
“Add a login.”
Then a database.
An error appears. You copy it into the chat. The AI changes something. The error is gone.
An hour later, you open the app in your browser.
And it works.
At least, it looks that way.
It’s fascinating and dangerous at the same time.
Suddenly, anyone can build software
The term vibe coding was coined by Andrej Karpathy in early 2025. Originally, it referred to a fairly extreme way of programming.
You tell the AI what you want. The AI writes the code. If something doesn’t work, you describe the problem or send back the error message. Eventually, it works.
Sometimes, you barely even look at the actual code.
At the time, Karpathy described it more in the context of small projects, where you simply let the AI carry you through the development process.
A tremendous amount has changed since then.
The tools have improved. The models have improved. And what started as a bit of fun has become a real way for many people to create software.
That’s a great thing, in principle.
An idea that once would have required a developer can now be running in a browser as a first prototype within just a few hours.
You can try something out.
You can show customers an idea.
You can find out whether a problem even needs its own software.
Vibe coding is extremely powerful for that.
Here’s where the problem begins
Let’s take the app we just talked about.
- The login works.
- The file upload works.
- Customers can see their orders.
Everything looks good.
So you might think:
Done.
But software isn’t just what you see in the browser.
Who is allowed to open which files?
- Could a customer change the ID in a URL and suddenly see someone else’s order?
- What happens if two changes are made at the same time?
- What happens to a file if the upload is interrupted halfway through?
- Are passwords and access credentials properly protected?
- Are there backups?
- What happens in six months when a new feature is added?
You can’t see any of these things just by clicking through the app.
And the AI usually doesn’t point them out on its own, either.
It’s given the task of building a feature.
So it builds a feature.
But that doesn’t mean the result is good software.
Works ≠ Done
This is probably the most important point I feel is missing from the whole discussion about vibe coding.
Software can work and still be poorly built.
That was true even before AI, by the way.
Developers can write bad code, too.
Developers can overlook security issues, too.
Developers can build solutions that no one understands anymore, too.
AI didn’t invent this problem. It just changed the speed at which it happens.
And that’s exactly what makes this interesting.
It used to take time to write bad code. Today, I can generate a lot of bad code very quickly.
Of course, I can generate good code just as quickly.
But the difference doesn’t necessarily lie in the model.
The difference lies in whether someone can assess what’s being created.
The first 80 percent
The first 80 percent suddenly feels incredibly easy
For me, this is one of the biggest effects AI has had on programming.
You get to a visible result extremely quickly.
An interface is ready.
Data gets saved.
Buttons work.
An API is connected.
It feels like enormous progress.
And it is.
But a real software project isn’t made up of visible features alone.
The final pieces are often the unglamorous ones.
- Error handling.
- Permissions.
- Tests.
- Data migrations.
- Monitoring.
- Performance.
- Maintenance.
- Security.
These are exactly the things that don’t make for an impressive demo on LinkedIn.
But they determine whether an app really works in the long run.
Recent studies on vibe coding show precisely this tension. The speed of prototyping is a real advantage. At the same time, there’s still much less robust evidence about how maintainable these applications are over the long term.
There are also unresolved security issues.
A 2026 study tested various coding agents on real-world software tasks. Many of the solutions worked technically, but still weren’t implemented securely.
That doesn’t mean I think we shouldn’t use these tools.
Quite the opposite.
I don’t want to develop without AI anymore
For me, the wrong conclusion to draw from all this would be:
“Then let’s go back to writing all our code by hand.”
Why?
If a tool can take work off my hands, I want to use it.
I don’t have to write the same form logic for the tenth time just to prove to myself that I can program.
And I don’t have to search through every piece of documentation if an AI tool can help me.
If an AI creates a first draft of a feature, I save time.
If it helps me find a bug faster, I save time.
If I can build a prototype in an hour that used to take me a day, that’s progress.
That’s why, for me, the question is changing less in terms of who writes the code.
The much more important question is:
Who understands what’s been built?
The job is shifting
That’s why I don’t think software development is simply going to disappear, either.
It’s changing.
Maybe I’ll write a lot less code myself in the future.
In return, I’ll have to make better decisions.
How should the app be structured?
Which data belongs together?
What information is a user allowed to see?
What happens when something goes wrong?
Which parts need to be tested?
Where can the AI make decisions, and where can’t it?
What happens when the requirements change?
An AI can help me with all of these things.
But it can’t take responsibility for the decisions off my hands.
You notice this as soon as an app gets bigger.
A single prompt can generate 20 new files very quickly.
Another prompt changes ten of them.
Then a problem gets fixed.
But that creates a new one somewhere else.
After a few weeks, you might have an app with thousands of lines of code that works.
But no one really knows why anymore.
This problem has also started to show up in research. A recent study observed the collaboration between a developer and Claude Code over several months. Among other things, it documented situations where missing context and cascading errors made the collaboration increasingly difficult.
I find that much more interesting than the question of whether AI can program.
Of course it can.
The more important question is whether we can still keep the result under control in the long term.
For a prototype, I’d use vibe coding right away
If I want to test an idea today, I see little reason to spend weeks building a perfect technical foundation.
Build the idea.
Show it to people.
Let them try it.
Find out whether anyone even has the problem.
If the code ends up in the trash afterwards, that’s perfectly fine.
That’s exactly what vibe coding is great for.
The UK’s National Cyber Security Centre now also recommends considering the use of these tools in light of the risk posed by the software in question. A prototype or an internal tool is different from an app that handles sensitive customer data or access credentials.
I think this distinction is important.
Not every piece of code needs to be built to last ten years.
Sometimes I just want to try out an idea.
In that case, it’s fine for software to be quick and dirty.
For me, it only becomes a problem when that prototype suddenly turns into a real product.
“It works” quickly turns into “customers are using it”
That probably happens faster than you think.
On Monday, someone builds a prototype.
On Tuesday, they show it to the team.
On Wednesday, the boss likes it.
By Friday, someone says:
“Can’t we just use this right away?”
And suddenly, the little prototype is handling real customer data.
In my opinion, this is exactly the point where our mindset needs to change.
It’s no longer enough for the app to work.
You need to understand what’s happening under the hood.
You need to review it.
Clean it up.
Test it.
Set limits.
Maybe rebuild parts of it.
That feels slower.
It is slower.
But that’s where software development begins for me.
Vibe coding doesn’t replace thinking
Maybe that’s the biggest thing I’ve learned from this whole development.
AI makes it incredibly easy to generate code.
That’s a huge step forward.
But code was never the real goal.
The goal is software you can rely on.
Software that solves a problem.
Software that still works when a user does something no one expected.
Software you can still change a year later.
And software where customer data doesn’t suddenly end up exposed just because no one checked the permissions.
Vibe coding takes a lot of work off our hands.
But it doesn’t take responsibility off our hands.
Maybe that’s exactly why good software engineering will become even more important in the years ahead.
Because if anyone can generate software in just a few hours, the decisive skill will eventually no longer be whether someone can build software.
It will be whether someone can tell whether it was built well.