Ghost decisions

Why the code your agents generate is full of choices no one made, and what it costs to leave them unowned.

July 15, 2026 11 min read

In April 2026, Google's CEO said 75 percent of the company's new code is now AI-generated and approved by engineers, up from 50 percent last fall, and framed it as a move to agentic workflows, with engineers increasingly orchestrating fleets of autonomous agents rather than writing the code themselves. Sit with the mechanics of that for a second. Every one of those agents, generating every one of those files, arrived at hundreds of forks: which library, which retry policy, which data shape, which error to swallow and which to surface, which of two reasonable patterns to follow. At each fork it chose. Almost none of those choices was a decision anyone made.

That is the thing worth naming, because it is becoming a large and rising part of how new code is written and it does not have a name. Call it a ghost decision: a choice that governs your system's behavior, selected by an agent picking the most probable option, that no authorized person decided and that was never recorded as a decision. It exists in effect but not in fact. Your codebase is filling with them, faster every quarter, and the reason they are dangerous is precisely that they do not look like anything at all.

The default is a decision

Start from what the agent actually does. A language model generates the most probable continuation given its context. At a fork with two defensible options, it does not weigh them against your situation; it emits the one that was more common in training. That is not a flaw, it is the mechanism working as designed. But notice what it means. The modal choice is not the right choice. It is the average choice, the one the rest of the industry happened to make most often. When the agent resolves a fork, it resolves it toward the population mean.

Now compare that to what happened when a person wrote the same line. Even the small forks, the ones nobody would write a document about, were resolved by a human carrying context: this codebase uses that pattern, this customer needs that guarantee, we got burned by this once. Most of those were tiny, implicit decisions, but they were decisions, made by someone who knew something the population average did not. The agent replaces that carrier of context with a frequency count. Multiply by the hundreds of forks in a file and the tens of thousands in a service, and you have quietly swapped your judgment for the training distribution's, one invisible choice at a time.

The word decision is load bearing here, so let me be precise. A decision is a choice made by someone with the standing and the context to make it. A default accepted silently by a probability maximizer is a choice, and it has all the consequences of a decision, but it lacks the two things that make a decision a decision: an author and a rationale. It is a decision with the person removed. That is the ghost.

Why you cannot see them

A real decision leaves a trace. Someone argued for it in a pull request, or wrote it in a doc, or at minimum still remembers making it, so when it turns out to be wrong you can find the decision, find the reasoning, and revise it. A ghost decision leaves only the code. And code is a record of what, never of why: it shows the retry policy that shipped, not the three that were rejected, not the reason, not the constraint that should have governed the choice and did not. You cannot review a decision that was never surfaced as one. You cannot grep for a choice nobody flagged. The ghost is invisible not because it is hidden but because there was never anything there to hide.

It gets worse, because the code is inconsistently read at best. Sonar's State of Code survey in early 2026 found that AI already writes or assists 42 percent of committed code, that 96 percent of developers do not fully trust it is correct, and that only 48 percent always check it before committing. In other words, half of developers admit they do not always check generated code before it ships. And do not be reassured that the code is approved by engineers, in Google's phrase: approving a generated diff is a verdict on the output as a whole, not a decision on each of the thousands of forks inside it, and it is exactly that shallow whole-diff pass the trust-but-verify numbers describe. So the ghost decisions are not merely unrecorded, they are often only partially examined. They enter the system at machine speed and stay, because the reviewer who might have turned a ghost back into a real decision, by noticing it and asking why, does not always see it.

The drift is in the aggregate

No single ghost decision looks wrong. Each one is the reasonable default, the thing a competent stranger would also have picked, which is exactly why it passes review on the rare occasion it is reviewed. The cost does not live in any one of them. It lives in the sum.

Your architecture is the accumulation of these choices, and a large and rising share of it is now being shaped by code written with or by AI: more than 40 percent of new code across the industry, and 75 percent at the frontier. So the system drifts, steadily and invisibly, toward the average of everything the model was trained on, while the specific reasons your system was supposed to differ from that average go unhonored. The drift surfaces only at collisions: the moment a ghost decision meets a real constraint it never knew about, a customer contract, a compliance rule, a hard-won lesson from an incident three years ago. Then it shows up as the worst kind of bug, the kind that runs, passes its tests, reads cleanly, and violates something that mattered, and when you ask why the code does this, the honest answer is that no one decided it should. A probability maximizer did, at a fork, months ago, and moved on.

