The Road or the Hairball
The walls came down. Pave the road, or live in the sprawl
I stumbled on a McKinsey piece from a few years ago the other day — a 2022 report on low-code and no-code, the last time we told non-technical people they could build software. Buried in it was this term: phantom couplings. A shadow app quietly consumes an IT system’s data, the IT team changes something reasonable, and the shadow app breaks in a way nobody traces back for weeks. Read it in 2026 and it doesn’t feel like history. If anything, it feels more relevant than ever.
Consider these two examples. One is about the nine seconds it took an AI agent to delete a production database this month. Operator-level access, one irreversible command, no human in the loop. Some called it a “backup verification gap.” That’s one way to put it. And it isn’t only startups. The Financial Times reported that AWS let its own coding agent, Kiro, fix a bug in production last December; the agent reportedly decided the cleanest fix was to delete and recreate the environment, taking AWS Cost Explorer down for thirteen hours. Amazon disputes the framing — it was, they said, “user error — specifically misconfigured access controls — not AI.” Hold onto that phrase. It turns out to be essential for what’s to come.
I wrote a piece a few weeks ago called Everyone Is a Builder Now. Non-technical people are shipping automations that hit Jira, post to Slack, write to prod APIs. That’s the fun and optimistic version. The other side of the same coin is: those automations are a live, messy dependency graph — and you can’t see it, let alone govern it. And it’s going to grow exponentially.
This is the part that’s genuinely new. For decades, software inside a company came from one place: engineering. That’s over. Increasingly the apps aren’t built by engineers at all — they’re spun up and adapted by finance, ops, marketing, the teams closest to the problem. Engineering is no longer the sole source of software, and the org has to cope with that whether it planned to or not.
Two dangers, one cut leash
Different dangers hide in here, and they’re worth pulling apart — because they’re related but not the same. One is invisibility: you don’t know the code exists, so you can’t trace it, can’t govern it, and it breaks something in a way nobody connects back for weeks. That’s the phantom-coupling problem. The other is blast radius: you may know exactly what the thing is, but it’s been handed the keys to do real, irreversible damage. It’s also where the security and compliance nightmares live. That’s the nine-seconds problem. One is that you can’t see it; the other is that what you can’t see can do anything.
The old world had both dangers too, but leashed. Low-code apps were active — a zap fired on a trigger, wrote to Salesforce, moved money without anyone opening a file. But they were bounded and deterministic: they ran only through the platform’s connectors, on surfaces the platform could see, and they did exactly what you wired, nothing more. Even the dumbest failures stayed inside their box — Public Health England quietly dropped sixteen thousand COVID cases when an automated export hit an .xls row cap in 2020. Bad, but bounded: one broken step in one predictable pipeline, doing exactly the wrong thing it was wired to do. The AI version is unbounded and autonomous. It reaches any API, and it decides what to do on its own. Same two dangers — invisibility and blast radius — just with the leash cut.
Pave it (or pretend)
So what do we do about it?
The reflex is to lock it down. Approval workflow, security review, mandatory catalog. Every place I’ve watched try this has produced some version of the same result — the vibe collapses. And the vibe is the whole point. Non-technical teams build their own tools to scratch an itch that central IT would take weeks or months to reach, because in the grand scheme of priorities it never rises to the top. But let’s be honest — part of it is also just fun. The fun of building something shaped exactly for you and the handful of people you work with. Tell those people to route around a security screening, file a verification request, and wait for approval, and you don’t get safer software. You get no software.
And that would be a real loss. Modern organizations run on software, so people building the tools they need isn’t a hobby — it’s a spark worth protecting, not a thousand small liabilities to stamp out. The tension between untamed creativity and ungoverned mess is real. I feel it too.
Back to McKinsey. Their prescription back then was sensible — don’t ban the citizen builders, give them a path with guardrails. Give them a platform, a catalog, and — above all — a promotion path. Here’s what’s changed, and it’s the point of the story. Low-code had a platform. It was a walled garden — a bounded surface where every app was at least visible to the people who ran it. Vibe coding tore the walls down. The automations now run anywhere, call any API, touch live systems, and appear in no catalog at all. AI didn’t kill low-code. It killed the one thing that made low-code governable. The phantom couplings McKinsey worried about were manageable when you could at least see the apps. Multiply them by a thousand invisible ones and you have what most large organizations are struggling with right now.
So the right frame is the one platform engineering figured out a decade ago. A paved road. You publish the opinionated, supported path, you make it fast, and you accept that people can go off-road when they need to — off-road just means they carry the full weight themselves. And above all: not everything should be promoted. A private filter someone built for their own dashboard should stay a private filter forever. A workflow three teams now depend on has to graduate — get reviewed, get an owner, get real error handling — before the whole company is quietly standing on it. And the thing that decides which tier you’re in was never how the app was built. It’s blast radius: what it can touch, and who bleeds when it breaks.
So the old question “who’s allowed to build?” is no longer relevant. In 2026 the answer has to be everyone, whether you allow it or not. The question that matters now is: who’s on the hook when it breaks?
The sales rep’s Zapier can lie to them. Fine. The billing automation your finance team vibe-coded can lie to a customer. Not fine. The agent your engineering team gave production credentials to can delete a database in nine seconds. Definitely not fine. Same tools, three different tiers — and the thing that sorted them was blast radius. Which, you’ll remember, is what Amazon called “misconfigured access controls.”
We already built the hairball. That’s not the problem. The problem is telling ourselves we can put off paving the road — right up until something deletes the database in nine seconds.