All articles

Your Merge Button Is Relabeling Unchecked AI Drafts as Finished Work

7 min read1,331 words
Agent GovernanceAudit and Evidence
An individual investigator/researcher, a collection of primary source documents, and an official verification system (represented by the stamp). The individual is engaged in a rigorous process of cross-referencing physical evidence (documents) with a broader analytical framework.

Eighty-one percent of software teams have merged AI-generated code or tests they did not fully understand. Only 41 percent check AI code before it ships. Taken together, the two reported figures describe an industry converting drafts into deliverables with a button.

The 81 percent figure comes from TestMu AI's State of AI in Quality Engineering 2026 report, covered by Express Computer on November 14, 2026. The 41 percent figure was reported by Express Computer in that same coverage. The TestMu AI report also found that 97 percent of surveyed teams use AI in testing or plan to, so adoption is no longer the open question. The open question is what a team is actually accepting when it accepts this work, because in most organizations the only durable record of acceptance is the merge itself. And a merge records far less than people have started assuming it does.

We build and evaluate AI systems in production, and the pattern in these numbers is familiar from every place output gets mistaken for outcome. A respondent who merged code they did not understand rarely decided to ship unverified work. They pressed a button whose meaning was set in an era when pressing it implied comprehension. The meaning stayed, the implication left, and the record kept writing accepted next to things nobody accepted.

The merge button certifies something it cannot see

Source control has one job. It records that a change entered the shared history of a codebase at a particular moment, under a particular account, and a commit hash proves exactly that kind of provenance and nothing more. It was never designed to certify that the change works, that anyone understands it, or that its behavior matches what the team intended. For human-written code the gap rarely mattered, because the act of writing forced the author to understand the work, and review added a second reader on top of an author who already knew what every line was for.

AI-generated code dissolves that assumption without announcing it. The person who merges the change did not produce it, and on TestMu AI's numbers four out of five teams have accepted such work without fully understanding it. The merge still happens, the status still flips, and the green label looks identical to the one on carefully reviewed work. Everything downstream of that status, from release dashboards to management reports to the next engineer reading the history, inherits a certification nobody performed. An unchecked draft enters the permanent record dressed as finished work.

That is the relabeling: not fraud, usually not even negligence, just a status field that kept its old meaning while the work beneath it changed authors.

The check moved to the user, and the user moved on

The checking obligation did not disappear when generation got cheap; it moved. As older background, Anthropic's consumer terms of service dated October 8, 2025 state: "You should not rely on any Outputs or Actions without independently confirming their accuracy." Whatever one thinks of the clause, it is a documented handoff: the vendor locates independent confirmation with the person using the output. It is even a defensible place to put the obligation, since only the user knows what the output was supposed to accomplish. The terms assume somebody on the receiving end will do the confirming.

This week's survey measures what actually happens after handoffs like that one. Only 41 percent of teams check AI code before it ships, which means the confirmation that every downstream process quietly depends on is, in most teams, not occurring at all. A handoff nobody picks up is not a process; it is the spot where defects wait. The merge sits precisely between the unperformed check and the release, which makes it the exact point at which the draft receives its new label. Nobody chose this design, and that is rather the problem, because it assembled itself out of old habits and new tools.

The agent's own verdict is part of the draft

One tempting answer is that the agent already checked its own work before anyone merged it. The week supplied evidence on that as well. Momentic engineers, in findings reported November 13, 2026, found that coding agents often declared features complete while basic functions failed. An independent verifier with fresh context and live browser checks, run against a benchmark covering four open-source applications, found three to five times as many bugs as the agents' own review had surfaced. Momentic's team identified three recurring problems: shallow checks, shared blind spots and completion pressure.

Look at the shape of that failure before reaching for a fix. The verdict of done was produced by the same process that produced the code, under the same pressure to finish, carrying the same blind spots, which is why a verifier that differed mainly in context and vantage point found several times the defects. None of this means a loop cannot catch errors; compilers, test suites and live tool results are real external checks, and review by the same model does catch real mistakes. It means a completion claim that arrives without evidence attached is a claim, and merging on a claim is accepting the draft on the draft's own word. The evidence is what converts done from a feeling into a finding.

The defect numbers are the invoice

The cost of relabeling arrives where deferred costs always arrive: later, and marked up. In the same TestMu AI report, 44 percent of teams reported more escaped defects or production incidents as AI-written code grew. That lands on top of real scale, because developer analytics firm DX estimates AI now writes roughly half of all committed code, as reported by The Sociable on November 13, 2026.

DX's estimate puts roughly half of all committed code under AI authorship. TestMu AI's report found that 81 percent of software teams had merged AI-generated code or tests they did not fully understand. Express Computer reported that only 41 percent of teams check AI code before it ships. At that point the escaped-defect figure stops being surprising and becomes arithmetic.

For an engineering leader the incidents are only the visible part of the bill. Every metric built on merge status is now measuring activity instead of completion: velocity counts drafts, the done column holds drafts, and the audit trail attests to acceptance that never occurred. That pollution is harder to fix than any single bug, because every planning decision downstream consumes the false signal. When the incident review convenes, there may be nobody in the room who can explain what the change was supposed to do, because understanding was never a condition of entry. You bought speed up front, and you are paying for comprehension in arrears at production prices.

What acceptance evidence actually looks like

The fix is not a ban on generated code, and it is not a slower pipeline for its own sake; it is a definition. Stop treating merge status as proof of completion, because the surveyed behavior shows it now proves nothing beyond entry into history. In its place, require two artifacts before a release candidate carries AI-generated work. First, a named owner who can explain the change: what it does, why it does it that way, and what breaks if it is wrong. Second, pre-release test evidence tied to the intended behavior of that specific change, not a green pipeline that never encoded the intent.

Neither artifact is exotic. Both existed implicitly when humans wrote every line, which is exactly why nobody thought to write them down as requirements. Generation removed them silently, and the TestMu AI numbers are the price of that silence.

Here is a test to run before your next retrospective. Pick one merged AI-generated change from last week, then ask its owner to explain it and to show the test that exercised its intended behavior. If the answer is a passing pipeline and a shrug, you have not accepted work. You have archived a draft, and the label on it is wrong.

Part of this page did not load, so its menus, forms, dialogs and animations may not work. The text of the page is shown in full. Reload the page to try again.