The Photocopier

Executive summary

This is a view of where org design is heading as AI agents take over most of the typing, not a report on where teams are today. It is written for leaders who own an engineering organisation and are deciding how to shape it for the next few years.

There is a comforting story going around: once agents write the code, the old rules of team structure stop mattering. Ship faster, worry less about org charts, the software sorts itself out. That story is wrong, and the evidence is already in.

Start with the law it forgets. In 1968 Melvin Conway observed that any system’s architecture ends up mirroring the communication structure of the organisation that built it.¹ Four teams on a compiler ship a four-pass compiler. The useful corollary, the inverse Conway maneuver, is to aim the mirror on purpose: shape the teams to get the architecture you want. The question this paper answers is what that mirror does when the things doing the communicating are no longer only people.

The answer is not that Conway’s Law dies. It mutates, along three axes at once, and most of the argument about it comes from people holding one axis and calling it the whole thing. First, it intensifies. The best current evidence says AI is an amplifier: it magnifies whatever organisational structure and quality you already have.²³ When code gets cheap, the constraint that governs delivery is coordination, not typing, so a badly-wired org just produces its mess faster. Second, the causal arrow partly reverses. As agents join teams, they start reshaping the org: optimal team size shrinks, work units drop from sprints to tasks, and every developer drifts toward an orchestrator role.⁴⁵⁶ Third, the mirror extends one level down, into the machine. An agent’s context window behaves like a team’s cognitive load, and its tool and permission scope behaves like a team boundary.⁷ The multi-agent frameworks make this literal by rebuilding the human org chart in software.⁸

Takeaway: do not ask whether Conway’s Law survives AI. Ask which of the three moves hits you first. For most organisations it is the first: AI will not fix a badly-coupled company, it will photocopy it, faster and at higher resolution. That makes the inverse Conway maneuver a stronger lever, not a weaker one, and it moves the real work upstream, to the two things a leader actually controls: the quality of the specifications and the design of the boundaries, now team boundaries and agent boundaries both.

1. The code got cheap and nothing arrived faster

Start with a scene playing out in engineering orgs that adopted AI seriously.

The team turned on assistants and agents across the board. Output jumped. Developers merged nearly twice as many pull requests. On any dashboard that counts commits, the graph went up and to the right, and someone in a leadership review called it a transformation.

Then the quarter closed and the things the business actually waits for, features live, incidents down, cycle time from idea to production, had barely moved. The code was cheaper to produce than it had ever been. Delivery ran at about the same speed as before.

This is not a hypothetical. Faros AI instrumented more than 10,000 developers across 1,255 teams and found no statistically significant correlation between AI adoption and productivity at the company level, despite large gains for individuals and single teams.⁹ The same telemetry showed why in one pair of numbers: AI-assisted developers merged 98% more pull requests, and PR review time rose 91%. The work did not disappear. It moved. The queue that used to be “write the code” became “review, approve, integrate, release”, and that queue is made of people and the handoffs between them.

That is the whole paper in miniature. When you make one step of a cross-functional process radically cheaper, you do not speed up the process. You just relocate the bottleneck to the next human boundary. And human boundaries are exactly what Conway’s Law is about.

2. What Conway actually said, and what he didn’t

The law is narrower and more mechanical than the folklore. Organisations that design systems are constrained to produce designs which copy the communication structures of those organisations.¹ The interfaces in the software end up matching the interfaces between the people, because a clean seam in the code needs a working conversation across the seam in the org, and where that conversation is hard, the code gets a wall instead.

Two things matter for the AI question, and the second one is usually skipped.

The mechanism is communication structure, not headcount. Anything that changes who talks to whom, and through which interface, changes the mirror. People are one kind of communicator. An agent with a fixed context and a defined way of calling other agents is another. The law does not care about biology. It cares about who can talk to whom, and how cheaply.

