The demo is tomorrow, so you open six agent sessions in parallel. An hour later: six branches touching the same files and an afternoon of conflicts. Your agents are split into “frontend,” “backend,” “database,” and every feature needs all three. Six months in, the codebase has tripled and nobody ever deleted anything.

Three laws from the 1960s and 70s describe exactly this: coordination cost, organizational shape, and drift.

More agents won’t save you (Brooks)

In 1975, Fred Brooks published The Mythical Man-Month, drawn from OS/360 at IBM: adding manpower to a late software project makes it later. Three mechanisms: ramp-up, tasks that can’t be partitioned, and communication cost growing as n(n−1)/2.

“Agents don’t need onboarding” is half true. They start instantly, but with no context — whatever isn’t written down, each one guesses differently. Indivisible tasks stay indivisible. Six agents on one module is fifteen pairs of interference, and you are the channel between them. Your attention doesn’t parallelize.

What actually parallelizes:

  • Fix the interfaces first, then put agents on either side.
  • Disjoint domains only. Tasks touching the same files are sequential.
  • A written source of truth: spec and decisions in shared artifacts.
  • Cap active agents at your review capacity.

Behind schedule? Cut scope, don’t multiply agents.

Your agent split is your architecture (Conway)

In 1968, Melvin Conway’s “How Do Committees Invent?” (Datamation) observed that organizations design systems that copy their communication structures. The industry turned it into the “Inverse Conway Maneuver”: organize for the architecture you want.

A multi-agent system is an organization. Split agents by technical layer, get a layered system with every domain scattered. One agent touching everything, get everything touching everything. The good news: re-splitting agents is cheap.

  • Specs per domain — with an approach like OpenSpec, every task is attached to a domain’s spec.
  • Modules or crates per domain, with enforced public interfaces.
  • A named owner who approves boundary changes; agents work inside.

Symptoms of a bad split: features that touch every module, concepts redefined under different names, merge conflicts always on the same “crossroads” files. Fix the split; the code will follow.

Install the brakes (Lehman)

From the 1970s, Meir “Manny” Lehman studied real systems at IBM. Two laws matter here. Continuing change: a system in use must keep adapting. Increasing complexity: complexity grows unless work is done to reduce it.

Agents accelerate change, so they accelerate drift. They add more than they remove, duplicate what they can’t find in context, and work around instead of refactoring. Each task is reasonable; the sum isn’t.

“Unless work is done” means planned work:

  • Recurring simplification by a simplifier agent, under existing tests.
  • Mechanical thresholds in CI: ESLint complexity, max-lines-per-function; Clippy cognitive_complexity, too_many_lines; knip for unused code; dependency-cruiser or crates per domain for boundaries.
  • Track the trend: count of threshold suppressions, file count, module size.
  • A simplification budget: a fixed share of agent work, not “when we have time.”

Takeaways

  • Brooks (1975): the bottleneck is coordination and your review capacity, not generation speed. Parallelize across disjoint domains, after fixing interfaces.
  • Conway (1968): split agents and ownership by business domain — specs (OpenSpec), crates or modules, a named owner.
  • Lehman (1970s): complexity grows unless reduced; schedule simplification and gate it in CI.
  • Watch the exceptions: accumulating suppressions are the first sign of drift.

Share this post

← All posts