One module changes for many unrelated reasons — tax law updates, UI changes, API shape drift. Every commit touches concerns the committer didn't intend; reviewers carrying the cognitive load of the whole module verify changes outside their expertise, paying comprehension cost on every visit, and team merges collide on lines that were never about the same thing.
Reading the module, the agent constantly switches between conceptually unrelated regions (tax logic, UI logic, API logic); every cross-axis edit pays context-window load for all of them. The agent's reasoning about any single concern competes for working context with the others; chained edits accumulate without proportional information gain.
Each module changes for one reason — separation of concerns in practice, with changes clustering around a single axis of variation. The reader sees the axis in the module name; the team aligns ownership with the axis, and every cross-cutting concern lives in its own module with its own commit history.
Each module varies along one axis; the agent reads the axis name from the module and loads only the slice of code relevant to the current edit, keeping context-window load minimal. The agent's per-edit reasoning step count drops because the relevant context fits in one read; cross-axis interference disappears.
Smellier version
function checkout(cart) {const tax = computeTax(cart, jurisdiction); // tax churnconst html = renderInvoice(cart, tax); // UI churnreturn postToGateway(html); // API churn}
Fresher version
function priced(cart) { return { ...cart, tax: computeTax(cart) }; }function rendered(cart) { return renderInvoice(cart); }function sent(html) { return postToGateway(html); }
Every team's churn lands in the same file; merges become contentious; testing one concern requires understanding all of them — high cognitive load for every reader. The team's verification cost compounds across the merged concerns; a change that broke one axis ships because the reviewer was focused on the axis the commit message named.
Any single conceptual change touches code that also implements unrelated concerns; the agent pays verification-surface cost across every axis on every edit. The agent generates an edit consistent with the axis it focused on while breaking an invariant on another axis — a partial fix that targeted tests don't cover.
Splitting the module forces a coordination surface — two files where there used to be one, plus a shared seam that any cross-cutting change must touch in both. The blast radius of a cross-cutting change rises along the seam; coordination cost across the new module boundary must justify the per-axis isolation the split provides.
Splitting introduces a seam between modules; cross-cutting changes now require the agent to load and synchronize edits across both, inflating context-window load for those specific cases. The agent's retrieval cost on cross-cutting concerns rises; the trade is worth it only when single-axis changes dominate the workload across the module.
Owners and reviewers are obvious; tests are focused; teams can move in parallel without colliding. The team's maintenance cost per axis drops to the work that axis actually requires, rather than the work plus the verification surface of every other concern in the original module. New features ship without cross-team coordination.
One axis of change per module means the agent loads exactly the slice of code relevant to the request — minimal context-window load — and concurrent edits along different axes don't interfere. The agent's completeness-check cost contracts to the touched axis, and cross-axis invariants surface as compile errors at the module boundary rather than as runtime drift.
Aggressive splitting on every change axis fragments cohesion — a class that genuinely belongs together gets shredded into pieces too small to express the original concept, adding accidental complexity without payoff. Each new module is another file in the navigation surface; readers chase concepts across boundaries the original cohesion didn't justify.
Splitting on every minor distinction creates a fan-out of tiny modules; the agent pays retrieval cost for every file it loads to reason about any meaningful behavior — assembly cost exceeds the comprehension gain. The token cost of cross-file navigation overwhelms the per-axis isolation the split was meant to buy.