Most defaults should stay defaults

Here is the nuance that keeps this from being an argument for reviewing every line, which would be its own dystopia. Most forks genuinely do not matter. The modal choice is fine the overwhelming majority of the time, and forcing a human to ratify every variable name and every loop would tax the work to a standstill and defeat the entire point of the agent. The problem is not that agents pick defaults. The problem is that there is no boundary between the forks where the default is fine and the forks that encode a constraint you already decided, and so the agent defaults on both. It cannot tell the difference, because the difference lives in information the agent does not have: which of these thousand choices is one your organization already made on purpose.

That reframes the whole thing. The goal is not to eliminate ghost decisions, it is to make sure the agent never ghosts a fork you have actually decided. Everywhere else, let it default in peace.

Turning the ghost back into a choice

If the difference between a ghost and a governed choice is an author and a rationale, then the fix is to put your real decisions where the agent meets the fork, so that when a choice is one you have already made, the agent defers to the decision instead of reaching for the average, and when it is not, it defaults as before. A recorded decision is the thing that resolves a fork on your terms rather than the population's. It is also, not incidentally, the only way to ever see the ghosts: the gap between the decisions you have made and the forks the agent is quietly resolving is the map of where your architecture is being written by no one. This is a different job from remembering what the agent believes it did, which is its own unreliable problem, and a different job from catching violations after the fact, which is inspection arriving too late. It is the job of deciding, on purpose, before the fork, and having that decision be present when the agent gets there.

We built Brief to be where those decisions live, so the agent reads them at the fork and you can see which forks are still unowned. But the naming survives without us, and it is the part that matters: as AI shapes a large and rising share of new code, the question was never whether agents make your decisions for you. They already do, thousands of times a day. The only open question is whether you can tell which ones.

What this does and does not claim

It does not claim agent defaults are usually wrong. They are usually fine, which is what makes the exceptions so hard to catch. It does not claim you should review every generated line; the argument is the opposite, that blanket review is the wrong tool and a smaller set of governing decisions is the right one. And it does not claim recording decisions is free; it is real work, and the honest version of this only asks you to do it for the forks that actually encode a constraint, not for all of them. The load-bearing claim is narrow: a choice made by a probability maximizer with no author and no rationale is a decision with the deciding removed; these choices accumulate wherever agents are allowed to resolve forks; and the ones that collide with a real constraint are invisible until they break, unless the decision existed before the fork did.

Frequently asked questions

What is a ghost decision? It is a choice that shapes your system's behavior, made by an AI agent selecting the most probable option at a fork, that no authorized person actually decided and that was never recorded as a decision. It has the consequences of a decision but neither of the things that make one accountable: an author and a rationale. Because it leaves only code behind, and code records what rather than why, a ghost decision cannot be reviewed or revised the way a real decision can.

Why does my AI agent keep choosing patterns we do not use? Because it resolves each fork toward the most common option in its training data, not toward your codebase's specific conventions or constraints, which it usually cannot see. The pattern it picks is the industry average, and where your team deliberately does something different, the agent has no way to know that the difference was a decision rather than an accident, so it defaults to the average and quietly overwrites your choice.

Isn't it fine for the agent to pick sensible defaults? Almost always, yes, and that is the point of using it. The trouble is only at the forks that encode a constraint you already decided on purpose, a customer commitment, a compliance rule, a lesson from an incident. The agent cannot distinguish those from the thousands of forks where the default is harmless, so without your decisions present it defaults on both, including the ones you would never have defaulted on.

How is this different from technical debt? Technical debt is a shortcut someone chose knowingly and could, in principle, point to and explain. A ghost decision has no one to point to; it was never chosen by a person at all. Debt is a decision you can find and pay down. A ghost is a decision that was never made, which is why it is harder to detect and impossible to attribute after the fact.

How do you stop agents from making decisions no one approved? Not by reviewing every line, which does not scale and misses the point. You make your real decisions available to the agent at the moment it reaches the relevant fork, so it defers to a decision where one exists and defaults freely everywhere else. That requires the decisions to be recorded, current, and retrievable at generation time, which also gives you the one view that otherwise does not exist: which forks your team has actually decided, and which are still being resolved by no one.