The Vibe-Coding Debt Panic: What I'm Actually Seeing

If you’ve read any dev newsletter this month, you’ve seen the headlines: vibe coding is quietly burying companies in technical debt, and there’s a “reckoning” coming in 90 days, six months, a year — pick your number. I get why this narrative spreads. It’s a satisfying story: people got lazy, let the AI write everything without looking, and now they’re paying for it. But after spending a good chunk of this year being the freelancer who gets called in to untangle exactly this kind of codebase, my actual take is more boring than the headlines: this isn’t a new problem, it’s an old problem running at 10x speed.

The codebases I inherit don’t look new. Two months ago I picked up a contract to add a feature to a Next.js app that, as far as I could tell, was almost entirely agent-generated with close to zero human review. Six API routes, each one reimplementing the same validation logic slightly differently. Error handling that either didn’t exist or just wrapped everything in a bare try/catch that swallowed the actual error. Component names that didn’t match what the components did, because nobody ever renamed anything after the first draft. I want to say this was uniquely bad because of AI, but honestly? I’ve seen the exact same shape of mess from junior devs working solo without review, and from cheap outsourced shops racing a deadline, back before any of this AI tooling existed. The pattern isn’t new. The tool that produced it is.

What actually is new is the volume. That’s the part I think the “vibe coding is destroying software” articles get half-right and half-wrong. They’re right that the debt is accumulating faster than most teams have ever seen. A junior developer without review might write a few hundred sloppy lines a day. An agent working unsupervised can write a few thousand in the same time, across a dozen files, before anyone’s had coffee. If your team’s discipline was already weak — no required review, no tests, “we’ll clean it up later” as an actual process — AI doesn’t create that weakness. It just runs your existing weakness through an amplifier. The debt was always going to happen. Now it happens on a much shorter timeline, which is exactly why it feels like a sudden crisis instead of the slow decay everyone’s used to.

So what do I actually do differently with agents? Not less generation — more review, and review that’s structured, not vibes-based itself. Every diff an agent produces for me, I read line by line before it goes anywhere near a commit, the same way I’d review a junior’s PR. I caught a bug a few weeks ago where an agent had reused a loop variable name from an outer scope inside a callback — technically valid JavaScript, completely wrong behavior, and it would have shipped silently if I’d skimmed instead of read. Not a hypothetical caution, a real bug from a real week. The agent wasn’t “hallucinating” in the dramatic sense people worry about — it was just confidently wrong in a way that looked completely normal at a glance. Which is exactly why skimming an AI diff is more dangerous than skimming a human one: humans tend to leave awkward, suspicious-looking code when they’re unsure. Agents leave clean, confident-looking code even when they’re unsure. The smell you’d normally rely on to slow down and look closer just isn’t there.

The fix isn’t “use AI less.” For a solo freelancer juggling multiple projects, that’s not realistic advice, and honestly it’s not advice I’d take myself. The fix is the boring one that was always true before any of this: small, reviewable chunks of work instead of giant unreviewed drops; tests that actually run before merge, not tests written after the fact to make a coverage number look good; and treating every line an agent produces as a draft from a fast, capable, occasionally-wrong junior — not as finished work. None of that is a new discipline invented for the AI era. It’s the same discipline good teams have always needed, just now with less room for error because the volume of code moving through the pipeline is so much higher.

Where I actually agree with the panic is on the incentive problem. A lot of the worst codebases I’ve inherited weren’t built by people who didn’t know better — they were built under deadline pressure where “ship it, we’ll fix it later” was the actual instruction from above, and AI just made “ship it” faster to say yes to. That’s a management problem wearing an AI costume. Blaming the model for a codebase that a business explicitly chose to skip reviewing is letting the actual decision-makers off the hook. If your org had no review process before agentic coding tools showed up, you didn’t have a technical debt problem waiting to happen — you already had one. The tools just made it visible faster.

There’s a version of this argument from the other direction too — people who wave off any concern about AI-generated code because “review has always caught bad code, so nothing’s actually different.” I don’t buy that either. Volume changes the economics of review itself. A human reviewer has a rough budget of attention for a day, and that budget doesn’t scale up just because the code being reviewed scaled up 10x. If a team keeps its review process exactly the same while the amount of code flowing through it multiplies, the realistic outcome isn’t “review catches everything like before,” it’s “review quietly gets shallower without anyone deciding that on purpose.” That’s the actual mechanism behind the debt panic, and it’s a legitimate one — just not the one most of the doom headlines describe. The problem isn’t that AI writes bad code. It’s that AI can outpace a review process sized for a slower era, and nobody explicitly resized it.

I don’t think vibe coding is some unprecedented threat to software quality. I think it’s a stress test exposing which teams already had weak engineering discipline, at a speed that makes it impossible to ignore. For the projects I work on solo, that’s actually made me more careful, not less — I trust the agent to write fast, and I don’t trust anything it writes until I’ve read it myself.