Alongside many other AI technologies in the past year, adoption of AI-assisted development is exploding—and producing exciting results. In Part Two of our miniseries, Vibe Coding: The Good, the Bad, and the Ugly, we’re continuing our examination of Rightwave’s experience with vibe coding on a large enterprise scale.
If you’re not caught up on the series, you can read Part One by clicking here. Now, let’s dive back into our case study. What happens months after vibe coding has done the heavy lifting?
Vibe Coding: The Bad — When Nobody Owns the Code
As AI-generated code became a larger percentage of Rightwave’s applications, new challenges began to surface:
- Lack of ownership and accountability
- Maintainability and scalability concerns
- Hidden technical debt
- Difficulty debugging or evolving AI-generated systems
At first, these issues were subtle. Easy to work around, and even easier to dismiss. But over time, they became harder to ignore. And 6 months later, what once felt fast no longer felt simple.
A minor billing issue surfaced—something that should have taken an hour to resolve. Instead, it stretched into two full days. One of the remaining developers found herself tracing through layers of unfamiliar logic, trying to understand how the system arrived at its calculations.
Nothing was obviously broken, but that was part of the problem.
The system looked correct—it just didn’t behave the way anyone expected.
Meanwhile, another developer on the team began joking that they had all become “software archaeologists”.
“We don’t write code anymore,” he said. “We excavate it.”
Generated ≠ Understood
The root issue wasn’t that the code didn’t work; it was that no one fully understood it.
Some systems had been built with ChatGPT. Others with Claude Code. Many had been modified and extended through additional prompts, patches, and quick fixes over the 6-month time frame.
The result was a patchwork of working solutions—each one functional in isolation, yet difficult to examine collectively. Questions surfaced such as:
- Why was a certain approach chosen?
- What assumptions were baked into the logic?
- How would changes impact downstream systems?
The answers to those questions were scarcely documented, and on top of that, often completely unknown at this point in time.
The Hidden Cost of Scaling Fast
When Rightwave reduced its development team, it didn’t just lose coding capacity—it lost context. It lost the engineers who would normally:
- Review and challenge implementation decisions
- Document systems and architectural intent
- Ensure consistency across codebases
- Anticipate edge cases and long-term impacts
AI had made it easier to generate code, but it hadn’t replaced the need for engineering discipline. Without that layer of oversight, something else began to accumulate quietly: Technical debt.
Not the obvious kind, like large broken systems or visible performance issues, but subtle, compounding debt such as:
- Inconsistent patterns across applications
- Fragile integrations between systems
- Logic that worked for the “happy path” but broke under edge cases
- Code that could not be easily extended or reused
Each individual piece seemed manageable, but together, they ended up creating friction across the entire organization.
Unfortunately, this impact began showing up in day-to-day work. What used to be quick updates now required deep investigation, and predictable releases now carried a new layer of uncertainty.
As a result, teams slowed down. Not because AI stopped working, but because the systems built with it became harder to evolve.
Even small changes raised new questions: Will this break something else? Do we fully understand what this component is doing? How do we know if this is safe to modify?
This dynamic eroded the team’s confidence, and with it, the very speed gains that had justified the shift in the first place.
The Warning Signs
Throughout this period, the development team from Programmers.ai continued raising concerns. Their message didn’t change:
AI accelerates development. It does not eliminate the need for code reviews, documentation, standards, or governance.
But in the early stages, those warnings were easy to deprioritize. After all, the systems were working. The business was moving forward. Customers weren’t complaining—at least until the cracks started to widen. But the deeper issue with Rightwave’s codebase wasn’t just a technical pitfall; it had now stretched across the organization.
No one truly “owned” the code anymore, at least not in the traditional sense. It wasn’t written from first principles by the team, it wasn’t consistently reviewed or standardized, and it wasn’t even fully understood by the people responsible for maintaining it.
In this case, AI had created output, but not accountability. And without ownership, even well-functioning systems become fragile over time.
The Bigger Pattern—And the Takeaway
Rightwave’s experience is becoming increasingly common. Across organizations rapidly adopting AI-generated development, similar patterns are emerging:
- Faster creation with slower troubleshooting
- More code with less visibility
- Short-term gains, long-term complexity
With this in mind, AI still doesn’t necessarily write bad code. But without proper guardrails, AI acceleration can quickly and quietly turn into organizational friction.
In short, fast code creation is undoubtedly powerful. But without clear ownership, discipline, and understanding, it can lead to systems that are fragile, inconsistent, and difficult to maintain.
Up Next in the Series
In Part 3, we’ll explore what happens when these challenges move beyond inconvenience and into real risk:
What happens when AI-generated code introduces security gaps, compliance issues, or system-wide failure?
If you’re working through similar issues, have questions, or want to share your own experiences with AI-generated code, we’d love to hear from you.
And if you’re starting to encounter friction or just want a second set of eyes, we’re here to help. Our team works with organizations to review, stabilize, and strengthen AI-generated code so you can scale with confidence.
