If the first rush of agentic/vibe coding feels like having a team of superhuman developers, the second phase is a reality check—one that every software builder and AI enthusiast needs to understand.
Why “Vibe Coding” Alone Can’t Scale
The further I got into building real-world prototypes with AI agents, the clearer it became: Joel Spolsky’s law of leaky abstractions is alive and well.
You can’t just vibe code your way to a robust app—because underneath the magic, the cracks start to show fast. AI-generated coding is an abstraction, and like all abstractions, it leaks. When it leaks, you need to know what’s really happening underneath.
My Experience: Hallucinations, Context Loss, and Broken Promises
I lost count of the times an agent “forgot” what I was trying to do, changed underlying logic mid-stream, or hallucinated code that simply didn’t run. Sometimes it wrote beautiful test suites and then… broke the underlying logic with a “fix” I never asked for. It was like having a junior developer who could code at blazing speed—but with almost no institutional memory or sense for what mattered.
The “context elephant” is real. As sessions get longer, agents lose track of goals and start generating output that’s more confusing than helpful. That’s why my own best practices quickly became non-negotiable:
- Frequent commits and clear commit messages
- Dev context files to anchor each session
- Separate dev/QA/prod environments to avoid catastrophic rollbacks (especially with database changes)
What the Research Shows: AI Can Actually Slow Down Experienced Devs
Here’s the kicker—my frustration isn’t unique.
A recent research paper, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, found that experienced developers actually worked slower with AI on real-world tasks. That’s right—AI tools didn’t just fail to deliver the expected productivity boost, they created friction.
Why?
- Only about 44% of AI-generated code was accepted
- Developers lost time reviewing, debugging, and correcting “bad” generations
- Context loss and reliability issues forced more manual intervention, not less
This matches my experience exactly. For all the hype, these tools introduce new bottlenecks—especially if you’re expecting them to “just work” out of the box.
Lessons from the Frontlines (and from Agent Week)
I’m not alone. In the article What I Learned Trying Seven Coding Agents, Timothy B. Lee finds similar headaches:
- Agents get stuck
- Complex tasks routinely stump even the best models
- Human-in-the-loop review isn’t going anywhere
But the tools are still useful—they’re not a dead end. You just need to treat them like a constantly rotating team of interns, not fully autonomous engineers.
Best Practices: How to Keep AI Agents Under Control
So how do you avoid the worst pitfalls?
The answer is surprisingly old-school:
- Human supervision for every critical change
- Sandboxing and least privilege for agent actions
- Version control and regular context refreshers
Again, Lee’s article Keeping AI agents under control doesn’t seem very hard nails it:
Classic engineering controls—proven in decades of team-based software—work just as well for AI. “Doomer” fears are overblown, but so is the hype about autonomy.
Conclusion: The Hidden Cost of Abstraction
Vibe coding with agents is like riding a rocket with no seatbelt—exhilarating, but you’ll need to learn to steer, brake, and fix things mid-flight.
If you ignore the leaky abstractions, you’ll pay the price in lost time, broken prototypes, and hidden tech debt.
But with the right mix of skepticism and software discipline, you can harness the magic and avoid the mess.
In my next post, I’ll zoom out to the economics—where cost, scaling, and the future of developer work come into play.
