Most companies govern enterprise software at the end. That’s the most expensive place to do it, and AI is about to make it unworkable. A change is built and ready to ship, then waits for a change board, a security sign-off, or a compliance review. By then the reviewers have the least context and the most power to delay the work, and the number of changes waiting for them keeps growing.
Faced with too little context and too much at stake, reviewers do what anyone would. They ask for more documents, hold the change until the next meeting, or send it back for rework. A company moves faster when people know what they’re allowed to do before they start.
In the last essay, I argued that building enterprise software and governing it should happen together, using a bank whose new loan rule lived in a spreadsheet for months because its loan systems couldn’t keep up. If the checks only happen once the work is done, they’re still a gate, with finished work waiting for approval. That’s the ticket queue we’re trying to get rid of.

At the end, governance is one big review that changes pile up behind. Woven through, each stage answers its own question, the work keeps moving, and what you learn in improve feeds the next decision.
A gate at the end doesn’t make changes safer
A final approval gate is a poor substitute for checks throughout the work. If an approval process slows teams down, it ought to make their changes safer. Yet DORA, the research program that has studied enterprise software delivery for more than a decade, found that heavyweight external approval, such as a change advisory board, hurt delivery performance. It found “no evidence” that a more formal, external review process was associated with fewer failed changes.
The wait can create problems of its own. When approval is slow and expensive, teams save changes up and send them through approval together. That gives reviewers more to untangle and means more can go wrong in a single release. When something breaks, the natural response is more review. Now the wait is even longer, and the next batch is bigger. DORA calls this “a vicious cycle.”
Manufacturing learned this long ago. W. Edwards Deming, the quality expert credited with helping turn around Japan’s postwar manufacturing, said to “cease dependence on inspection to achieve quality” and build quality “into the product in the first place.” Inspection at the end of the line can reject a bad car. It can’t build a good one.
The clearest case I know comes from finance. Knight Capital is one of the best-known deployment failures in the industry. In 2012 it rolled out new trading code to eight servers and missed one. The eighth server still held old code Knight had stopped using in 2003, and the new release set it off. According to the SEC’s order, the system sent millions of orders into the market in about 45 minutes while trying to fill 212 customer orders. Knight lost more than $460 million. Before the market opened, its systems had sent 97 emails flagging an error. Nobody acted on them.
Knight’s deployment controls failed well before anyone could contain the incident. What Knight lacked were checks during the work. The SEC noted that Knight “did not have a second technician review this deployment.” Code nobody used had been left in place for nine years. The warnings went to an inbox nobody read. Its order router was called SMARS, and the SEC found Knight had no “procedures in place to halt SMARS’s operations.” In the last essay I said governing a change means it has an owner, a person who approved it, a record of what happened, and a way to stop it. At Knight, each of those was missing or weak.
AI changes what a review means
Before AI, a gate at the end was tolerable. At most large companies, only engineers shipped changes. They came in a handful of big releases a quarter, each weeks in the making, and a reviewer could read them. So that’s where the checking went.
After AI, almost every part of that is different. Changes come from engineers, business teams, and agents. There can be hundreds of them, each built in hours. No one can read them all. Agents also act: they answer customers, update records, and move money. The risk moves from the release to what each agent is allowed to do.

