01Anyone can make anything now
The cost of making something collapsed. Anyone can describe what they want and watch a working draft appear: a script, a dashboard, an app, a model. The roles blurred overnight. Product managers ship code. Designers wire up prototypes. Every team is running a hackathon, and everyone is being asked to build.
This is real, and it is good. The barrier between an idea and a first version is mostly gone. But a first version is exactly where the easy part ends.
02Making got easy. Shipping did not.
Generating code is cheap. Running it, trusting it, and maintaining it is as hard as it ever was. A hackathon produces a demo, not a product. In the best case you are left with dead code nobody understands. In the worst case, the prototype someone shipped over the weekend leaks your customers' data.
The complexity did not go away. It moved downstream, onto whoever now has to operate ten times more software, written ten times faster, by people who never had to run it in production before.
03Taste is the scarce input
When anyone can generate a version, the version stops being worth much. What is scarce is knowing which version is right: the judgment to find the one good answer in a haystack of plausible ones, the craft to refine it, the care to make it specific to this user, this context, this problem.
That is taste, and it does not come from the model. It is curation, personalization, and the thousand small decisions that separate something generic from something made on purpose.
When output is infinite, taste is the only part that isn't a commodity.
04The new bottleneck is coordination
Speed is a team problem too. Everything one person ships is something everyone else now has to find, read, reconcile, and stay current on. Produce ten times more and you create ten times more to coordinate: the docs, the threads, the status meetings, the re-explaining.
Coordination cost grows with output, and at this speed it swallows the gain. So it has to go to zero. The only thing that can drive it there is the same thing that created the output.
Agents carry the coordination, so the humans don't.
05Structure, not hierarchy
A team of people each building ten times faster does not need more managers. It needs to stay coherent. The same tools, the same context, one source of truth. Otherwise ten people drift in ten directions and the speed itself becomes the problem.
The old answer was hierarchy: layers of people routing information and approving work. That was a workaround for slow, scarce creation, and it does not fit a team where everyone is a builder. The answer now is structure you can share. Distributed, persistent, and reviewable, so judgment compounds across the team instead of fragmenting.
A software team already learned this with Git: one shared source of truth, every change visible, every contribution reviewable. That is what lets small teams ship enormous amounts of code without falling apart. Working with agents, every team needs the same thing, for everything they make.
Picture what that produces: a flat, small team where everyone is amplified by agents that share context the moment it changes. Output flows between agents that keep each other current. People work the two ends that matter, choosing what to do and judging what comes back, while the coordination runs itself.
06A rig holds it together
A rig keeps all of this in one place. It is your process, your data, your standards, and your tools, written down in plain language a model can act on and a teammate can read.
- Structure
- A folder with a known shape, not a sprawl of scripts nobody can follow.
- Persistence
- Notes, decisions, and context live somewhere durable and survive every machine they touch.
- Craft
- Your taste, encoded once, applied to everything the agent produces.
- Collaboration
- Published or synced, one person's rig becomes the whole team's starting point.
- Composition
- Rigs nest into the shape of your org. Mount one inside another and context flows between them, live.
- Trust
- Plain text you can read, so you see exactly what a rig does and review a change before you run it.
Share a rig and it stops being yours alone. Synced over the relay, rigs become the information highway between everyone on a team and their agents: context and output moving across all of them at once, whatever harness each person runs.
You stop shipping the output and start shipping the way you work.