A single conceptual change forces edits in many small places — adding one logging field means touching 17 files spread across the codebase. The reviewer's cognitive load rises because every site has to be verified independently, the team's search cost multiplies with the count of scattered sites, and one missed site ships broken.
A single conceptual edit forces the agent to identify, load, and modify many small sites — each cheap individually but the search and completeness-check cost dominates. The agent's context-window load rises across N files just to verify the same logical change everywhere, and the retrieval cost of finding the next site competes with reasoning about the change itself.
All code that varies together lives together — separation of concerns applied so a single axis of change maps to a single edit site. Adding a new field is one change in one module; the reader sees the axis in the module name, and reviewers verify the change in one place rather than reconstructing it from N partial diffs.
All code that varies together sits in one place; the agent loads one module to make any change along this axis and verifies completeness in one read. The agent's context window holds only the relevant slice; the reasoning step count drops because the agent doesn't reconstruct the scattered set, and completeness-check cost collapses to a single file.
Smellier version
// Five files each have:log(`event=${event}, user=${user}`);
Fresher version
// One file:function logEvent({ event, user }) {// one place to evolve}
Easy to miss a site; reviewers can't verify completeness without re-running the same search the committer did, and small changes feel disproportionately risky. The team's verification cost compounds across every scattered site; a change that broke one of the 17 instances ships because the reviewer trusted that the listed files were the complete set.
Every change carries risk of missing a site the agent didn't grep for; reviewers (human or agent) can't verify completeness without re-running the same search, and the agent's verification-surface cost multiplies by the count of touched files. The agent generates an edit that targeted every site it found while missing the one site the search didn't surface.
Consolidating the scattered code into one module can pull together responsibilities that genuinely belong apart, and the cure forces a coordinated migration across every original site. The blast radius of the consolidation touches every caller during the move; teams must align on the rename and import paths before the new module can be reasoned about as the single source.
Consolidation creates a new boundary the agent must respect; previously-independent sites now route through one module that becomes a contention point for unrelated edits. Context-window load on the consolidated module rises because every change along this axis loads its full surface; the agent's retrieval cost on cross-cutting edits also rises along the new seam.
Change cost becomes proportional to the conceptual change, not to how widely the concept was scattered. The team's maintenance cost per axis drops to the work the axis actually requires; the team's enhancement cost also drops because adding a capability to the axis touches one module instead of N, and reviewers verify completeness by reading one file.
A change to the consolidated behavior lands at one file; the agent's token cost per edit drops from N files loaded to one, and the chance of missing a site goes to zero by construction. Verification surface collapses because the file is the surface; the agent reads one module and ships the change without grep-and-iterate.
Pulling every superficially-related edit into one module creates a god-module that becomes the new shotgun target — change cost migrates rather than vanishing, and the new module accumulates accidental complexity as unrelated axes share a file. Readers carry the cognitive load of the whole god-module to reason about any one axis it owns.
Pulling every superficially-related edit into one module creates a god-module the agent now loads as a tangle of unrelated concerns — the smell migrated, not vanished. The agent's reasoning-step cost rises as it disentangles unrelated axes per edit, and context-window load on the god-module exceeds what the agent can hold for any single concern.