Vibe Slop, the Build-Everything Mirage, and the Governance Gap Nobody Budgeted For

This Is a Security Problem First

Most coverage of vibe slop treats security as a footnote. I will not, because security is the part that keeps me up at night and the part that should keep every CISO up too.

A 2025 assessment that ran more than a hundred large language models across eighty real-world coding tasks found that roughly 45% of AI-generated code contained vulnerabilities from the OWASP Top 10. Java fared worst, failing security checks ~72% of the time. Cross-site scripting flaws showed up at ~86% failure rate across models. And here is the part people skip: newer, more capable models did not fix this. They produced syntactically cleaner code that still carried the same security holes. The models got better at looking correct without getting safer. That is precisely the trap.

Independent scanning work tells the same story from another angle. Researchers who examined ~5,600 vibe-coded applications turned up 2,000+ vulnerabilities and 400+ exposed secrets — hard-coded keys and credentials sitting in code that someone shipped. The failure patterns are remarkably consistent: models skip input validation unless explicitly demanded; they scaffold applications with no authentication at all; they hard-code secrets in a meaningful share of cases; they pull in sprawling dependency trees for trivial requests; they reach for outdated cryptographic algorithms.

This is the same category of problem I have spent the last two years cleaning up on the Microsoft side. Copilot tenant after tenant gets switched on, surfaces sensitive files nobody knew were overshared, and exposes risk that had been sitting dormant for years. AI does not invent your security debt. It finds it, accelerates it, and broadcasts it. The remediation pattern is the same one EPC Group ships in our Copilot Readiness Assessment and the broader Defender XDR + Purview deployment.

The Honest Counterweight: The Productivity Gains Are Not Fake

If I stopped here, I would be writing exactly the kind of one-sided scare piece I dislike. Let me argue the other side as fairly as I can.

Some of the most credible measurement comes straight from provider APIs. Research pulling cohort data from Cursor, GitHub Copilot, and Claude Code found a strong correlation between heavier AI use and greater developer output — during weeks when AI use peaked, heaviest-engagement developers reportedly authored several times more durable work than developers who used no AI at all. Large organizations report meaningful, measurable wins — one telecom reportedly shipped engineering code about 30% faster while saving hundreds of thousands of hours. The same 30% figure keeps surfacing from unrelated directions; practitioners describe Copilot-style tools cutting time-to-deploy and accelerating release cycles by roughly a third.

For validating an idea, vibe coding can replace a $50-100K engineer-built prototype with a few hundred dollars in AI credits. The output is not production software and was never meant to be — it is a validated specification. The danger is never the prototype. The danger is the prototype that quietly graduates to production because it “worked” and nobody made the call to throw it away.

The honest reading is a productivity paradox: AI-assisted coding raises throughput and raises the cost of fixing what it ships, at the same time, in the same organizations. Output goes up. The reliability tax goes up with it. Telemetry across tens of thousands of developers found AI-heavy teams ship more — and PRs grew ~51% larger, bugs per PR rose ~28%, median review time stretched to several times its baseline, incidents per PR roughly tripled. One MIT researcher described AI coding tools as a brand-new credit card that lets us rack up technical debt in ways we never could before. The gains are concentrated at the moment of typing, and the costs are smeared across everything afterward.

When Code Generation Is the Discipline, Not the Slop

There is a development happening in parallel that almost nobody is connecting to any of this — and it deserves the headline. In mid-2026 Perplexity published research on something it calls Search as Code. Instead of treating search as a black box you query and consume, they broke their search stack into atomic composable primitives — retrieval, ranking, filtering, fan-outs, rendering — and exposed them as an SDK. A model writes actual code in a secure sandbox to assemble those primitives into a custom pipeline tailored to the task. For a simple question, a couple of calls. For a hard one, it orchestrates thousands of search operations in a single turn, with conditionals, parallelism, deduplication, and verification baked in.

Vibe slop is what you get when a model writes code from a vague prompt and a tired human ships it unread. Search as Code is what you get when a model writes code against a carefully engineered set of primitives, runs it in a sandboxed runtime, and is held to an explicit verifiable contract. One is improvisation pretending to be engineering. The other is engineering that happens to use a model as the orchestrator.

Their case study pointed the system at a brutal real-world task: identify and characterize more than 200 high-severity security vulnerabilities across three years, citing the affected vendor's own advisory for each, naming the product and the fixed version, and proving the fix is actually tied to that vulnerability. Their approach scored 100% on accuracy while using ~85% fewer tokens than the baseline. Competing systems came in under 25%.

Every move in their architecture is a governance move dressed up as an engineering one. Rules encoded into the query plan — only vendor-owned advisory pages counted, aggregators ruled out at the source rather than filtered later (untrusted by default). Model used as a planning subroutine, not the final authority — the code summarized where coverage was thin, asked for targeted refinements, and validated each proposed query before running it (the model proposes; the code disposes). An explicit verifier with a real schema and a confidence threshold — a page only survived if it bound one vulnerability to one product and one fix version in the vendor's own text. Weak evidence got discarded.

Strip away the search specifics and that is a verification gate, a cross-checking step, a source-traceability requirement, and a human-defined confidence threshold — the exact governance layers EPC Group builds into every multi-AI BI engagement. Three different parties, three different starting points, one conclusion. The villain was never code generation. The villain is code generation without the second half of the system.

Where I Land