In 1967, Melvin Conway sent a paper called "How Do Committees Invent?" to the Harvard Business Review. They rejected it, on the grounds that he had not proved his thesis.1 Datamation published it the following April, Fred Brooks named the idea in The Mythical Man-Month, and the name stuck.
The thesis:
"Organizations which design systems … are constrained to produce designs which are copies of the communication structures of these organizations."
Everyone quotes this. Fewer people read it as what it actually is, which is a cost function.
Four teams — Identity, Billing, Content, Messaging — reliably produce four services with those names. Not because those are the correct technical boundaries. Because those are the boundaries where people were already talking, and drawing a line where a line already exists is free.
The mechanism is bandwidth, not sociology
Software development is an information-coordination problem wearing a technical costume.
When Alice and Bob talk constantly, their components fuse. Coordination is cheap, so they spend it freely. Shared types, shared assumptions, tight coupling — none of it hurts, because a change costs a two-minute conversation.
When Alice's team and Bob's team barely talk, something else happens. The boundary hardens. It acquires an API, a queue, a contract, a ticket workflow, a document that nobody reads and everybody cites.
That formalization is not architecture. It is a communication tax, capitalized into the codebase.
Every interface in your system is a priced conversation. The expensive ones become APIs. The cheap ones become function calls.
Communication topology becomes dependency topology becomes system architecture. One tightly integrated team produces a monolith. Ten autonomous teams produce ten independently deployable services. Neither outcome required an architectural decision.
Both were determined before the first commit.
HBR wanted proof
They eventually got it.
Nagappan, Murphy, and Basili measured organizational structure against defects in Windows Vista2 — number of engineers, edit frequency, depth in the org hierarchy, how many organizations touched a binary. Those metrics predicted failure-prone binaries better than code churn, complexity, coverage, dependencies, or pre-release bug counts. Average recall was 0.84. The org chart was a better bug predictor than the code.
Then MacCormack, Baldwin, and Rusnak ran the matched-pair version3: commercial products versus open source products doing the same job, built by tightly coupled versus loosely coupled organizations. In every pair, the loosely coupled organization produced the more modular design. The gap in propagation cost — how far a change in one component spreads — ran up to a factor of six.
Next, Colfer and Baldwin reviewed 142 empirical studies of the mirroring hypothesis.4 Their finding: prevalent, but not universal.
The "not universal" is the interesting half. Support was weakest in open collaborative projects — the ones with the least org chart to mirror.
That is the tell. Those projects had substitutes for organizational coordination: explicit design rules, version control, public standards, an entire tooling layer that let strangers integrate without a shared manager. When you supply enough coordination technology, mirroring weakens.
Open source was the first large-scale proof that Conway's Law responds to tooling. It is not the last.
Where it turns expensive
The costly failure is not architecture that mirrors the organization. It is architecture that contradicts it.
You want three vertical services: Identity, Orders, Payments. You have five horizontal departments: Frontend, Backend, Database, Infrastructure, QA.
One feature now crosses five organizational boundaries to ship.
The friction does not stay organizational. It gets expressed in the code, every time: handoffs, shared databases nobody owns, APIs that sprawl because two teams negotiated them across a ticket queue, long-lived branches, integration weeks, release trains, coordination meetings that exist purely to simulate the conversation the org chart prevented.
Eventually the architecture surrenders. It always does. The org chart has more stamina than the design document.
Want three autonomous services? Build three teams that can independently own them, instead of a frontend department and a QA department.
Most companies attempt the maneuver cosmetically anyway. They rename the departments, keep the approval chains, and wonder why the microservices all still deploy on Thursday.
It was never really about software
Conway was describing anything built by groups of humans.
A company organized into isolated departments produces a fragmented customer experience — the customer walks the seams. A government split across agencies produces processes shaped like jurisdictions, not like problems. A manufacturer organized around components optimizes components and ships a mediocre product.
The boundaries between the people become visible in the thing. They are always visible in the thing.
Now the input changes
AI increases implementation velocity without repealing Conway's Law.
DORA's 2025 report, drawn from roughly 5,000 practitioners, lands on one word for AI's organizational role: amplifier.7 It magnifies what a high-performing organization already does well and magnifies the dysfunction of one that doesn't. A badly partitioned organization does not get better architecture from coding agents.
It gets bad architecture faster, in more places, with more confidence.
The structural signal is already measurable. GitClear's 2026 analysis of code-change data8 reports refactoring line-moves down 70 percent against 2022, duplicated blocks up 81 percent, and — the one that matters here — cross-file function calls down 35 percent. Cross-file calls are what reuse across a boundary looks like. That number falling means code is increasingly being regenerated rather than shared.
That is Conway's Law running at machine speed inside a single repository.
But there is a second effect pointing the other direction, and it is larger.
Conway's Law derives its force from the cost of coordination between humans. Lower that cost enough and the law does not break — its input changes. Open source demonstrated that once. Agents are doing it again, on a shorter timescale and inside the firm.
One capable developer with agents now holds a surface area that historically required several specialized teams: the service layer, the client SDKs, the infrastructure, the schema, the test suite, the docs. Not because the work got smaller. Because the translation cost between those specialties collapsed toward zero.
When the translation cost is zero, the boundary stops being free. And a boundary that isn't free has to justify itself on technical grounds — which is the only ground it should ever have stood on.
Conway's Law doesn't punish you for having boundaries. It punishes you for inheriting them.
I run this experiment daily. Protocol specifications, a document search platform, SDKs across four languages, the infrastructure under all of it — coordinated by one person because the interfaces between those concerns cost a prompt instead of a sprint.
The architecture I end up with is the architecture I chose, which is a genuinely new experience.
What does not collapse
Communication cost is not the only cost, and this is where the optimistic version of the argument gets sloppy.
Agents collapse translation. They do not collapse authority.
Faros AI's telemetry across more than 10,000 developers9 found individual output up sharply — roughly 21 percent more tasks completed, nearly double the pull requests merged — while organizational delivery metrics stayed flat. The bottleneck moved. It did not disappear. The work now piles up in front of review queues, approval gates, and release coordination, because that is where the remaining human serialization lives.
If shipping requires four approvals, the seams reappear at the approvals. If a schema change requires a change-advisory board, that board is an architectural boundary regardless of how fast the code arrives at it. If two teams both need to say yes, the system will grow an interface between them, and the interface will be shaped exactly like the disagreement.
So the law generalizes rather than dies:
Architecture mirrors the topology of decision rights.
Communication cost used to be the dominant term because talking to another department was genuinely expensive. It isn't anymore. What remains expensive is permission — and permission structures are now the thing being copied into your systems.
What to actually look at
Stop drawing the org chart. It was always a proxy.
Draw the approval graph instead. For one representative feature, count the number of people who can block it and the number who can unblock it. Then look at your architecture and find the seam that corresponds to each one. They will be there.
Then ask the only question that matters now: which of those boundaries would survive if you had to defend it technically, with no reference to who reports to whom?
The ones that survive are your architecture.
The rest are just meetings that learned to compile.