Smart Nodes

The best small teams barely have a structure. No Slack, no project software, no org chart worth drawing. Each person is a node, and when one needs something it finds whoever has it and asks. It sounds like it shouldn't work. It does, up to a size, and the size is the whole story.

The easy explanation is that these companies got lucky with good people, and that it won't scale. Both are true. But why it won't scale is about to change, and the same fact that changes it is what makes flattening everyone else quietly dangerous.

Start with why hierarchy exists. Not wisdom at the top: cost. Talking is expensive. Ten people who all coordinate is forty-five relationships. A hundred is five thousand. The cost grows like the square of the headcount, and a person can hold only so many working relationships at once. Past some size, everyone-talks-to-everyone can't be paid for.¹

Hierarchy is the workaround: compression. You talk to your manager, the managers talk to each other, and the cost stops exploding. That's how you run a company of a million people. It's the only way anyone ever has.

The org chart was, in large part, plumbing: a way to move information through a building of people who can't hold each other in their heads. A manager does more than route, of course. Someone has to own outcomes, hire and fire, settle fights, absorb blame, keep people pointed the same way. Those don't vanish. But notice which part scaled. You add management layers in proportion to how many people need coordinating, not to how many fights break out. Routing is what made the pyramid deep. Strip it away and most of the layers lose their reason to exist; the human parts that remain don't need a fresh tier of managers every seven people.²

Now routing is getting cheap.

A model reads the whole codebase. The email. The designs. Ask who knows the most about a subsystem and it tells you, because it has read everything, which no person in the building has. Knowing who has what, and getting it to who needs it: a machine does that now.

The cost doesn't disappear, though. It moves. Someone still has to check whether the model's answer is right, decide which of ten plausible options is worth pursuing, and keep autonomous pieces from duplicating or contradicting each other. Coordination cost becomes verification cost and judgment cost. Hold that thought; it's where this is going.

Because when a workaround gets cheap, you see what it was hiding. Much of management was a temporary way to move information, like the switchboard operators who once connected every call. Nobody thinks they were stupid. They were necessary, right until they weren't. We called the routing "leadership" because the alternative was admitting we'd built a profession out of carrying messages.³

So the layers compress. A few companies are doing it on purpose already: capping the org at a handful of levels, turning managers into player-coaches who still do the work, pushing the ratio of makers to managers far past what used to be sane. The boldest cases are experiments, and some will fail. But the direction isn't in doubt, because the cost that justified the layers is falling.⁴

That's the part everyone watches, and it's the dull part. The sharp part is what a flat network demands of whoever's left.

A mesh where anyone can reach anyone only works if every node can route itself. A hierarchy lets you be a passive node: wait to be told, do your piece, pass it up; the structure thinks for you. Take the structure away and there's no one to wait for. If you can't work out who to talk to, the work stops at you.

This is exactly why these teams work at their size and not above it. They sit under the coordination cliff, and they hire only people who can navigate the graph unaided. That's not proof the mesh scales; it's an instance of the exception. The honest claim is narrower and more interesting: cheap routing moves the cliff out. The size at which everyone-talks-to-everyone collapses gets bigger. How much bigger, nobody knows. But the companies that push it furthest will be the ones whose every node is a computer, not a phone waiting to be connected.⁵

So the virtues invert. Waiting for permission was prudence; now it's a dead end, because no one's job is to grant it. Staying in your lane was tidy; now every handoff stalls at its edge. The information you once hoarded to look important only makes the network dumber: in a tree, controlling what you know is power; in a mesh, what you don't pass on is a cut wire. What replaces all of it is the reverse: deciding without anyone to ratify it, making your own work legible so others can route through you, and judgment most of all, because once the work is nearly free, the scarce thing is knowing which work is worth doing. Anyone can generate ten good options now. The value is entirely in choosing, and choosing is taste, and taste is the one thing the model can't hand you. That's where the migrated cost lands: not on communication anymore, but on the judgment of the people directing the machines.⁶

Which brings us to the catch, and it's the part nobody has solved.

All of this assumes the nodes are already smart: already senior, already holding judgment, already able to route. But people don't start that way. We made them. The junior role, the middle layer, the years spent as an unimportant node in someone else's hierarchy: that was the apprenticeship. It was where judgment came from. You could object that judgment doesn't strictly need hierarchy, that what it needs is exposure, stakes, and feedback, which a mesh might supply some other way. Maybe. But hierarchy is the only machine we've ever had that reliably turns a raw graduate into someone you'd trust to choose, and we're dismantling it before we've built the replacement.

The bet is beautiful if you only ever hire finished people. These companies can; they're small and choosy. But finished people are manufactured somewhere, and the somewhere is the structure we're tearing out. If everyone wants smart nodes and no one will grow them, the supply runs down, and because judgment takes years to form, you won't feel the shortage until it's a decade deep. That's the worst kind of problem: invisible while it's cheap to fix, obvious only once it isn't.⁷

I don't know how it resolves. But the real frontier is the question the whole argument keeps backing into: if hierarchy was the factory for judgment, what replaces the factory? Maybe a model mentors a junior the way a senior once did. Maybe companies design deliberate low-stakes reps (the modern version of the unimportant node) and treat growing people as a moat instead of a cost. Maybe no one does, and the firms that flatten hardest spend the late 2030s discovering they hired away their own future.

Almost no one is asking this, because admiring a flat org chart is easier than asking where its people come from. So here's the one thing to actually do with it: stop optimizing your org for nothing but this quarter's output, and budget, on purpose, for the slow manufacture of judgment. It's the asset that won't show up on next year's balance sheet and the only one that will matter on the one after. The alternative is to keep eating the seed corn and call it efficiency.