Vibe-Coding leads to messy Codebases - What can we do?

Intro

AI code generation leads to messy codebases! Specifically vibe-coding.

Beyang Liu from Sourcegraph said: some devs swear by AI, and others call it garbage. Who’s right? Well… both.

One dev uses AI to generate small, independent function helper utilities, simple API calls, unit tests. They love it. Another dev tries to have AI build full features in one go. They hate it.

It all comes down to complexity.

If the task is well contained, AI is incredible. It doesn’t matter if it’s 10 lines of code or 1,000 lines as long as the requirements are clear, the output will be solid.

But as soon as there are too many moving parts e.g. dependencies, architecture decisions, trade-offs, AI loses the plot. It doesn’t “think” the way we do. It just predicts what code should come next based on patterns. And in complex scenarios, those patterns aren’t enough.

This leads to AI codebases becoming a mess.

Techniques for Decreasing Complexity

Ever since ChatGPT blew up, people have been trying to figure out a tricks to improve AI generated code.

Prompt Engineering

The way you phrase a prompt changes everything. If you just ask, “Write a function to do X,” you’ll get something generic. But if you say, “Write a function in the style of a senior developer, following best practices for Y framework,” the result is noticeably better. However, this just mitigates the problem, and doesn’t solve it.

Providing Context (RAG)

Another trick is Retrieval Augmented Generation (RAG). Instead of expecting AI to “just know” things, you feed it the relevant information. You tell it, “Here’s our project’s architecture. Here’s our coding style. Here is our documentation. Now write the function.” Suddenly, AI makes fewer dumb mistakes.

Agents

This is where things get even more interesting. Instead of dumping a huge request into AI and hoping for the best, you break it into smaller tasks—just like a good dev would. • One part of the AI handles database queries. • Another focuses on API logic. • Another refactors and tests the code.

Then, everything comes together at the end. This structured approach gets you closer to something usable.

But even with all these techniques, AI still struggles to get it clean and structured reliably. At least in my case.

Abstracting Away the Complexity

So, what if we stopped asking AI from coding everything from scratch?

Let me put it this way: Imagine I ask you to build a PC. You’d break it down into tasks:

1. installing the GPU
2. setting up storage
3. assembling the motherboard.

But would you build the CPU yourself? Of course not. That’s a specialized job requiring factories, rare materials, and years of expertise.

Software should work the same way. Instead of having AI build an entire system from the ground up potentially making a mess along the way, why not just give it pre-built components?

This is where frameworks come in.

If we had a framework with predefined building blocks for API layers, database interactions, and authentication, AI wouldn’t have to invent everything. It could just assemble components in a structured way.

And that’s not about the speed of development. It’s about consistency. Instead of 100 different ways to write an API, the framework provides one clear way. AI no longer has to guess.

This could lead to a more consistent codebase, making it much easier to maintain.

Conclusion

So, what’s the takeaway?

AI Needs Better Tools, Not Just Better Prompts.

If we want AI to generate production-ready applications, we shouldn’t expect the impossible.

Instead, we should: • Keep AI focused on small, well-defined tasks. • Provide precise instructions through prompt engineering and context. • Use frameworks in addition to precise prompts to give AI a structured way to write code.

If we do that, AI stops being 100 junior devs chaotically hacking together a project and starts being much more maintainable and thus more useful.