Over-Mocking Is a Governance Problem, Not a Review Smell A 2026 MSR paper by Hora and Robbes analyzed 1.2 million commits, isolating 48,563 agent-authored ones, and found that coding-agent test commits introduce mocks 36% of the time versus 26% for human test commits, with agents clustering on a single test-double style and producing more brittle suites. The post argues the resulting tilt is a governance problem rather than a review smell, since reviewers cannot keep pace with agent-scale test generation, and that the fix belongs at the convention layer that shapes what the sampler sees. Originally published at tddbuddy.com https://www.tddbuddy.com/blog/over-mocking-is-a-governance-problem/ . Related reading: Agents Pattern-Match Your Test Smells https://www.tddbuddy.com/blog/agents-pattern-match-your-smells/ named over-mocking as one of five smells; this post is the dedicated argument backed by the empirical study. The Contract Test Is the Only Witness the Agent Cannot Author https://www.tddbuddy.com/blog/the-contract-test-is-the-only-witness/ owns the seams the allowlist opens. The Instruction File Is Not the Discipline https://www.tddbuddy.com/blog/instruction-files-are-not-the-discipline/ is the same failure mode at a smaller scale. The study counted the mocks. The answer was a policy question. A 2026 paper by Hora and Robbes arxiv 2602.00409, MSR 2026 measured 1.2 million commits across public repositories, isolated the 48,563 authored by coding agents, and compared the rate at which those commits introduce test doubles against the rate at which humans introduce them. Agent test commits add mocks 36% of the time. Non-agent test commits add them 26% of the time. The agents concentrate on a single test-double style where humans spread across stubs, fakes, spies, and mocks. The suites that result are more brittle than the human baseline on the measures the paper reports. The gap is directional, not deterministic. Ten percentage points on a measured dataset is a clear signal; it is not evidence that agents mock everything in sight. What the signal describes is a tilt. A codebase that already leans on mocks gets leaned on harder. A codebase that leans harder teaches the next session to lean harder still. The industry's instinct is to catch this in review. The industry's instinct will not scale. Over-mocking stopped being a review smell on the day the sampler got faster than the reviewer. What has to replace the review is governance, and the convention layer is where the fix lives. The MSR study is not a thought piece. It is 1.2 million commits, 48,563 of them agent-authored, measured on a comparison the review-pass-at-a-time workflow has no way to see. The 36% versus 26% delta is the headline. The subsidiary findings matter as much. Agent-generated test commits cluster narrowly on one test-double style, where human commits distribute across the toolbox in a way that tracks the shape of the problem. Brittleness on the agent-generated portion reads higher than the human baseline on the paper's measures. That shape is a governance shape, not a taste shape. A review-taste finding would show scattered individual lapses the reviewer could flag one at a time. A governance finding shows a measurable, directional, dataset-scale tilt that recurs regardless of which reviewer is on the PR. The reviewer did not cause the tilt. The reviewer cannot fix the tilt. The tilt is a property of how the sampler reads the codebase and extends it. The intervention that moves the number lives at the layer that shapes what the sampler sees. Governance beats hunting. The earlier post in this arc listed over-mocking as one of five smells agents reproduce from the local suite. That framing is honest and it is necessary. It is also insufficient on its own. The review-smell lens looks at a single PR, surfaces a single mock, asks a question, and moves on. The workflow fits the production rate of a human writing one test at a time. It does not fit the production rate of a sampler writing twenty. The math is against the reviewer structurally. A reviewer who catches eight mocks in a diff of twenty tests has caught eight mocks and shipped twelve. The twelve ship with precedent weight: each becomes an example the next session samples. Next week's PR arrives with thirty tests built on top of the twelve. The reviewer who was running an uphill fight starts running one on a steeper hill. What the review-smell framing earns is the diagnosis. What it does not earn is the fix. The fix is one level up, at the convention the reviewer is defending. A reviewer defending a strong convention catches the exceptions. A reviewer defending nothing in particular is reading diffs at reading speed against a sampler running at generation speed, and the arithmetic has one answer. The smell outruns the reviewer. The reviewer's job is to hold the convention that decided whether the mock was allowed. Agents mock what the codebase mocks. Every merged PR adds a vote for the pattern it carried, and the next session reads the vote. A suite with a mock-heavy convention will produce mock-heavy tests at generation throughput for as long as the convention stands. The precedent is not a historical artifact. It is the active specification for what the next hundred tests will look like. This is the mechanism the earlier posts in this arc have been circling. Agents are faithful pattern-matchers. The faithfulness is a feature when the pattern is good and a liability when the pattern is a smell. A codebase that teaches "every collaborator is a mock" by example gets that teaching reproduced with structural fidelity, in every file, at generation speed. The sampler does not know the convention is a smell. The sampler knows the convention is what the suite says to do. The suite is self-instructing. The question is which instruction it carries. Flipping the default is the move. Mocks are not banned. Mocks are not allowed without a named seam. A static analyzer rejects Mock