Vibe Coding Can Build a Web App, But Can It Keep It Running?
Tags: webdev, softwareengineering, ai, beginners
A while ago, building a web application meant spending hours writing code, searching through Stack Overflow, fixing errors, and sometimes wondering why something that worked yesterday suddenly stopped working today.
Things have changed quite a bit. Today, you can simply tell an AI tool what you want, and within minutes, it can generate an application with a login page, database, dashboard, and even payment features.
Honestly, it's impressive. As a software engineering student who also enjoys building things, I find these tools incredibly useful. But there's something about this new way of developing software that I think we should talk about.
It's called vibe coding.
The idea is pretty simple: describe what you want, let AI write the code, run it, and keep asking for changes until everything looks the way you imagined. You don't necessarily need to understand every line of code.
Sounds great, right?
Well, there's a catch. Getting an application to run is one thing. Building something reliable enough for people to actually depend on is another.
Software engineering is more than just writing code
I used to think software engineering was mainly about knowing how to code and build applications. But the more I learn, the more I realise that writing code is only one part of the job.
Think about a simple e-commerce website. You can ask AI to create one, and it might give you something that looks fantastic. But have you considered what happens when hundreds of customers start using it?
What happens if two people try to buy the last item at the same time? Is customer information properly protected? What happens when a payment fails halfway through checkout?
These are the kinds of problems software engineering teaches us to think about.
It's not just about making things work. It's about making sure they continue to work properly.
Some important parts of that process include:
- Planning: Understanding what you're actually building and what users need.
- System design: Making sure the different parts of your application work together properly.
- Testing: Checking what happens beyond the few scenarios you've tried yourself.
- Version control: Keeping track of changes and being able to recover when something goes wrong.
- Security: Protecting user information and preventing common vulnerabilities.
- Maintenance: Writing code that you or another developer can still understand months later.
These things aren't always visible when someone demonstrates an application, but they're what make a difference in the long run.
Where I think vibe coding becomes a problem
I'm not against vibe coding. In fact, I enjoy using AI to speed up development. However, I think there are a few problems when people depend on it too much.
- You might not understand what you've built.
Imagine generating an entire application without really understanding how the different parts work. Everything seems fine until something breaks.
You copy the error into AI, get a suggested fix, apply it, and suddenly something else stops working.
Now you're fixing one problem after another without really knowing what's happening behind the scenes.
AI can help you debug, but you still need enough knowledge to understand whether its solution actually makes sense.
- Security is easy to overlook.
A website can have a beautiful login page and still have serious security problems.
Things like weak authentication, poor input validation, exposed API keys, and badly configured permissions can put users at risk.
The problem is that these issues aren't always obvious. Everything might look perfectly normal from the frontend while serious vulnerabilities exist in the backend.
- Adding new features can become a nightmare.
When you build an application one prompt at a time, it's easy to end up with code that has no clear structure.
You might have duplicated functions, inconsistent naming, and different parts of the application doing the same thing in different ways.
At first, adding features is easy. But as the application grows, making even small changes can become difficult.
- Without testing, you're basically guessing.
Just because a page loads doesn't mean the feature works correctly.
What about invalid inputs? Empty fields? Network failures? Unexpected user behaviour?
Testing helps you discover these problems before real users do. Without it, every update becomes a bit of a gamble.
- Someone still has to take responsibility.
This is probably the most important point for me.
If an application loses customer information or processes payments incorrectly, users aren't going to blame the AI that generated the code. They'll look at the people responsible for the application.
As developers, we need to understand what we're building and be able to take responsibility for it.
Does that mean we should stop using AI?
Absolutely not.
I actually think AI is becoming one of the most useful tools available to developers. It can save hours of work, explain complicated concepts, generate boilerplate code, and help us explore ideas much faster.
The problem isn't using AI. It's depending on something you don't understand.
Personally, I think the best approach is to learn the fundamentals while using AI as an assistant.
If AI generates a database model, take time to understand it. If it writes an authentication system, understand how authentication works. If it suggests a solution to an error, don't just copy and paste it. Try to understand why the solution works.
One rule I think every beginner should follow is this:
Don't ship code you cannot explain.
You don't have to write every single line yourself, but you should understand what you're putting into production.
Final thoughts
I don't think AI is going to make software engineering less important. If anything, it's making the fundamentals even more valuable.
Today, almost anyone can generate an application that looks professional. But building something secure, reliable, maintainable, and capable of handling real users requires much more than a good prompt.
Vibe coding might help you get your first version running in an afternoon. But what happens a month later, when users start reporting problems, your database grows, and you need to introduce new features?
That's where the real work begins.
AI can help you write the code, but understanding the code is still your responsibility.
Top comments (0)