agentleFS
The-Artificer-of-Ciphers-LLCThe-Artificer-of-Ciphers-LLC/skills-from-the-artificer/conways-law/SKILL.md

conways-law

Skill6 starsChanged 34 days agoMITView on GitHub

Apply Conway's Law when discussing system architecture, team structure, org design, microservices, API ownership, or any situation where communication patterns and software design intersect. Trigger on phrases like "who owns this service?", "our teams keep stepping on each other", "how should we split up this system?", "why does our architecture look like this?", or any question about the relationship between org structure and technical design. Conway's Law is one of the most important—and most underappreciated—forces shaping software systems.

The file

We split this skill into the rules it gives an agent

6 rules. About 0 are common, 6 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈6

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Migrations are org problems, not just tech problems: If you want to decouple a monolith into microservices, you probably also need to …

    line 21
  2. Distinctive:

    When a system feels messy or tightly coupled in the wrong places, look at the org chart.

    line 32
  3. Distinctive:

    When interfaces are poorly designed, ask: did the teams that own them ever really collaborate?

    line 33
  4. Distinctive:

    Before designing the architecture, design the team structure that will build and own it.

    line 36
  5. Distinctive:

    Ask: what communication do we want between these components?

    line 37
  6. Distinctive:

    If we want a cleaner boundary here, what team changes would support that?

    line 46

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Conway's Law

"Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization's communication structure." — Melvin Conway, 1968

The core idea

Conway observed that the architecture of a software system will mirror the communication structure of the team that built it. If you have three teams, you'll probably end up with a three-tier system. If two teams don't talk much, the interface between their systems will be poorly defined and brittle. This isn't a choice — it's an emergent property of how organizations work.

This isn't a bug to fix. It's a force to work with.

Why it matters

  • Org structure drives architecture more than technical decisions do. The seams in your software tend to appear where the seams in your org appear.
  • Communication overhead is the bottleneck. Dense, constant communication produces tightly integrated systems. Sparse communication produces loosely coupled systems. Neither is universally good — it depends on what you're building.
  • Migrations are org problems, not just tech problems. If you want to decouple a monolith into microservices, you probably also need to change how your teams are structured.

The Inverse Conway Maneuver

Once you accept Conway's Law, you can use it intentionally. The Inverse Conway Maneuver is: design your team structure to match the architecture you want.

If you want a clean boundary between billing and user management, put those on separate teams with limited shared meetings. If you want tight integration between two services, put those engineers on the same team. The communication structure will do a lot of the architectural work for you.

How to apply it

Diagnosing architectural problems:

  • When a system feels messy or tightly coupled in the wrong places, look at the org chart. Who talks to whom? The coupling often matches.
  • When interfaces are poorly designed, ask: did the teams that own them ever really collaborate?

Planning new systems:

  • Before designing the architecture, design the team structure that will build and own it.
  • Ask: what communication do we want between these components? Then structure teams to match.

Making the case for org changes:

  • Conway's Law gives technical leaders a principled argument for restructuring teams: "We can't get this architecture without changing how these teams are organized."

Key questions to surface

  1. What does our org chart look like, and how does our system architecture compare?
  2. Where do our inter-team dependencies cause the most friction?
  3. If we want a cleaner boundary here, what team changes would support that?
  4. Are we trying to fight Conway's Law, or work with it?

Team Topologies connection

The book Team Topologies (Skelton & Pais) operationalizes Conway's Law into team patterns:

  • Stream-aligned teams own end-to-end delivery of a product/service
  • Platform teams reduce cognitive load on stream-aligned teams
  • Enabling teams help others upskill
  • Complicated subsystem teams own things requiring deep specialization

These patterns are designed to produce good architectures via good communication structures.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.