Why I Started VibeTDD: From Skeptic to Framework Builder
For the longest time, I resisted the whole "vibe-coding" trend. You know the one, where developers let AI write most of their code while they sit back and make occasional corrections. It felt... wrong. Like we were giving up the craft that took years to master.
But curiosity eventually got the better of me.
The Experiment That Changed Everything
I decided to run a proper experiment with a real project, not just toy examples or code snippets, but something substantial with multiple components:
- Chrome Extension: Fully written using vibe-coding with Claude
- Web Application: Built mostly with AI assistance using Vue.js + Vuetify
- Backend Services: Developed partially with AI help
The goal was simple: see what happens when you actually try to build something real with AI as your primary coding partner.
What I Discovered
The Good: Speed and Momentum
AI-assisted coding is undeniably fast. Within hours, I had a working Chrome extension that could scrape LinkedIn activity. The web app came together quickly too. There's something intoxicating about the pace — you describe what you want, and code appears.
The Reality Check
But then the cracks started showing:
The Chrome extension ended up being about 4,000 lines of code. After basic refactoring, I cut out 1,000 lines of dead code, duplicates, and unnecessary comments. Looking deeper, only about 40% of the remaining code was actually useful.
The Vue app suffered from over-engineering. Claude would build custom title wrappers instead of using Vuetify's built-in title props. It mixed different patterns for the same components and resisted creating reusable components, preferring to inline everything.
File sizes exploded. One file grew to over 1000 lines, and Claude started getting confused. When I asked to split the code, I got a crazy architecture full of logic I never requested.
The Breaking Point
Here's what really bothered me: every time I hit the context limit and started a new chat, I had to re-explain conventions and project structure. The AI would follow rules at first, then gradually drift back to duplication and poor practices.
It felt like Groundhog Day — uploading source files again and again, explaining the same constraints, fighting the same battles.
The Insight
After weeks of experimenting, my conclusion was clear: AI is excellent for prototyping and simple MVPs, but it breaks down for real, maintainable projects.
However, I couldn't shake the feeling that we were approaching this wrong. The problem wasn't AI itself — it was how we were using it.
The Framework Hypothesis
What if we could harness AI's speed and knowledge while maintaining the discipline that creates sustainable software? What if we combined:
- Test-Driven Development as quality guardrails
- Human oversight for architectural decisions
- AI assistance for implementation speed
- Clear conventions that both humans and AI can follow
This is where the idea for VibeTDD was born.
By the way, this entire experiment led to something unexpected — mirameo.com was born from these learnings. It's a practical application of the principles I was discovering about sustainable AI-assisted development.
Why TDD Changes Everything
Test-Driven Development isn't just about testing, it's about design. When you write tests first:
- You define the behavior before implementation
- You catch regressions immediately
- You force good design through small, focused methods
- You create living documentation of what the code should do
When AI writes code to pass your tests, it can't take shortcuts or add unnecessary complexity. The tests become a contract that keeps the AI honest.
The Mission Ahead
We're facing an exponential growth in AI-generated projects, and many are becoming unmaintainable messes. AI is a brilliant assistant, it knows a lot, works fast, and never gets tired—but it needs proper guidance.
The human is still the boss in software development.
Through this blog, I'll be documenting my experiments in building a practical framework that:
- Combines AI speed with human judgment
- Uses TDD as the foundation for quality
- Creates sustainable practices for long-term projects
- Prevents the "AI spaghetti code" epidemic
What's Next
I'll be sharing real experiments, failed attempts, and successful patterns as I work toward this framework. Some posts will be technical deep-dives, others will be broader reflections on the human-AI collaboration in software development.
The goal isn't to replace developers with AI, but to amplify what makes us great while leveraging what makes AI useful.
If you're interested in sustainable AI-assisted development, quality software practices, or just want to see how this experiment unfolds, I'd love to have you along for the journey.
What's your experience with AI-assisted coding? Have you found ways to maintain quality while using AI tools? I'd love to hear about your experiments and insights.