Who changes enterprise software, how often, and what a review has to be, before and after AI.
The last six months made this impossible to ignore. On 9 November 2026, Anthropic released Claude Fable 5.2 and described an experiment in which one engineer gave the model an empty folder and asked for a prototype operating system. The model coordinated more than 1,000 subagents for eight days and produced a working operating system that boots on a laptop. Anthropic also said over 90% of the changes merged into its own core codebase are now written by Claude, with human guidance. No change board reads that much. Gartner predicts that by 2027, 40% of enterprises will demote or decommission their autonomous AI agents because of governance gaps found only after production incidents.
The instinct is a bigger gate: more reviewers, more meetings, more sign-offs. I don’t think that works. A gate built for a few big releases will stall hundreds of small ones. The way through is to stop saving the checks for the end.
Security made the same move, which engineers call shift left. Teams stopped counting on a security review just before release and moved the checks into design and the build pipeline. The reason was cost. As NIST’s Secure Software Development Framework puts it, the earlier security is addressed, the less effort and cost it takes. AI needs the same move for all of it: policy, approvals, and audit at every stage, from decide and spec through build, ship, run, and improve.
Governance starts before anyone builds
The most important approval happens when you decide what to build. It comes before anyone builds anything.
Take two requests that look alike. One team wants a tool that drafts marketing emails. Another wants one that scores personal loan applications. Both are a form, some data, and a model. They carry very different risks. If the email tool gets something wrong, someone rewrites a paragraph. If the loan tool gets something wrong, a person is denied credit they should have gotten, and the bank has a regulator asking questions. The EU AI Act lists systems that judge people’s creditworthiness among its high-risk uses, and it requires their risk management to run “throughout the entire lifecycle.”
So the first questions, at decide, are about the use case. Who owns it? How risky is it? If it’s wrong, who gets hurt? The email tool and the loan tool might be built the same way and still get very different answers.
The next stage is the spec. When AI agents build enterprise software, the spec is what the agent builds from. So that’s where the rules go, including what data the work may touch and what an agent may do on its own.
Go back to the bank. Its credit committee decided that small business loans above a certain size need a second review from risk. The bank made that rule itself. In the old world, that rule lived in a spreadsheet, a few emails, and someone’s memory. In the new one, it goes in the spec: loans above this size go to risk, risk’s answer is recorded, and no loan closes without it. The rule is written once, in plain language, by the people who understand it. When the committee changes the rule, its owner updates the spec, and the new version is approved, tested, and shipped like any other change. Nobody reworks a codebase.
The rules run while you build
Once the rules are in the spec, they can be checked automatically every time something changes. Engineers call this policy as code. Tools like Open Policy Agent let a company write a rule once and have many systems check it the same way. A rule a person has to remember gets forgotten on a busy Friday. A rule that runs on every change gets checked every time.
The more AI can do, the clearer we need to be about what it’s allowed to do. That’s why agents need rules of their own. Gartner, in the same release, blames agent failures on governing every agent the same way, and its fix is levels of autonomy. The way I think about it, an agent should earn autonomy the way a new hire does. First it watches. Then it suggests, and a person decides what to apply. Only then does it act on its own, and only within limits. A person decides each step up. The agent never promotes itself.
The limits also depend on what the agent is touching. The same agent can act freely on test data and still need a person’s approval in production. OpenAI’s white paper on governing agentic AI systems recommends limiting what an agent can do, requiring human approval for high-risk actions, keeping logs people can read, and making sure an agent can be interrupted.

Agents move from watching to suggesting to acting, and a person decides each step. What they may do also depends on where they’re working.
The other thing that has to happen during the build is proof. When an agent says “I tested it,” that’s a claim. A test that fails without the fix and passes with it is evidence. The proof should come from the system that ran the test.
And anyone should be able to stop the work when something looks wrong. Then problems get fixed where they start.
What’s left at the end is small
When the rules are checked at decide, spec, and build, the end gets simple. One question is left at ship: is this the version that was approved?
That question matters more than it looks. An approval should belong to one specific version of a change. If the change is edited after someone approves it, the approval shouldn’t quietly carry over. Otherwise you’ve approved something nobody actually saw. Knight would have failed this one: only seven of its eight servers ran the approved code. The SEC faulted Knight for having no second technician review the deployment, and a system can do that review in seconds by checking every server against the approved version. So the check at ship stays small.
People still look where judgment is needed. Treating every change the same is a common mistake. A wording fix on an internal page and a new rule for who gets a loan shouldn’t wait in the same line. When the routine checks are automatic, reviewers can spend their time on the few changes that deserve it.
Auditors get something better too. A policy written in a document is a claim. A policy that ran on every change, with a record of each result, is evidence. Hand auditors that record.
Here’s a good test of whether the checks are in the right place. The normal change process should be fast and reliable enough to use for emergency changes too. If the only way to fix something urgent is to go around your approvals, they’re in the wrong place.
Governance lets more changes move at once
Air traffic control is what made flying at scale possible. It knows the flight plan before the plane takes off, it watches the whole flight, and it keeps a record. Because it’s there the whole way, a lot of planes can fly at once.
Enterprise software needs the same thing. When the checks run at every stage, a change can go as soon as it’s ready.
After launch, someone has to watch what the system and its agents actually do. That’s the run stage. Knight’s 97 warnings were never designed as alerts, and it had no procedure for halting its own system. At run, the questions are whether anyone is watching and whether you can stop it.
The last stage is improve, and the checks run there too. You check whether the change did what the spec said, and what you learn goes into the next spec. The record of what happened is what makes improving safe.
Every project should make the next one easier to get right. A rule written once checks every change after it. A permission an agent earned carries forward, within its limits, until it expires, its scope changes, or a person revokes it. A record from last month answers this month’s audit question. The fiftieth change should be cheaper to build and cheaper to govern than the first.

