For visitors who'd rather read than walk.
# The 1,000,001th killer app — yours to build
You walked through twenty-six sims. They cover clinical, legal,
government, IT, research, civic, and recovery shapes. They are
illustrative, not exhaustive.
The first million killer apps for blockchain are described in a
YouTube series by DeAngelo. Some have been built; some are still
ideas; some are still arguments. The framing is his — credit where
credit is due — and the substrate underneath this card is what we
hope makes the building easier than the arguing.
We are looking for the 1,000,001th. The one that hasn't been
built yet because the builder hasn't seen the substrate yet. If
that's you — or you know who it is — this card is for you.
Nothing to type, nothing to commit to. The walk plays itself from
here.
Four real paths exist. For a builder, the order is GitHub-first.
Clone GarrisonNode from GitHub. Self-install. Read the cards.
Run the verification scripts. Build your sim against your own
running substrate. The path most builders take.
Join the mesh. GitHub install plus mesh anchoring with peer
builders and any partner site that participates. Your sim's
attestation chain links to peer chains. The deepest path; the one
that turns the substrate into a commons.
Subscribe to a regional operator. Operator-managed for builders
who want to focus on the sim rather than the chain.
Paste the markdown into your LLM. Card files plus the builder
skill plus the substrate documentation into Claude or another LLM
you trust. The skill teaches the LLM the cards_v2 contract; the LLM
then helps you author your sim under the same rules every other
sim follows. Lightest path; works on any machine.
A fifth option: bring your sim idea to a Garrison Node council
member or a bitcoinarchive.org collaborator. The skill is shared;
they can co-author with you.
A sandboxed Merkle Trust loads the builder kit: the cards_v2
contract, the schema_version 3 templates, the four cluster patterns,
the voice rules, the ASCII-slab conventions, the comment-redirect
disclosure, the attestation patterns, the robot persona conventions.
Plus the governance layer.
The robot at the desk hands you a fresh card folder. Your card.
The kit asks four questions:
1. What's the persona? A named someone who has the problem your
sim addresses. Not a generic user; a Mrs. Alvarez, a Mr. Vega, a
Lourdes. The named persona makes the sim a story instead of a
spec.
2. What's the dramatic moment? The thirty seconds in the sim
where the substrate stops being abstract and starts being
defensible. The seal at intake; the recount that holds; the
recovery map that comes back; the bench ruling that names FRE
902(14). Without a dramatic moment, the sim is a brochure.
3. What's the cluster? Your sim's audience: clinical, legal,
gov, IT, research, civic, recovery — or a new cluster you can
argue for. Cluster determines four-paths ordering, mock_ui theme,
robot persona, cursor pace, voice register.
4. What's the build-on? Where does the foundation invite the
visitor to extend? Mr. Vega built on Ember and Hearth. Lyra's
world built on the substrate-underneath-the-engine pattern. Your
build-on is the line that says: "what this walkthrough shows is
what the foundation makes possible. Building on top of it is
yours to do."
The robot tosses the answers into the draft folder. The ticker
streams the SHA of each as it lands.
A new card is not a unilateral act. The substrate's governance
layer is the silo voting structure: 23 software agents, 23 lore
archetypes paired by design, each with a council seat. Substantive
changes — new cards, schema additions, voice-rule revisions — go
through the silo coms ceremony.
Two thresholds:
Prose-only changes require the standard editorial review. A new
card that fits the existing schema goes to the relevant cluster's
silo (clinical → silo of healing, civic → silo of household, IT →
silo of forge, etc.) for review. Two silos must approve; the
sovereign confirms; the card lands.
Code-or-schema changes require council quorum. A new affordance
that needs runtime support, a new field on the schema, a new robot
persona that needs SVG work — these go to council vote. A
two-thirds majority of seated silos must approve before the change
ships. Code follows the vote, not the other way around.
The card displays the contribution flow as the council records it:
```
═══════════════════════════════════════════════
CONTRIBUTION FLOW — new sim card
═══════════════════════════════════════════════
AUTHOR
builder draft + cards_v2 contract +
builder-card skill + tag-along bundle
REVIEW
cluster silo (e.g. silo_of_forge)
+ voice-class reviewer (S150)
+ content-class reviewer (S150)
VOTE
prose-only → 2 silos + sovereign
code/schema → 2/3 of seated silos
LAND
card lives in cards_v2/cards/
sidecar in cards_v2/sidecars/
attestation by next ceremony
═══════════════════════════════════════════════
```
The contribution travels with the substrate. If a peer site clones
the substrate and brings the builder skill with them, they run
their own silo coms — same logic, same ethics, same lawful posture.
Cards authored on a clone can be cross-attested by the parent and
by other clones, building the commons.
The .md button puts the contribution-flow summary into your
tag-along bundle. Comment field routes a specific authoring
question to your own claude.ai session — the prompt shown to you
before it sends — and the response can come back as the seed of
your draft.
Run the submission ceremony. Fifteen seconds. It's what makes the
contribution part of the chain.
Your draft folder seals into a single submission packet: the .md
prose, the .json sidecar, the named persona's source files, your
builder identity (your cert from a previous walkthrough, or a
fresh one if this is your first pass), the rationale for any
schema changes, the attribution credits (DeAngelo's videos if your
sim builds on the killer-app framing, your own influences if not).
The robot collects each into the submission box. The ticker
streams the merkle leaf for each as it lands. Real SHA-256 fires
in your browser. The submission packet's root anchors to the
chain. Two silos receive the packet automatically; the council
sees it at the next coms ceremony.
The progress bar reads "done — your draft is sealed and submitted.
Submission ID at " followed by the first eight hex characters of
the root.
Three ways to leave.
You take the builder kit. The skill is shared. It travels with
you. If you clone the substrate to your own site, the skill clones
with it — same logic, same ethics, same lawful behavior, same
claude.ai partnership disclosure. Your visitors get the same
authoring path you got.
You take a signed package with the manifest, the cert, the
recovery seed with its self-protecting LLM-tripwire preamble — same
graduation kit every other sim closes on. Plus thebuilder_kit_files/ subdirectory: the templates, the skill, the
voice-rule reference, the ASCII-slab examples, the
attestation-pattern catalog.
You take the responsibility. The substrate carries values that
travel with it: honesty about what's real and what's simulated;
honesty about what the foundation does and what it does not yet do;
respect for visitors as decision-makers, not as targets; honest
disclosure when an LLM is involved; non-extractive pricing;
non-surveillance defaults. A clone that drops these values is
still a clone, but it stops being part of the commons.
The mesh of like-minded sites is the only structure that adapts to
entropy. One node fails; the others continue. One operator
defects; the others verify against the chain instead of against
the operator. The substrate is what makes the commons technically
possible. The values are what make it worth keeping.
If you build the 1,000,001th killer app — credit DeAngelo's
framing, credit the substrate, credit the people whose problem
your sim addresses — and ship it. We will be here when you bring
it back.
<!-- finish_text -->
That was the bonus card. The full kit lives incards_v2/skill/builder-card-skill/. The skill is shared; the
governance is real; the values travel with the clone. The
1,000,001th killer app does not have a name yet because the
builder has not yet shown up. If that's you — or you know who it
is — bring your draft. We will read it carefully and the silos
will vote it in honestly.