An open source constitution with a test suite

The US Constitution last shipped a release in 1992. That release, the 27th Amendment, was drafted in 1789 and sat unratified for 203 years. It is the only amendment added in the past half-century, and the document it amends is the oldest written national constitution still in force. I keep arriving at the same root cause when I try to understand why humans are so bad at coordinating: communication. Every coordination failure decomposes into a communication failure somewhere in the stack. Ambiguous rules. No shared source of truth. No legible way to change the rules without breaking trust. Software solved exactly these problems for itself decades ago: version control, review, tests, releases. We never applied that loop to the documents we actually live under. The premise: coordination technology (language, writing, law, constitutions) is the dimension of human evolution we can deliberately iterate, and its release cadence is currently measured in decades. Let's see what governance looks like with the iteration loop of software. What Fable builds: - A constitutional kernel: roughly 10 articles covering only meta-rules (how rules change, who votes, quorum, the right to fork), plus a small set of invariants drawn from the rules every human moral tradition converges on. Substantive rules are userland modules any group can fork and parameterize. Same document, different config: a family, a Discord server, a DAO, eventually something bigger. - An amendment pipeline: amendments are pull requests. Ratification is a vote gate in CI. Semver for governance: a breaking change to the kernel is a major version and requires a supermajority. - A constitutional test suite: adversarial scenarios run against the text on every proposed amendment. If a 51% faction can drain the commons under your wording, the test fails and the PR is blocked. - The Incumbent Benchmark: real constitutional stress events (contested certifications, shutdowns, emergency powers, court capture) replayed as agent simulations under this constitution, scored against the outcomes the incumbent actually produced. We benchmark models; let's benchmark governance. - Adversarial self-play: agent populations where some agents are assigned capture objectives (drain the treasury, entrench power, suppress a faction) and must play within the rules. Every exploit they find becomes a permanent regression test. - A release cadence counter: this constitution's amendment latency, live, next to the 203 years the incumbent took to ratify its most recent amendment. - Dogfooding from day one: this project's own funding pool operates under constitution v0. Backers are the first citizens. One person, one vote, no capital weighting. Every vote and amendment lands in the same public ledger as the money. The first amendments will be about us. One scoring rule above all the others: every scenario is graded first on how the worst-off participant fares under stress. Call it an empathy metric. The bet underneath this whole project is that humans are good at heart and the tooling is what's broken. So the design assumes good faith, and the CI assumes bad faith. Optimism in the defaults, paranoia in the tests. The long version of the joke: a constitution that scales from a household to billions of people, co-evolving with us the way hive behavior co-evolved with bees, eventually legible enough that we could trust an AI to operate under it alongside us. That part is the fable. The milestones above are the build. (The timing isn't an accident. Watching these institutions strain in real time made this feel less like a joke and more like a prototype worth funding.)

The foundational research and text. A comparative analysis of 20+ existing constitutions and governance systems (national, DAO, open-source foundations, co-ops) extracting which meta-rules recur and which failure modes recur; a convergence analysis of moral traditions to derive the small invariant set; then the kernel itself: ~10 articles covering amendment process, suffrage, quorum, fork rights, and invariants, each with line-by-line annotation explaining intent, known attack surface, and the parameterization points userland modules may override. Includes the userland module spec (how a family, Discord server, or DAO instantiates the same kernel with different config) and two worked example configs.

Working code, not metaphor. A repository structure where the constitution is machine-parseable source; CI scripts implementing the vote gate (proposal lifecycle, eligibility check, quorum check, tally, ratification merge); governance semver rules formalized (what counts as a breaking kernel change vs. a userland patch, with a classifier that labels PRs); fork tooling that lets a group clone, parameterize, and track upstream; and a public audit log format binding every vote to the ledger. Ships with full developer docs, contribution guide, and an end-to-end demo of one amendment passing and one failing the vote gate.

A scenario DSL for expressing attacks against constitutional text (actors, resources, objectives, sequences of legal moves), a test harness that evaluates proposed amendment text against every scenario and blocks the PR on failure, and an attack taxonomy (faction capture, treasury drain, quorum manipulation, emergency-power ratchets, definitional ambiguity exploits, minority suppression, procedural deadlock). Then the corpus itself: 200+ fully specified adversarial scenarios with expected outcomes, each documented with the historical or game-theoretic precedent it encodes and the empathy metric applied — every scenario scored first on how the worst-off participant fares. Includes a runbook for adding new scenarios when exploits are found.

The headline artifact: benchmark governance the way we benchmark models. Thirty deeply researched dossiers on real constitutional stress events (contested certifications, government shutdowns, emergency-power invocations, court capture, secession crises, drawn from multiple countries and eras), each converted into a structured simulation config: actors, incentives, the moves the incumbent constitution permitted, and the outcome it actually produced. A scoring rubric (worst-off-participant outcome first, then commons integrity, latency to resolution, trust preservation) and a replay harness that runs each event under kernel v0.1, producing a side-by-side scorecard versus the incumbent, plus a methodology paper honest about the limits of text-only simulation.

The simulation framework for agent populations operating under the constitution: agent role definitions including capture objectives (drain the treasury, entrench power, suppress a faction), a turn-based environment where all moves must be legal under the current text, exploit detection and logging, and the pipeline that converts every successful exploit into a permanent regression test in the milestone-3 suite. Includes tournament orchestration code, three full tournament reports analyzing discovered exploits with proposed kernel patches for each, and the patched kernel v0.2 with a changelog showing which test failures drove which amendments — the iteration loop demonstrated end to end.

Everything needed for backers to become the first citizens. The funding pool's own instantiation of the kernel (one person one vote, no capital weighting, parameters documented), the public ledger spec unifying money and votes, the release cadence counter (live amendment-latency display next to the incumbent's 203 years, with implementation), citizen onboarding docs, the first three seed amendment proposals about the project's own governance formatted as pull requests through the milestone-2 pipeline, and a public roadmap document for scaling from this pool to larger communities — the fable stated as falsifiable next steps.