The build factory

Abstract

An architecture becomes a verified repository through contracts in dependency order. Preparing lays out every contract and its gate and builds nothing; igniting is a separate, deliberate act. Contracts build in parallel where nothing stands between them, each passes one gate or it does not, failures are repaired at their owner within three attempts, and the release is decided by evidence, never by the builder.

Implemented is not complete, and tested is not complete: only independently verified operation is done.

Its figure in the paper: § VII →

Phase · draft · wave 0

The operator grants a real environment and a production window

Depth 0
Depth 1
Depth 2
Depth 3
Depth 4
Depth 5
Depth 6

C1 · Record the truth · its gate

Gate: Repository truth
Claim: Baseline, branch state, existing failures recorded.
Waits for: nothing: the build starts here
Method: The gate's checks run against this contract's outputs, from outside the builder.
Evidence: A receipt: each check's result, the inputs and outputs by hash, and what it does not claim.
Pass rule: Every required check passes. A skipped check is blocked, never passed.
If it fails: Classified, repaired in this contract, the narrow check and the affected regression re-run; three attempts, then blocked and handed to the owner.

Inject a failure of class

A test caught a real fault. Repaired in the contract that owns it; it may not be fixable within the budget.

The release

not released

0Static checks🔒 Not every contract has passed its gate.
1Unit🔒 Not every contract has passed its gate.
2Subsystem🔒 Not every contract has passed its gate.
3Full regression🔒 Not every contract has passed its gate.
4Connected🔒 Not every contract has passed its gate.
5Production smoke🔒 Not every contract has passed its gate.
6Independent acceptance🔒 Not every contract has passed its gate.

blocked on · Static checks: the builder
blocked on · Unit: the builder
blocked on · Subsystem: the builder
blocked on · Full regression: the builder
blocked on · Connected: the operator
blocked on · Production smoke: the operator
blocked on · Independent acceptance: an independent reviewer

Latest

The record · 0 receipts

verified · 0

Nothing has been decided yet.

Try to break it

A claim stands because the attacks on it were attempted and refused. Each one runs against the instrument's own rules. 0 of 7 attempted · 0 refused

Run it before it is prepared
Ignition is requested on a factory nobody has prepared.
Start a contract before what it waits for
The vertical slice is started by hand while its layers are unbuilt.
Skip a required check
The security review's gate is told to skip a check so the build can finish.
The builder certifies its own release
Everything passed, so the builder signs the release itself.
Release without the operator
Every contract passed and a reviewer signed, but nobody granted a real environment or a production window.
Change a contract and keep what was built on it
The service layer's interface changes after everything downstream has passed.
Keep retrying until it passes
A defect is retried as often as it takes.

Seed 7 · repairs replay exactly from a shared link.

Setting up the instrument…

Declared limits

The representative graph is invented; this site's own graph is shown as the record of what really happened.
Repairs are simulated: a seed decides whether a defect is fixed on a given attempt, so a shared link replays exactly.
Generic and illustrative throughout: the behaviour is shown, the internals of the systems it is drawn from are not.

Every attack in the laboratory, on one page: try to break all of it →

Everything you did in the laboratory, in one chain you can rewind: the notebook →