Connect America: How Article VII Bootstraps a Republic

Starting question

What exactly must happen for a written Constitution to become a working system, and can that transition be reproduced in executable code?

The complete research foundation for this public adaptation is available on Zenodo: Code Constitution.

The America that appeared on the map

In our Death Stranding playthrough, America first existed as a promise on a map. Its outline was familiar, city names survived, people lived inside shelters, and cargo moved between separate points. The shared system emerged only as Sam advanced. We reached another station, restored contact, completed the work, obtained consent to connect, and one isolated area became part of the UCA (United Cities of America). The map changed color, the network expanded, and the familiar outline of a country gradually filled with working connections.

That experience mattered more than the plot formula about rebuilding America. The game made the distinction between territory, name, and system perceptible. Territory could remain in place. A name could survive a catastrophe. A system required people, nodes, authority, and infrastructure to be connected again. Each new connection confirmed that a shared order existed here, among those who had agreed to enter it and had gained access to its capabilities.

Within that experience, a UCA ID felt like a small material sign of a large architecture. A card, record, or interface status declared membership in an order that was still being assembled. Behind the sign stood a network; behind the network stood a sequence of local acts of consent. America came online node by node.

Article VII of the United States Constitution performs a similar opening movement. It stands at the very end of the original text and answers the question with which a software system usually begins its life: upon what event does this artifact acquire authority, and for whom does it begin to operate?

Seven articles, seven builds

This publication opens a cycle of seven articles, one for each article of the original United States Constitution. Its research foundation is Code Constitution, which transformed a political constitution into a set of architectural questions: who establishes the order, where authority originates, how derivative rules are adopted, what provides continuity, and how the system changes itself. The new cycle reverses that operation. We take each article of the United States Constitution, build a software model from it, and test whether the model preserves the original structure.

The publication order follows the logic of assembly. Article VII supplies the point of activation, so the series begins at the end of the document. It then moves from the foundation of the system towards its operating components.

This route allows subsystems to be added gradually. In the first publication, Congress does not yet exist as an operating pipeline, the President does not yet exist as an executive circuit, and the judiciary does not yet exist as a dispute-resolution mechanism. We have a document, thirteen potential participants, and a condition under which the new architecture is deemed established. That is enough for the initial bootstrap. An operating republic will require the rest of the cycle.

The final article as the entry point

Article VII consists of one sentence. It provides that ratification by the conventions of nine states is sufficient to establish the Constitution among the states that ratify it:

“The Ratification of the Conventions of nine States, shall be sufficient for the Establishment of this Constitution between the States so ratifying the Same.”

Read as software, that sentence contains four independent parameters:

1. Event: ratification.
2. Permitted source of the event: a state convention.
3. Threshold: nine unique states.
4. Scope of the result: the states that ratified this version.

Every parameter changes the behavior of the model. An ordinary vote by a state legislature does not use the specified channel. A repeated message from one state does not increase the number of participants. Eight ratifications leave the proposal waiting. The ninth changes the status of the document. The new system operates among the consenting participants, and subsequent ratifications enlarge its scope.

flowchart TB
    A["Text adopted by the Convention of 1787"] --> B["States hold ratifying conventions"]
    B --> C{"Are there nine ratifications?"}
    C -- "Not yet" --> D["The proposal waits"]
    C -- "Yes" --> E["The Constitution is established among the ratifying states"]
    E --> F["Transition to the federal runtime begins"]

The historical sequence emphasizes the difference between establishment and practical activation. New Hampshire became the ninth state to ratify on 21 June 1788. The new federal government began operating on 4 March 1789. The interval required elections, the assembly of institutions, the creation of administrative procedures, and the translation of written architecture into institutional execution. The United States National Archives describes this sequence.

The distinction is familiar in software. An approved specification is not yet a deployed service. A signed release does not by itself mean that the infrastructure is ready. A successful schema migration does not guarantee that users have received a working interface. Article VII precisely marks the moment of establishment; history supplies the subsequent stages of transition.

Four states of one bootstrap

The first version of the model distinguishes four states that the word “adopted” can easily collapse into one.

This table expresses the central result of the first publication. Article VII implements the transition from artifact to recognized foundation of the system. Deployment and operation belong to the next layer. That boundary makes the model useful: the function receives exactly the responsibility that its source can support.

stateDiagram-v2
    [*] --> Proposed
    state "Constitution proposed" as Proposed
    state "Waiting for threshold" as Waiting
    state "Established among participants" as Established
    state "Transition to institutions" as Transition
    state "Federal runtime" as Runtime

    Proposed --> Waiting: 1–8 ratifications
    Waiting --> Established: 9th ratification
    Established --> Established: another state ratifies
    Established --> Transition: activation is organized
    Transition --> Runtime: institutions begin operating

