They Shipped Buggy Code Faster. AIOps Is About to Do It Again.

Years ago, a company called me to troubleshoot their new mainframe continuous integration and continuous delivery (CI/CD) process.

Except it wasn’t a CI/CD problem, because what they’d built wasn’t CI/CD. They’d implemented virtualization to give every developer an independent development environment. Faster provisioning. No more contention for the shared region. The execution win was real.

What they didn’t see was what that shared environment had been quietly doing for them. Years of institutional regression testing lived there, coupled to the region they’d just virtualized away. Nobody decided to abandon testing. No meeting. No memo. The testing wasn’t removed. It was orphaned. They found out the way you always find out: after the defects shipped.

The net result of their modernization: they shipped buggy code faster.

You couldn’t install DevOps

DevOps was never a product. However, enterprises spent a decade buying CI/CD toolchains, keeping their operating model unchanged, and getting faster pipelines for the same defects. People, process, and technology, and everyone bought the technology first.

AI for IT Operations (AIOps) is being bought the same way right now. But AIOps isn’t a product. It’s an operating model: the talent to specify what a system may decide, the observability to verify what it actually decided, and explicitly placed authority to stop it.

One difference this time, and it’s not in our favor. DevOps failures broke artifacts, and you can roll back a release. AIOps failures break decisions. Same install-it thinking. One layer up. Applied to something you can’t un-ship.

This time we can measure it

HyperFRAME Research just published open survey data from 520 enterprise infrastructure and operations (I&O) leaders. Three numbers tell the story:

Delegation is exercised at more than twice the rate governance is claimed. Careful with that 24%: it doesn’t mean the other 76% have nothing. It means only a quarter of the market can say, without hedging, that governance is structurally in place.

Now add talent. Forty-nine percent report a significant skills gap in the combined technical and legal expertise needed to govern AI, and it’s the #1 barrier they name. The data has no respondent-level crosstabs, so I won’t claim the overlap as fact. But if the gap is distributed independently across adopters, roughly one in four enterprises is already operating delegated AI authority without the talent to govern it. That number only falls if talent-poor organizations are concentrated outside the 56% already operating these systems. Maybe they are. The data doesn’t give us the crosstab. But with 56% operational and another 36% planning deployment, the safer reading isn’t comfort. It’s collision.

The failure modes, measured

I’ve written before about the failure modes that follow unplaced authority. Those were structural predictions. This data puts market-scale numbers on the preconditions for every one of them:

What the data can’t show

This is perception data. It measures where leaders believe authority sits. Drift, the failure mode that matters most, is the divergence between that belief and runtime reality. A survey can’t see it. By construction.

So here’s the claim the data does support, and it’s worse: the market has dismantled its own ability to falsify the belief that humans are still deciding.

Go back to the mainframe shop. The thing that broke wasn’t the code. It was the regression suite: their falsification machinery. They deleted their ability to know their code was bad without ever deciding to. The AIOps market is doing the identical thing to its decision layer. Nobody chose to ship buggy code. Nobody is choosing to cede authority. That’s what makes it drift.

The principle is simple: never delegate decisions faster than you build the machinery to falsify them.

Two questions tell you whether you’re in this population:

1. For every AI workflow running right now, do you know who is authorized to stop it?
2. When they stop it, does the system generate an auditable record of who said no, to what, and under which policy?

If you can’t answer both, you don’t have a governance position on drift. You have an unfalsifiable belief that it isn’t happening.

Before the second call

The mainframe shop’s call was answerable. The broken thing was an artifact: a test suite, something you can point at and rebuild. The AIOps version of that call has no artifact to point at, and the person you’d call is the technical-plus-legal hybrid half the market can’t hire.

The first symptom is already here. Eighty-four percent agree AI consumed more budget than planned. Overrun is what unspecified scope looks like on a budget line. The second symptom is a post-mortem full of technically accurate statements and no accountable party.

There’s more in this dataset: the outsourcing two-hop, the EU AI Act collision. Posts for another day.

The market has decided to delegate. It hasn’t decided who’s accountable, and it lacks the people to answer the question.

They shipped buggy code faster. Don’t ship unaccountable decisions faster.