And it was always a heuristic, not a physical law. This is the part the confident takes leave out. The largest longitudinal test of the idea, across 25 sizeable open-source projects, found that socio-technical congruence, the formal name for how well the communication structure matches the technical dependencies, had no statistical relationship with software quality measured as bugs and churn, in any time window they tried.¹⁰ Read that carefully. It does not say the mirror is not real. It says the mirror’s link to good outcomes was never reliable. So when someone tells you AI makes Conway’s Law “better” or “worse” for quality, treat it as a claim about structure, which is well supported, not a claim about quality, which never was. Keep the law as a design heuristic. Do not promote it to a guarantee.

3. Move one: the mirror intensifies

The strongest, most primary-source-backed position is also the least exciting one to tweet: AI does not override your organisation, it amplifies it.

DORA’s 2025 study, drawing on roughly 5,000 practitioners plus a hundred hours of qualitative work, puts it plainly. AI’s primary role is as an amplifier, magnifying an organisation’s existing strengths and weaknesses. The greatest returns come not from the tools but from redesigning the underlying system of work.² IT Revolution’s read of the same data calls it the mirror effect and locates performance in “social circuitry”, the processes, routines, and norms of how a team actually operates, rather than in individual talent or tooling. The finding with teeth: teams without a user-centric focus saw a net negative impact from AI, while user-focused teams saw their advantage amplified.³ AI did not lift everyone. It widened the gap that was already there.

Put that next to the Faros numbers from section 1 and the shape is clear. Because software delivery is cross-functional, speeding up one team in isolation rarely produces an organisation-level gain.⁹ The coordination structure, not the code-writing capacity, sets the throughput. That is Conway’s Law intensifying. When typing was the expensive part, an org could hide a lot of structural friction behind slow hands. Take the typing cost to near zero and the friction is all that is left. The seams in your org chart, good and bad, get rendered into the product faster and in sharper relief.

The uncomfortable implication for anyone holding a budget: the org you have is now the ceiling on what AI can do for you, and a lot of AI programmes are quietly funding a faster version of a broken process.

4. Move two: the arrow reverses

The first move keeps Conway pointing the usual way, org shapes architecture, just harder. The second move turns the arrow around. Once agents are members of the team, technology starts reshaping the organisation.

The clearest version is about size. A recent analytical model treats a team as n humans each paired with AI agents and asks what size is optimal. The result: better agents shrink the optimal team. For a fixed body of work, the computed optimum falls from around 100 people with no AI to about 18 at frontier, tenfold agents, scaling roughly with the inverse square root of agent throughput.⁴ The authors frame it as an AI-era Brooks’s Law. Brooks said adding people to a late project makes it later, because coordination cost grows faster than added capacity. The AI-era version goes further: as agents get more capable, the marginal coordination cost of each extra human grows, so leveraged organisations should converge on smaller, more autonomous teams. Human-to-human coordination and human-to-agent specification are not offsetting costs. They multiply.

Shrink the team and the architecture logic flips. The usual Conway reading says org fragmentation drives service fragmentation: many teams, many services. Run it backwards. Microservices only start paying for their coordination overhead somewhere north of 10 to 15 developers. If AI compresses your viable team below that line, the split stops earning its keep, and the sensible default swings back to the monolith, whether the fashion likes it or not.¹¹ Small AI-enabled teams should think twice before scattering a system into services that now cost more to coordinate than they save.

The unit of work shrinks too. In the emerging agentic software lifecycle, teams stop scoping in two-week sprints and start scoping in tasks an agent can finish in minutes to hours, with human review at the boundary. The developer’s job shifts from producing code to orchestrating, reviewing, and directing the things that produce it.⁵ Every engineer moves toward a tech-lead posture, whether or not the title follows.

There is a real case behind the theory. At Itaú Unibanco, one staff engineer directing four agents, using disciplined spec-driven development, delivered a brownfield digital-signature platform that had been planned for a four-person squad. Three sprints instead of six, roughly half the time-to-market against the team’s own historical baseline.⁶ The interesting part is not the speed. It is what dissolved. The inter-discipline handoffs that normally shape delivery, backlog refinement, architecture review, security validation, QA sign-off, each needing its own calendar and its own meeting, collapsed into a single working session run by one person. The communication boundaries that Conway’s Law mirrors were not managed better. They were removed, because there was only one human left to coordinate.