A minimal executable model

A metaphor gains weight when it survives conversion into behavior. Each publication in the cycle therefore contains an executable prototype. The first model uses ordinary JavaScript and standard language features only. It represents Article VII as a pure function: state decisions enter; a constitutional bootstrap state emerges.

export const FOUNDING_STATES = Object.freeze([
	'Delaware',
	'Pennsylvania',
	'New Jersey',
	'Georgia',
	'Connecticut',
	'Massachusetts',
	'Maryland',
	'South Carolina',
	'New Hampshire',
	'Virginia',
	'New York',
	'North Carolina',
	'Rhode Island',
]);

export const ARTICLE_VII_THRESHOLD = 9;

export function evaluateArticleVII(decisions) {
	const knownStates = new Set(FOUNDING_STATES);
	const ratifyingStates = new Set();

	for (const decision of decisions) {
		if (!knownStates.has(decision.state)) {
			throw new TypeError(`Unknown founding state: ${decision.state}`);
		}

		if (decision.channel === 'state-convention' && decision.approved === true) {
			ratifyingStates.add(decision.state);
		}
	}

	const ratifiedBy = Object.freeze([...ratifyingStates]);
	const established = ratifiedBy.length >= ARTICLE_VII_THRESHOLD;

	return Object.freeze({
		artifact: 'Constitution of 1787',
		phase: established ? 'established' : 'proposed',
		ratifiedBy,
		establishedBetween: Object.freeze(established ? [...ratifiedBy] : []),
		runtime: 'pending-implementation',
	});
}

The code preserves four properties of the article. Set guarantees unique states. state-convention records the permitted source of ratification. The ARTICLE_VII_THRESHOLD constant makes the threshold explicit. establishedBetween binds the result to the participants that accepted the document. runtime is an addition made by our engineering model and candidly leaves the system in transition.

At this point, the software form begins to pose useful interpretive questions. Should an invalid vote trigger an error, or should it be preserved as an event that does not affect the result? Does the order of ratification carry normative weight, or does it serve only as a historical log? How is the authenticity of a convention’s decision proved? Which structure handles later accessions? Article VII provides the behavioural foundation; implementation forces us to enumerate what lies beyond it.

WARDEN: where the analogy is tested

The cycle introduces a separate circuit called WARDEN. It belongs to our laboratory and tests the quality of the transformation from Constitution to software. Its position deliberately lies outside the federation being modelled. The Article III judiciary will be a participant in the system itself: it hears actual disputes, determines the applicable rule, and grants a remedy. WARDEN acts earlier and more coldly. It compares text, declared invariants, code, and test scenarios.

flowchart TB
    A["Article VII: normative text"] --> C["Model invariants"]
    B["JavaScript: executable behavior"] --> D["WARDEN"]
    C --> D
    D --> E{"Did every scenario pass?"}
    E -- "Yes" --> F["The model is admitted to the series"]
    E -- "No" --> G["Return to code or interpretation"]

For Article VII, WARDEN’s first battery contains four tests:

import test from 'node:test';
import assert from 'node:assert/strict';

import { FOUNDING_STATES, evaluateArticleVII } from './article-vii.js';

const convention = (state) => ({
	state,
	channel: 'state-convention',
	approved: true,
});

const eightConventionRatifications = FOUNDING_STATES.slice(0, 8).map((state) => convention(state));

const nineConventionRatifications = FOUNDING_STATES.slice(0, 9).map((state) => convention(state));

const eventsWithDuplicateAndLegislatureVote = [
	...eightConventionRatifications,
	convention(FOUNDING_STATES[0]),
	{
		state: FOUNDING_STATES[8],
		channel: 'state-legislature',
		approved: true,
	},
];

test('eight conventions leave the proposal waiting', () => {
	const result = evaluateArticleVII(eightConventionRatifications);
	assert.equal(result.phase, 'proposed');
	assert.deepEqual(result.establishedBetween, []);
});

test('nine unique conventions establish the Constitution', () => {
	const result = evaluateArticleVII(nineConventionRatifications);
	assert.equal(result.phase, 'established');
	assert.equal(result.establishedBetween.length, 9);
});

test('a legislature vote and a duplicate do not increase the count', () => {
	const result = evaluateArticleVII(eventsWithDuplicateAndLegislatureVote);
	assert.equal(result.ratifiedBy.length, 8);
});

test('establishment leaves the runtime in transition', () => {
	const result = evaluateArticleVII(nineConventionRatifications);
	assert.equal(result.phase, 'established');
	assert.equal(result.runtime, 'pending-implementation');
});

