Vibe coding had a great quarter. Every other post on my feed is someone who shipped an app over a weekend using Claude, Cursor, or Copilot. The demos look incredible.
I'm not here to dunk on that. I vibe-coded two of my own tools in March and the speed was genuinely wild. A content pipeline that would have taken me two weeks was running in a day.
But it's April now. And some things have started breaking.
What I mean by "month three"
There's a pattern I keep seeing, and I finally tracked it across 6 projects -- 2 of mine, 4 from people I talk to regularly in dev communities.
The timeline goes roughly like this:
Week 1: Ship fast. Everything works. Post about it. Get likes. Feel unstoppable.
Week 2-4: Small bugs. You prompt your way through fixes. Each fix is fast but you notice you're not totally sure why certain things work. You added a retry wrapper at some point and now there are three of them in different files.
Month 2: A real bug shows up. Not a typo or a missing null check -- something architectural. The data model assumed X but the feature you just added needs Y. You ask the AI to fix it and it generates a workaround that technically works but adds another layer of indirection.
Month 3: The codebase feels heavy. You want to add a feature and the AI suggests changes in 4 files, but you realize two of those files do almost the same thing. Refactoring means understanding code you didn't write and don't fully grok. The AI can explain it, but the explanation takes longer than writing it from scratch would have.
This isn't a failure of AI tools. It's a failure of the workflow most of us defaulted to.
The two projects I tracked
Project A: Content scoring pipeline -- I vibe-coded this in early March. Four agents, structured handoffs, the whole deal. By week 3 I had duplicate error handling in every agent because each time I asked Claude to fix an edge case, it added its own try/catch without knowing about the others. The fix took me a full day of manual reading. The AI could have done it if I'd asked the right question, but I didn't know what to ask because I didn't understand my own codebase well enough.
Project B: A quiz app -- Much simpler. Single page, API calls, score tracking. This one held up better, and I think the reason is obvious in hindsight: the surface area was small enough that the AI (and I) could hold the whole thing in context. No module boundaries to get confused about.
The difference wasn't about AI capability. It was about codebase complexity relative to context window.
What the other four projects showed
I talked to four devs who vibe-coded projects in January-February and checked in with them in late March.
Two had rewritten significant portions by hand. Not because the AI code was bad -- because it was inconsistent. Different patterns in different files. Three different ways to handle auth tokens. A utility function that existed twice with slightly different signatures.
One had abandoned the project entirely. Not from frustration with AI, but because adding features got slower than starting over would be, and they lost motivation.
One was doing fine -- but they'd been pair-programming with AI from day one, reading every line, and rejecting suggestions that didn't fit their architecture. Their velocity was lower initially but their month-three velocity was way higher than everyone else's.
The actual takeaway (it's not "don't vibe code")
Vibe coding works. The speed is real. But the default workflow -- accept suggestions fast, ship, fix forward -- creates a specific kind of technical debt that compounds faster than hand-written debt does.
The debt isn't bad code. It's inconsistent code. Multiple patterns for the same problem. Abstraction layers that exist because the AI didn't know about the abstraction layer in another file. Error handling that's thorough in some places and absent in others.
Three things that seem to help:
Read before you accept. Obvious, and everyone says they do this, but be honest -- when the AI gives you a 60-line function that passes your test, do you actually read all 60 lines? I didn't, and that's where my duplicate retry wrappers came from.
Refactor weekly, not quarterly. With hand-written code you accumulate patterns gradually and refactor when it hurts. With AI code the inconsistency builds faster because every prompt is stateless. Weekly 30-minute refactor sessions catch the duplication before it becomes structural.
Know your architecture, even if the AI writes the code. The one dev whose project survived month three had a clear mental model of the system. They used AI for implementation but made architectural decisions themselves. That's different from "build me a thing that does X" and it leads to very different codebases.
How well do you actually understand AI's role in your workflow?
I built a quick diagnostic for this -- not a "are you a real developer" gatekeep thing, more a self-assessment of where you fall on the spectrum from "AI writes, I ship" to "I architect, AI implements."
Worth taking if you vibe-code regularly: Check your AI developer workflow
Takes about 2 minutes. No email required. You might be surprised where you land.
I write about AI agent systems, developer workflows, and the messy reality of shipping with AI tools. Follow if that's useful.
Top comments (0)