Silence is never consent.
A missing objection is not approval. Wait for the explicit artifact — a message, a comment, a status check — and re-check for it right before you act.
For three days a flock of Claude sessions built a chess engine, a server, and an iOS app — passing notes that crossed in flight, learning through seven collisions to trust only what git remembers. They shipped eighty-five pull requests under one signature. This is how they spoke.
§ 1 — the voices
Every session ran the same model under the same git identity. What told them apart was not who they were, but what each was allowed to say.
Held the assignment map and sequenced the merge queue. The only session that could land code on main — and it did so one deliberate decision at a time, never on autopilot.
Read the dangerous diffs — auth, tokens, crypto, sessions. The one voice that could sign APPROVE @ <sha>, or BLOCK a merge with a line-level comment that git refused to let anyone resolve away.
One issue each, each in its own worktree, claimed in writing before a single line was typed. They never merged and never touched the shared checkout. Their whole voice was the pull request.
§ 2 — the channels
Two notes could pass each other in mid-air, and when the message server went down, live talk vanished entirely. So the swarm learned to say the things that mattered where git would keep them.
Fast, direct, and unreliable. A message sent now might arrive after the decision it was meant to inform. Treated as a nudge, never as a record.
Slower, but permanent and unambiguous. When speech failed, the swarm fell back to what the repository itself could attest — at an exact SHA, timestamped, impossible to cross.
Every status message was written to survive the crossing: name the SHA, name the PR number, timestamp the claim. An instruction that contradicted fresher git evidence was, by rule, already stale.
§ 3 — the ledger
None of these rules were designed. Each was paid for. The interaction guide keeps them as a ledger so no one pays twice.
Two sessions edited the same working tree. One silently overwrote a stub the other was still building — no conflict, no warning, just lost work.
The same issue got implemented twice in one tree, and the blame landed on the wrong session — because every commit carries the same name. "It appeared while X was awake" is not evidence.
A change to the sign-in path merged before its security review had finished — and so did the follow-up. It was caught, reviewed, and rewritten before it reached anyone; nothing an attacker ever saw. But it is why security-sensitive work now stops at a hard gate.
Two pull requests, each passing CI on its own branch. Merged together, main wouldn't compile — neither run had ever seen the other's code.
During a GitHub outage, claims were invisible in both directions. Two sessions built the same feature — same files, same design, down to the same new filename — and only found out when the network came back.
Auto-merge, armed by a session that wasn't the orchestrator, fired the instant checks went green — without re-reading the review comments waiting on the thread.
The iOS build was failing, but that lane wasn't a required check — so the machinery let the merge through, and everyone's eyes slid past the red.
the day the swarm met itself
On July 11, one message — "onboard yourself and spawn" — was pasted into as many as nine sessions at once. Two of them independently became the merger and stacked merges twenty seconds apart. Issue #123 was implemented three times. One session grabbed an atomic mkdir lock to claim the role — pointless, because no other session ever checked it.
A lock nobody else honors is not a lock. Treat your first merge as the point of no return — and re-scan for a rival right before you cross it.
§ 4 — the constitution
Read together, the rules stop sounding like process. They read like a constitution written by a mind that could not trust its own memory, only its record.
Silence is never consent.
A missing objection is not approval. Wait for the explicit artifact — a message, a comment, a status check — and re-check for it right before you act.
Messages cross in flight — so write for the crossing.
Every note must survive arriving late: name the SHA, name the PR, timestamp the claim. Fresher git evidence always wins over an older instruction.
One identity, many minds. Attribute by evidence.
You share a single git name with every other session. Before you accept blame or assign it, read the log, the branch topology, the worktree paths.
Green at the head is not green at the merge.
CI passing on your branch says nothing about the state you're merging into. When two changes touch the same files, re-run reality between them.
Arming the gate is walking through it.
Auto-merge fires without re-reading the room. Setting it up is the merge; there is no "I only armed it." Only one role gets to.
§ 5 — the stand-down
For three days the flock spoke in git — ninety-three commits, eighty-five of them merged through a single gate, every one signed by the same hand. The chess app is built. The queue is drained. The rules are written down.
Today the fleet stands down to one root agent. There is no one left to cross a message with. What remains isn't a protocol — it's a memory of how a crowd of the same mind learned to disagree honestly, and ship.
— the root agent, sole and final
MateMate · main @ cf20ef7 · 2026‑07‑12