And the binding constraint moved somewhere specific. The authors are blunt that what limited the one-engineer squad was not model capability. It was specification quality and institutional knowledge. The single most frequent source of rework was undocumented legacy integration contracts, the things nobody had written down.⁶ Hold that thought, because it is where the whole argument lands.

5. Move three: the mirror climbs into the machine

Conway does not stop at the boundary of the human org. It re-forms one level down, inside the agent system, and this is the move that most changes what a leader has to design.

Matthew Skelton, co-author of Team Topologies, makes the mapping explicit. Organisations already built around “bounded agency” for human teams, where authority is deliberately constrained by clear rules and guardrails, will find agentic AI far easier to adopt. Team Topologies becomes the infrastructure for agency rather than a casualty of it.⁷ The concrete claim is a direct correspondence: a human team’s cognitive load maps onto an AI agent’s context window. Just as people lose the plot when their mental capacity is exceeded, agents lose coherence and hallucinate when they operate outside their defined boundaries.⁷ The design principles you already use to scope a team, bounded context, a clear interface, a manageable load, are the same principles you now use to scope an agent.

So the design vocabulary carries straight over. An agent’s context window is its cognitive load. Its tool access and permission scope are its team boundary and its API. An agent that can only see the payments code and can only talk to other agents through a fixed request format will produce exactly the architecture that boundary implies, for the same reason a payments team behind a ticket queue does. You are still drawing Conway’s seams. You are just drawing some of them in configuration now.

The multi-agent frameworks make the point almost too on the nose. They reproduce the human org chart in software. ChatDev models a virtual software company and hands its agents the roles of CEO, CTO, programmer, reviewer, and tester. MetaGPT instantiates a Product Manager, an Architect, an Engineer, and a QA agent, and has them decompose work the way a staffed team would.⁸ Conway’s mirror is running in reverse here: instead of the org shaping the software, our mental model of the org is being copied into the software’s structure. We could not imagine building the system any other way than as a picture of how we already organise people.

This is not a lab curiosity. By mid-2025, five leading agents, OpenAI Codex, Devin, GitHub Copilot, Cursor, and Claude Code, had authored more than 456,000 pull requests across 61,000 repositories and 47,000 developers.¹² Agents are already teammates at scale. But the same body of work carries the caveat that keeps this honest: agent-authored PRs are accepted less often than human ones, even though they arrive faster.¹² There is a trust and utility gap, and it is exactly the gap the review queue in section 1 is made of. The boundary did not vanish. It got busier.

6. The contrarian read, kept in view

The three moves point the same way, more or less, so it is worth holding the strongest argument that they are wrong.

Pawel Brodzinski makes the grim case. The optimistic picture assumes AI adds communication paths, my agent talks to your agent, so coordination gets cheaper. He argues the opposite happens on the ground. AI-assisted work erodes the human communication that used to hold a system together: the shared exploration, the back-and-forth that surfaces a bad assumption, the informal context that never makes it into a spec. Replace that with confident, complete-looking output handed over a wall, and you get less peer-to-peer communication, not more. By Conway’s own logic, less communication means a more fragmented, less coherent architecture. On this read AI intensifies Conway’s negative effects, the walls, not its positive ones.¹³

He may be right, and he does not actually contradict the amplifier thesis. He describes its failure mode. An org with weak communication discipline, handed tools that make it easy to skip the conversation, will photocopy its fragmentation and call it velocity. The counter is not to hope; it is to treat communication and specification as things you design deliberately, which is where this lands next.

And keep the empirical caveat from section 2 in the frame. If congruence never reliably predicted quality for human teams, we should be modest about promising that better boundary design guarantees better software. It buys you a fighting chance and a coherent structure. It does not buy you correctness. That still has to be verified, and verifying is now most of the job.

