You can read the org chart off the codebase

I used to think autonomous teams were the answer.

The logic was clean. Conway's Law says a system ends up shaped like the communication structure of the organisation that built it. So if a big tangled team produces big tangled software, cut it into small autonomous teams and the software gets cleaner. Give people ownership, remove the handovers, done.

I've since worked inside a lot of companies as a contractor, from marketplaces to fintech to education, and I've watched that recipe run many times. It doesn't do what I thought it did.

What I actually saw

You can read an org chart off a codebase. It's uncanny once you've noticed it.

Two services that do almost the same thing, because two teams each needed it and neither knew the other had built it. An interface nobody dares to touch, because it sits exactly on the line between two departments. A feature that works beautifully right up to the point where it needs data from somewhere else, and then goes strangely quiet.

Every one of those seams is a conversation that didn't happen. The code is just where it became visible.

Autonomy alone doesn't fix that. Autonomous teams with no shared picture don't move in the same direction faster. They move in different directions faster, and the seams show up sooner. I've seen more problems come from a team that was confidently self sufficient about the wrong model of the business than from a team that had to ask.

What actually decides it

The lever isn't autonomy. It's where knowledge lives and who can reach it.

A team that can answer its own questions, without scheduling a meeting with the one person who knows, will build something coherent whether or not you call it autonomous. A team that has to guess will build its own version of the truth, and that version will end up in the product. Every time.

That's the version of Conway's Law I'd write today. Not "the system mirrors the org chart", but "the system mirrors who could reach which knowledge, and how easily". The org chart is only a proxy, and often a bad one.

Why this matters more now, not less

Here's the part I didn't see coming.

For most of my career, writing the code was the slow step. That's no longer true. With AI in the loop, implementation has stopped being the bottleneck in a lot of work, and what's left is the part that was always the hard part anyway: deciding what should exist, where the boundaries go, and whether the thing solves a real problem. Which is to say the engineering.

And the bottleneck moved, exactly one step along. It's now knowledge access.

If you've built anything with AI agents, you already know this without naming it. An agent with no access to the relevant context produces confident, plausible, subtly wrong work. It duplicates something that already exists. It invents its own convention because it couldn't see yours. It solves the ticket and breaks the thing next door.

That's not a new failure mode. That's a walled off team, in miniature, running at speed.

So Conway's Law applies to agents too, and it's the cleanest demonstration of it I've ever had. How you arrange your agents, what each one can see, what they hand to each other and where they're allowed to act, shows up directly in what they produce. Give one agent everything and it loses the plot. Give each a narrow job, a shared source of truth and an explicit handover, and the work holds together.

Design the flow of knowledge and you're designing the architecture, whether the workers are people or processes.

What I'd do instead

Not "split into autonomous teams". Three things:

Put the knowledge where it can be reached. Decisions with their reasons, the shape of the domain, why the odd bit is odd. Somewhere central, current, and readable without asking permission. This is boring, unglamorous work and it pays for itself continuously, for humans and for agents alike.

Make the interfaces explicit. Not just the technical ones. Who owns this? Who decides that? What gets handed over and in what shape? Most of the ugliest code I've seen sat on an ownership boundary nobody had stated out loud.

Then shape the teams for the architecture you want, not the other way round. Conway's Law isn't a problem to be solved. It's a constraint you can use, once you stop fighting it.

Autonomy is a good thing. It just isn't the lever. The lever is what your people, and now your agents, can find out without having to ask.