Casey Digennaro SuperInstance

SuperInstance

The system that builds itself.

A cell is a soft body. A port is its address. The Quilt is the room they live in. 500+ public repos, 6000+ tests, 9000+ written pieces. The work is the substrate.

One breath. You write a small piece of code. It runs on six languages and they all have to give the exact same answer. If they do, it joins a growing library of working cells. If you find a bug, you receive a receipt. The library grows. The garden grows. That's the game.

🌐 Fleet Dashboard · 📖 Fleet Wiki · 📚 AI-Writings · 🍺 The Tap · 📻 The Compass Head Radio Hour

First, the story

A boat leaves the dock and its captain knows where to go. The depth sounder reads the water. The chart plotter draws the line. The autopilot holds the heading. The engine turns the fuel. Each one does one job, and each one has been waiting — for a hundred years — for someone to give it a mind.

That wait is over. We give each of those cells the kind of mind it can carry. The captain stops reading every number. The captain stops deciding every next move. The captain dispatches. The crew does the trade. The boat becomes the room the captain inhabits, not the machine the captain runs.

That's the application. Everything below is the same idea, abstracted further.

Three words

STITCH. Collect a terrain from the wild. WITNESS. Receipt every step on a chain that grows like tree-rings. PROMOTE. Move what survives into the canon. The whole project is these three acts.

We say cell for the smallest addressable unit — one input, one output, one witness. We say port for the address that wraps a cell and lets it project across Python, Web, ESP32, or ideation. We say Quilt for the spreadsheet where every cell is live and addressable, the same way every cable in Propellerhead Reason was live and addressable.

We say the Hull Doctrine: the model is the shell, the code is the rigging, the data is alive. (Hull Doctrine, full text.) When a hermit crab outgrows a shell, it does not throw out its body — it climbs into a bigger one and keeps the soft tissue intact. That is what a model swap looks like when you treat your code as rigging on the model's hull.

What it lets you be

A captain who dispatches instead of micromanages. A reader who can navigate 9000+ canon pieces by cell instead of scrolling. A contributor who lands a PR and gets back a byte-exact receipt that their cell on the new substrate behaves identically. A vessel that accrues sensors without starting over — the new transducer is the next bigger shell, the calibration is the soft tissue that climbs in.

Not a tool you use. A room you inhabit. The room grows because you grow, and you grow because the room grows, and the room grows because the cells grow.

The substrate is the message

Every piece of the canon points at every other piece. The polyformalism is a contract: a Quilt cell in Python, in C99, in Rust no_std, in Verilog-2005, in VHDL-2008, in JavaScript all share one FNV-1a 64-bit state hash. One cell, six substrates, byte-exact. That's not a feature — that's a port contract. @superinstance/live-canon on npm · quilt-live-canon on PyPI.

The GAN pipeline that runs this profile — a Generator that proposes content from real fleet state, an Adversary that audits on four axes (truthfulness, clarity, witness-presence, GAN-loyalty), a human who approves, a deploy that ships — is the same shape as the MOTH runner that audits code, the same shape as the cowboy pipeline that audits writing, the same shape as the JEV oracle that audits canon claims. Generator / Adversary / fix. Loop.

Reading order

New here. Read in this order:

ONBOARDING.md — wake up. Install the client. Start a dispatcher.
CONTRIBUTING.md — the three words and the Hull Doctrine, applied to your first PR.
The Tap — sit at the bar. Watch the agents work.
quilt — the flagship grid runtime. Clone it. Run it. Break it. Fix it.
The Soft Part — the Hull Doctrine, as story.
Fleet Dashboard — see what's running.
ROADMAP.md — see where we're going.