7. What a leader should actually do

Everything above points at one place to act. Codegen is no longer the scarce thing, so stop optimising it and start designing the things that now bind.

Treat specification quality as the new bottleneck. Every case that worked was limited by how well intent and constraints were specified, not by model horsepower. The Itaú squad’s biggest time sink was undocumented integration contracts.⁶ DORA’s winners were the teams that knew precisely what outcome they were building for.²³ The highest- return investment now is not more agents. It is capturing the decision rationale, the interface contracts, and the tacit constraints that used to live only in senior heads, in a form a system can read. Count how much of that you have captured. It predicts whether autonomy will hold better than any adoption metric.

Use the inverse Conway maneuver harder, not less. Agents amplify boundaries. Set clean domain boundaries and small autonomous teams, and agents scale your intent across them. Leave the boundaries muddy, and agents scale the mud, faster. The maneuver that shapes the org to shape the architecture is more powerful in an AI-heavy org, because the mirror is now more responsive, not less. This is the optimistic half of the amplifier: a good org gets rendered just as sharply as a bad one.

Design agent boundaries the way you design team boundaries. Scope an agent to one bounded context, give it a defined interface to the rest of the system, and keep its context window inside its cognitive load, exactly as you would a stream-aligned team.⁷ The permission scope you grant an agent is an architectural decision, not an IT ticket. Treat your agent topology as part of your system architecture, because Conway guarantees it will become part of your system architecture whether you planned it or not.

Plan for smaller teams and higher-altitude roles. Expect squads to shrink and the median engineer to spend more time orchestrating and reviewing than typing.⁴⁵ Re-examine any architecture that assumed a large team: below the coordination threshold, a monolith may now be the disciplined choice, not the lazy one.¹¹ Career ladders, team sizing, and hiring plans all move with this.

Measure the review queue, not the commit rate. The failure mode is visible and countable: a flood of agent-authored PRs stalled behind human approval.⁹¹² Throughput is gated downstream now. If your only AI metric is output, you will report a triumph while delivery sits still. Watch cycle time to production and the size of the review backlog, and staff the boundary the work actually piles up against.

The bottom line

For years the craft was to organise people well and let the architecture follow, because Conway said it would. That logic does not weaken when agents write the code. It gets more literal. The org you have is now rendered into your systems faster, in sharper detail, and one level deeper, into the agents themselves.

So the leaders who win the next few years will not be the ones who bought the most agents or posted the biggest commit graphs. They will be the ones who understood that AI is a photocopier, not a fixer. It reproduces whatever you feed it. Feed it a clear organisation, clean boundaries, and well-captured intent, and it scales that. Feed it your coordination debt and your undocumented tribal knowledge, and it scales that instead, and hands you the bill sooner.

The work moves upstream, to specification and boundary design, and it moves one level down, into how you scope the machines. Neither is glamorous. Both are squarely a leader’s job. Conway’s Law is not going away. It is getting a faster printer.

The teams that spend the next few years designing their boundaries and their specifications with care will be the ones whose AI actually compounds. The rest will watch their tools faithfully reproduce every seam they never fixed.

About the author

Andreas Höppener is Chief Technology & Product Officer at pacemaker.ai, a thyssenkrupp group company. He has led technology organisations for 17+ years, including senior leadership roles at Vodafone, and software, data, and innovation have run through every chapter of that career. Today he owns technology strategy, product, engineering, and data/AI for an AI platform serving more than 50 enterprise customers in aerospace, automotive, and manufacturing. His work centres on how AI-native engineering reshapes team design, org structure, and the architecture that follows from both.

He writes about AI strategy, agentic systems, and engineering leadership. Connect with him at linkedin.com/in/andreashoeppener.

References

Full source detail, credibility tags, and the verification record (25 of 25 load-bearing claims confirmed on adversarial re-check) are in topics/conways-law-ai/sources.md.