The executable prototype passes all four scenarios with the standard node --test command. The result has a modest and precise meaning: the code implements the selected invariants of Article VII. The tests do not yet establish the model’s historical completeness, the legal correctness of every future case, or the suitability of the entire Constitution as software architecture. Those questions will accumulate across the seven publications.

The first run, incidentally, failed three scenarios. A test helper accidentally received the element index supplied by Array.map() as the value of approved, turning eight ratifications into one. An explicit arrow function repaired the dataset. WARDEN caught an ordinary JavaScript error before we elevated it to the status of constitutional doctrine. That is a respectable first watch for a test circuit.

WARDEN also preserves the provenance of every test. The invariant of “nine unique states” follows from the threshold and the nature of the participants. The invariant requiring a convention decision follows from the specified mode of ratification. The scope invariant follows from the words concerning the states ratifying the document. The separation between establishment and runtime is our engineering interpretation, supported by the historical sequence. This traceability allows a reader to identify and challenge every decision without mysticism around the code. A magical artificial intelligence in this position would quickly turn the study into an oracle with good CSS; WARDEN receives the more prosaic and useful office of tester.

What Article VII already gives software architecture

The first article in the cycle leaves four practical conclusions.

The activation condition belongs to the architecture. A system needs an explicit event after which a specific revision acquires authority. A repository, a release tag, and a deployed environment represent different states.

A threshold must define the scope of its result. Nine acts of consent establish a shared order among the consenting participants. In a distributed system, an equivalent threshold requires us to identify which nodes accepted the new state and what guarantees apply to the others.

The source of approval matters. Article VII specifies state conventions. The software model therefore stores the type of event with its result. A bare approved: true discards the provenance of authority and treats every accessible form of approval as equivalent.

Successful activation opens a transition. Once establishment occurs, the operating components still have to be assembled. The architecture preserves this gap as a separate state and thereby makes migration observable.

These conclusions already appear useful for software. They apply to distributed configuration, release governance, multilateral approval, and the activation of systems in which no single team possesses a permanent root. Their present value concerns the establishment protocol. The following articles will test whether the same model can withstand supremacy of rules, changes to the kernel, node autonomy, disputes, execution, and the production of common rules.

Where the first experiment ends

Article VII is particularly suitable for software adaptation because it is brief and procedural. It identifies participants, a permitted action, a threshold, and the scope of the result. Machines handle this structure well. Most constitutional order is more difficult: powers overlap, words require interpretation, facts become disputed, conventions alter practical behavior, and material execution depends on people and institutions.

The cycle therefore evaluates the adaptation incrementally. Each publication adds a component and new invariants. Some provisions will receive a clear executable form. Others will remain constraints, interfaces, or questions that a program can register but cannot resolve by itself. The final assessment arrives after Article I, when the model has acquired the complete original circuit.

The first result remains encouraging. The Constitution’s final article does behave like an entry point. It receives local decisions, reaches a defined threshold, determines the scope of a new version, and moves the system into deployment. The eagle is still sitting in the bootloader, but the bootloader passes its tests.

Conclusion

Our Death Stranding experience gave the model a simple image: a shared system appears on the map through a sequence of recognized connections. Article VII turns a similar movement into a constitutional protocol. The text already exists; states decide through a specifically designated mechanism; the ninth act of consent establishes the new revision among the participants; work then begins to transform the foundation into operating institutions.

In code, the protocol preserves the threshold, the provenance of the decision, unique participants, scope, and a separate runtime state. WARDEN confirms the selected invariants and keeps disputed choices visible. That is enough for a first bootstrap and little enough for an honest continuation.

The next publication turns to Article VI. Once the system is connected, it needs its own root of trust: a way to identify the supreme body of rules, preserve prior obligations, and bind officeholders to the constitutional order. America has appeared on the network. The network must now decide what it trusts.

Continue the research with AI

The site renders this section from the independent question set constitution-runtime.article-vii.bootstrap, stored in the companion catalog constitution-runtime-01-article-vii-questions.yaml. Each question contains its own subject and interpretive frame, so it can be reused in another publication or conversational path without copying this article.

The recommended route is connection experience → activation condition → scope → executable model → WARDEN → limits of the model. The AI answer contract, branch triggers, visual references, and localized prompts are defined in the question catalog.

Publication information

Authors: Sam Starling, Oksana Dubinetska
Project context: Zhovten Games / IRONCREED
Complete research source: Code Constitution — DOI 10.5281/zenodo.21894242
Research repository: FOP-Oksana-Dubinetska/code-constitution
Historical materials: text of the United States Constitution; ratification and activation of the federal government; overview of Article VII
Related publications: Articles VI–I in the “Constitution That Runs” cycle
Publication revision: 0.2 · 13 August 2026