When I first started experimenting with AI-assisted development—better known as “vibe coding” —I treated it like a thought exercise. It felt experimental, even gimmicky. However, over the past few months, my team and I have gone deep on it, actually building internal tools and client prototypes using Anthropic’s Claude and other models.
What started as curiosity has turned into a crash course in the new realities of software creation. Vibe coding isn’t theory anymore. It’s a practical tool. But like any new tool, it’s only as good as the person using it.
How Fast is Fast?
To see what was possible, we decided to rebuild one of our own internal systems—a resourcing and allocation tool that tracks employee skills and project assignments. We’d already spent nine months building it the traditional way. Then, as an experiment, we decided to try vibe coding it. I gave one of my engineers—someone who’d never used Claude before—a single instruction: Try building the same thing, start to finish, using prompts. During the time it took our resourcing lead to eat lunch, he had vibe-coded a fully clickable demo.
For anyone who’s built enterprise tools, that kind of speed feels like a cheat code. For well-understood problems like “build a scheduling app” or “create a LinkedIn-style dashboard,” AI can absolutely fly. I’ve even started building MVPs live during client calls, just to show what’s possible. Two or three times a week, I’ll sketch out a concept in real time, and it’s often shockingly close to what ends up in production.
But that’s also where the limits start to show.
Where it Breaks Down
The illusion of speed is real. A polished UI can hide a brittle foundation. These systems often lack the architecture, patterns and documentation that make real software scalable and maintainable.
Even small changes, such as updating contrast or refactoring a data model, can send you into chaos if you’re not versioning, testing, or committing regularly. Large language models aren’t deterministic, so even re-running the same prompt can produce different outcomes. Without checkpoints and discipline, it’s easy to lose track of what “good” looked like.
Early on, I ran into these walls all the time, hitting quota limits, strange API quirks or the AI confidently making things up. Over time, I realized vibe coding depends less on clever prompts and more on clear thinking. When your input is vague, the output unravels into chaos.
Architecting for AI
That’s why I’ve started calling this approach “architecting for AI.” The goal isn’t to replace engineering. It’s to build a framework that AI can understand and build on.
If you feed it consistency—structured naming conventions, modular thinking, clean logic—it will start to produce code that works seamlessly together.
On one recent side project—a gaming platform I vibe-coded from a Figma design and basic requirements doc—I started rough. The first few iterations were full of noise and dead ends. But once I established a pattern language the model could follow, everything clicked.
Now I can say, “Add a leaderboard,” or “Add a user inventory,” and it just does it, cleanly, consistently and predictably. It’s not that the AI got better; it’s that I learned how to work with it.
That’s the core shift: the real skill is architecting for AI.
The Maintenance Problem
Here’s the thing most people overlook: A vibe-coded app still needs maintenance.
All the same engineering fundamentals apply—documentation, testing, version control and code reviews. If you skip them, entropy creeps in fast.
At one point, I joked that we’re becoming “AI janitors.” And honestly, it’s true. These tools make it easy to create a massive surface area of code in minutes, but you also create technical debt just as quickly. If you don’t clean as you go, you’ll be knee-deep in AI work slop within weeks.
Think of it like gardening. You can plant a whole forest overnight now, but someone still has to prune the trees, pull the weeds and keep the ecosystem healthy.
We’re even starting to formalize that as a service: AI cleanup. Teams come to us with vibe-coded prototypes that look great on the surface but are impossible to extend. Our role is to stabilize them and turn them into a sustainable product.
Takeaways for Technical Teams
If you’re in DevOps or engineering leadership, here’s what we’ve learned the hard way:
- Treat vibe coding like a prototyping tool, not a production shortcut.
- Always build with rollback points and version control.
- Document as you go. AI code deteriorates more quickly when its origin is unknown.
- Establish an “architecting for AI” framework with consistent naming, modular design and reusable prompts that create coherence across outputs.
- Expect cleanup cycles. Plan for refactors and maintenance just as you would in traditional sprints.
The Bottom Line
AI-assisted coding isn’t a buzzword; it’s a real change in how software gets built. Developers can now go from idea to prototype in hours, not weeks. But speed alone doesn’t win. The advantage comes from pairing that velocity with structure. When humans define the blueprint and AI executes it, the result isn’t just faster code, it’s durable, scalable systems built for what’s next. Because in the era of infinite generation, the real differentiator isn’t who can build—it’s who can sustain.
