No Vibe for Vibe Programming
Why AI-Generated Code Creates More Problems Than It Solves
AI promises to democratize software development through "vibe programming", the practice of describing what you want and letting AI write the actual code. But this seductive shortcut doesn't reduce your need for developers. It increases that need while making their jobs harder and your systems more fragile.
The promise sounds compelling: write what you want in plain English, let AI translate it into working code, and watch your application come to life in minutes instead of days.
This is "vibe programming”.
Vibe programming is the practice of using AI to generate production code from natural language descriptions. Proponents claim it will democratize software development and reduce the need for traditional professional developers. The reality is far different and far more troubling.
Vibe programming doesn't reduce your need for software developers. It increases that need while simultaneously making their jobs harder and your systems more fragile.
The Seductive Speed of Vibe Programming
To be fair, vibe programming delivers impressive results for simple, isolated tasks. Need a function to parse CSV files? Describe it, get the code, and it often works on the first try. Want to build a basic CRUD interface? The AI can scaffold one faster than you can say "model-view-controller."
This speed creates a powerful illusion. Teams see rapid initial progress and extrapolate that velocity across their entire development timeline. Management sees the first features emerge quickly and assumes the remaining 90% of the work will proceed at the same pace.
This is where the trouble begins…
The Security Alarm Bells
Security researchers have been sounding warnings about vibe programming for good reason. When developers don't fully understand the code they're deploying, they can't properly evaluate its security properties. AI-generated code may contain vulnerabilities that aren't obvious from the surface behavior. SQL injection risks, authentication bypasses, and insecure data handling can all hide in code that "works" for its primary function but fails catastrophically under adversarial conditions.
More insidiously, vibe programming creates new attack vectors. Bad actors can craft prompts designed to inject malicious code into AI-generated outputs. Because the human developer may not fully understand the resulting code, they might not recognize the backdoor or the data exfiltration routine buried among otherwise legitimate functions.
Building proper security into AI-generated code requires significantly more effort than teams typically apply. It demands careful code review, security testing, and often substantial refactoring. This is all work that negates much of the supposed productivity gains from using AI generation in the first place.
The Hidden Cost: Unmaintainable Code
But security concerns, serious as they are, represent only part of the problem. The deeper architectural issue with vibe programming lies in what happens after that initial code generation: long-term maintenance and evolution of your system.
When you use vibe programming, you accumulate thousands of lines of code that nobody on your team actually wrote or fully understands. The AI produces code optimized for the specific prompt it received, not for clarity, maintainability, or alignment with your system's architectural patterns. The result is code that works but that your team can't effectively reason about, modify, or debug.
Consider what happens when requirements change..and requirements always change.
A developer needs to add a feature or fix a bug in AI-generated code. They can read through it, but the patterns may be unfamiliar, the naming conventions inconsistent with the rest of your codebase, and the logic structure optimized for AI generation rather than human comprehension. Understanding what the code does takes longer. Understanding why it does things a particular way becomes guesswork. Making changes without introducing bugs requires extraordinary care because the developer doesn't have the mental model that comes from having written the code themselves.
The Vicious Cycle
This dynamic creates a perverse trap: your team struggles to understand and maintain AI-generated code, so they use AI to help them understand it. They describe what they think the code should do, ask the AI to explain what it actually does, then use AI again to generate the modifications they need. At each step, the human developers understand the system less and depend on AI tools more.
This cycle is doomed. Software systems accumulate complexity over time. They develop intricate interdependencies, subtle invariants, and implicit contracts between components. These system properties emerge from hundreds of decisions made during development. Typically, these are all decisions that exist in the heads of the developers who made them. When those decisions were made by AI based on isolated prompts, that institutional knowledge never exists anywhere accessible to your team.
As the system grows, the gap between what your developers understand and what your codebase contains widens. Eventually, you reach a point where significant changes become nearly impossible because no human can confidently reason about the system's behavior. You've created technical debt at an industrial scale,. This technical debt has interest payments that must be paid. Those interest rates are in the form of slowed development velocity and increased defect rates. And these costs compound relentlessly.
The Myth of Reduced Developer Need
The fundamental misunderstanding driving vibe programming adoption is the belief that it reduces the need for skilled developers. This is backwards. Vibe programming increases the need for developer expertise while making it harder to apply that expertise effectively.
You still need developers to:
- Understand your business requirements deeply enough to write effective prompts
- Evaluate whether generated code actually meets those requirements
- Integrate AI-generated components into your broader system architecture
- Review code for security vulnerabilities and architectural misalignment
- Debug issues when behavior doesn't match expectations
- Maintain and evolve the system as requirements change
- Make architectural decisions about system structure and component boundaries
What vibe programming does is add a massive new burden: understanding and maintaining code that your team didn't write, using patterns they didn't choose, implementing logic they didn't design. This is harder than writing code from scratch because your developers must reverse-engineer intent from implementation rather than expressing intent through implementation.
A Better Path Forward
AI tools have legitimate value in software development. They excel at assisting developers with specific tasks: suggesting completions, explaining unfamiliar code, generating boilerplate, and catching common errors. These assistance modes augment developer productivity without creating the comprehension gap that vibe programming introduces.
The key difference is ownership. When developers write code with AI assistance, they still own the logic, understand the decisions, and can reason about the system behavior. The code reflects their thinking, expressed more efficiently through AI help. This is fundamentally different from vibe programming, where the AI owns the implementation details and the developer just specifies desired outcomes.
From an architectural perspective, the choice is clear. Treat AI as a powerful tool that helps your developers work more effectively, not as a replacement for developer expertise and understanding. Use AI assistance where it genuinely helps without sacrificing comprehension. Avoid letting AI-generated code become a black box that your team must maintain but cannot truly understand.
Your system's long-term health depends on human understanding of how it works and why it's structured the way it is. Vibe programming trades that understanding for short-term velocity gains. While this trade may seem advantageous to you, it is a trade that will cost you dearly as your system grows and evolves.
Software architecture is fundamentally about managing complexity and making systems understandable and maintainable over time. Vibe programming works directly against these goals. It multiplies complexity, obscures understanding, and makes maintenance harder. There's no vibe in that. All there is, is increasing pain as your technical debt compounds.
The allure of instant results is strong, but architectural wisdom means looking beyond the immediate moment to the system you'll be living with for years to come. That system needs to be understood, maintained, and evolved by your development team. Vibe programming makes all of those things harder, not easier.
For the long-term health of your architecture, and for the long-term health your valuable development teams, give the current hype about vibe programming a hard pass.