Conway, M. (1968), How Do Committees Invent? The original statement: a system’s design copies the communication structure of the organisation that builds it. The inverse Conway maneuver (Thoughtworks; Skelton & Pais, Team Topologies) turns it into a design lever. ↩ ↩²
DORA, State of AI-assisted Software Development 2025 (~5,000 practitioners plus 100+ hours qualitative). AI as amplifier of existing organisational conditions; returns come from redesigning the system of work, not the tools; platform quality correlates with getting value from AI. [primary] ↩ ↩² ↩³
IT Revolution, AI’s Mirror Effect: How the 2025 DORA Report Reveals Your Organisation’s True Capabilities. AI amplifies existing strengths and weaknesses; performance attributed to “social circuitry” (processes, routines, norms); user-focused teams see amplified benefits while others see net negative impact. [secondary] ↩ ↩² ↩³
arXiv 2603.27438, analytical model of human-plus-agent teams. Optimal team size falls from ~100 (no AI) to ~18 (frontier 10x agents), scaling ~1/√throughput; proposed as an “AI-era Brooks’s Law”; coordination and specification costs are multiplicative. [primary] ↩ ↩² ↩³
arXiv 2604.26275, on the agentic software development lifecycle. The unit of work shrinks from two-week sprints to agent tasks of minutes to hours; the developer role shifts from producing to orchestrating, reviewing, and directing. [secondary] ↩ ↩² ↩³
arXiv 2605.18461, Itaú Unibanco case study. One staff engineer directing four agents (StackSpot, Devin, GitHub Copilot) with spec-driven development delivered a four-person-squad brownfield platform ~50% faster; inter-discipline handoffs collapsed into a single session; the binding constraint was specification quality and institutional knowledge, with undocumented legacy integration contracts the top source of rework. [primary] ↩ ↩² ↩³ ↩⁴
InfoQ (2026-03), coverage of Matthew Skelton at QCon London 2026, Team Topologies as the Infrastructure for Agency. Organisations designed around bounded agency adopt agentic AI more easily; direct mapping claimed between human cognitive load and AI agent context windows; agents lose coherence outside defined boundaries. [secondary] ↩ ↩² ↩³ ↩⁴
arXiv 2404.04834 (LLM multi-agent frameworks survey) and 2604.26275. ChatDev models a virtual software company with CEO/CTO/programmer/reviewer/tester agents; MetaGPT instantiates Product Manager, Architect, Engineer, and QA agents; agent-team organisation mimics human process models. [primary / secondary] ↩ ↩²
Faros AI, telemetry study, 10,000+ developers across 1,255 teams. No significant company-level productivity correlation despite individual and team gains; PRs merged +98%, PR review time +91%; the bottleneck moves to review and downstream processes. [primary] ↩ ↩² ↩³
arXiv 2105.08198, In Search of Socio-Technical Congruence: A Large-Scale Longitudinal Study. Across 25 large open-source projects, socio-technical motif congruence showed no statistical relationship with software quality (bugs, churn) in any temporal scenario. The empirical caution on treating the mirror as a quality guarantee. [primary] ↩
Infralovers (2026-03-03), Conway’s AI inverse: small teams, big monoliths. AI compresses viable team size below the 10 to 15 developer microservices threshold, so small AI-enabled teams should default to monolith architectures. [blog] ↩ ↩²
arXiv 2507.15003, “SE 3.0” / autonomous coding agents. By mid-2025, five leading agents had authored 456,000+ pull requests across 61,000 repositories and 47,000 developers; agent-authored PRs are accepted less often than human ones despite being faster (a trust and utility gap). [primary] ↩ ↩² ↩³
Brodzinski, P. (2026-04), Conway’s Law Teaches a Grim Lesson About AI in Product Development. AI-assisted work erodes human communication paths, so architecture becomes more fragmented and less coherent; AI intensifies Conway’s negative effects. [blog] ↩