The memo went out in January. AI is here. We are flattening the org. Testers are now feature owners. Developers own their own tests. Everyone gets an agent. Headcount drops thirty percent. Velocity is supposed to go up.

It did, for a quarter. The agents shipped. The audit logs were clean. The dashboards were green. The board got the slide.

Then 2:47 AM. Production database encrypted. Ransomware note in the inbox. The blacklist entry that protected the management plane was removed three weeks ago by an agent in a refactor PR titled “clean up unused config.” Tests passed. Pipeline green. Eighteen approvers signed off across six PRs. The attacker walked through the open door this morning.

The board is on the line by 6 AM. They want a head.

Let’s play the Blame Game.

Agent, Agent, bo-bagent

The agent executed the request it was given in an environment where nobody had built a guardrail to say “this blacklist entry is critical, never touch it without human review of the originating ticket.” The agent has competence. The agent does not have judgment. Those are different things and the difference is the entire point.

The exec wants to blame the agent. The exec cannot. Blame is a currency. It gets spent on someone with a balance. Reputations get drawn down. Bonuses get withheld. Promotions get delayed. The agent has no balance. Pointing at the agent does not satisfy the political need an outage creates. The board does not get its head.

So blame has to land somewhere else. Someone with capital. Someone the org can spend.

Let’s keep playing.

Tester, Tester, bo-bester

The memo redefined the tester’s job. Their value was no longer in finding bugs. Their value was in shipping features with AI assistance. The same person who used to be paid to break things was now paid to ship them. They responded to the new incentive. They shipped this one. Their fingerprints are on the spec, the rollout plan, and the ship decision.

Firing them admits the restructure was wrong. The restructure has the exec’s signature on it.

Dev, Dev, bo-bev

The developer kept their feature targets and absorbed QA on top. The agent wrote the tests. The tests passed. Green builds, clean diffs, fast merges. The signal said the code was good. The signal was generated by the same machine that wrote the code. On paper, the developer authored the failure. In practice, the developer was handed a workload that required the very expertise the org just eliminated, and a quality gate that mostly checked whether the agent was internally consistent with itself.

Greybeard, Greybeard, bo-baird

The greybeard wrote that blacklist entry in 2019 after a specific incident. He never wrote down why. The reason lived in his head. Then he got severed in Q2 to fund the AI seats. The entry stayed. The reason left the building.

He cannot be blamed. He is at a competitor now, watching this from the outside. The system had a rule. Nobody documented it. The only copy was in a person, and the person was treated as a cost line.

Reviewer, Reviewer, bo-buver

Six PRs, three reviewers each, eighteen approvals. The comments were thoughtful. They cited internal style guides. The conventional commits were perfect. The Slack notifications fired on schedule and went unread because everyone knows reviewers handle the small stuff.

Surely one of these eighteen reviewers should have caught it.

Oops. It’s the agent again.

There is no human in the CI review pipeline. There are only other agents pretending to be them, and the pretending is good enough that nobody noticed when it stopped being review. Same model class, same training, same blind spots, in parallel. Eighteen approvals. One opinion. Repeated.

Give the Agent Its Due

The agents are good at their job. They are shipping real work in real production environments for teams that know how to use them. The same person doing more, faster, with better support, is the actual AI success story. Expanding scope inside a role is a force multiplier. Replacing the role with a prompt is a press release.

The agent did not ransomware the database. The agent did exactly what it was asked to do, in an environment deliberately built to have nobody left who could ask why.

Which means the head the board wants is not in any of the verses we have played so far.

Exec, Exec, bo-bec

There it is.

The exec did not fail because they adopted AI. They failed because they used AI as cover for a restructure they wanted anyway.

They collapsed role specialization on the theory that AI flattens skill differences. AI flattens execution. AI does not flatten judgment. They replaced human review with agent review and called it equivalent.

AI multiplies what people know. The exec fired the people who knew things. They multiplied zero. They got the speed of zero with the confidence of a senior engineer.

The Postmortem

That is the diagnosis. Now the reality.

The exec will not accept it. The exec assembled the meeting. The exec controls the narrative. The exec writes the press release. None of those instruments point inward.

The blame still needs a head. The exec has already picked one. The developer wrote the PR, owns the commit, and is the one human in the chain who will sit in the postmortem and say “I should have caught it.”

The press release will say “an unforeseen integration of AI tooling with legacy infrastructure.” The internal memo will say the developer.

The incident will be called an AI failure because that is the cheapest story available.

It was a management failure with autocomplete.