The ground has shifted
For fifty years our tools assumed a single human author typing into files. Branches, merges, diffs, locks, code review — every one of them encodes that assumption: one mind, one hand, one edit at a time, and a careful ritual to reconcile whenever two hands collide.
That world is gone. Cognition is now cheap, abundant, and parallel. We no longer have one author; we have a fleet. And our tools fight this at every turn — they let collisions happen and then make us resolve them by hand, after the fact, when the damage is already in the tree.
We can do better. We can design so that collisions cannot occur, and so that we spend intelligence only where it is actually needed.
What we hold
Conflict-freedom should be compiled, not hoped for. Whether two pieces of parallel work can collide is a question you can answer before a single line is written — if the work is described as contracts with explicit boundaries. A collision should be a compile error caught by a cheap checker, never a surprise discovered at merge by an expensive one.
Intelligence should be spent where decisions are made, not where they are carried out. Most of what we call "coding" is not thinking — it is the mechanical instantiation of a decision already made. The rare, hard, genuinely novel choices deserve the most powerful minds we have. Everything downstream deserves the cheapest thing that works, or no mind at all.
Eight principles
Prevent, don't reconcile. Decide the division of labor and the boundaries before work begins. A conflict avoided at plan time is worth a hundred resolved at merge time.
Compile the plan. A decomposition is conflict-free if its parts share no mutable ground and their contracts agree at every seam — and that is checkable mechanically, in milliseconds, for free. Prove it before you spend.
Grant capabilities; never forbid. Hand each worker only what it may touch. A rule can be disobeyed; an absent capability cannot. Safety by construction beats safety by instruction — because instruction, given to a probabilistic mind, is only a wish.
Add freely; mutate rarely. New work is additive, and additive work does not collide. Changing what already exists is the exception — rationed, serialized, bound by an explicit promise. Shrink the contested ground to the few things actually being changed.
Ration cognition. Let the strongest model decide the contract; let cheap executors realize it; let deterministic tools do what needs no judgment at all. Drive the cost of every leaf downward until only the irreducible decisions remain expensive.
Verify with machines, not minds. Every piece of work carries its own test — a gate a machine can check without thinking. Never spend a large mind to confirm the output of a small one. Let truth be cheap and automatic.
Coordinate by reading, not talking. Workers should not converse; conversation is expensive and forces each to reason about the others. Let them leave structured traces and read shared state. Awareness should cost a lookup, not a dialogue.
Make every task idempotent. A unit of work is a pure function of its inputs, repeatable to the same result. Then failure is merely retry, and trust is merely running it twice. Reliability in the whole, built from the unreliable in the part.
The contract is the program
We stop treating code as the source of truth and the contract as an afterthought. We invert it. The contract — the promise at the seam between two pieces of work — is the artifact that matters; the code is only its realization. When two minds meet at a boundary, that boundary is a promise written down, not a guess each made alone. Get the promises right and the code becomes interchangeable, regenerable, cheap.
On lineage
None of the pieces here were conjured from nothing. Capabilities, content-addressing, commutative change, idempotency, shared state over messaging — each has a long lineage in the history of computing. The claim is not invention. The claim is that this era demands they be assembled, and pointed at a new target: not one human writing software, but many minds — silicon and human together — building one thing at once, without colliding.
The bottleneck is no longer writing code. It is saying, precisely and once, what we want — in a form that many minds can execute in parallel without stepping on each other.
Build for that.