— How it works
From intent to owned software, in six steps.
The same supply chain you saw on the home page, now artifact by artifact. Every step leaves something concrete behind — which is why the result is software you can stand on.
Step 1 of 6 — Discover
A product engineer embeds and maps the work.
A product engineer sits with you, learns how you actually run, and turns the fog into a short list of jobs worth shipping. No questionnaire — they watch the work.
priority → billing ledger
owner → you · cadence → weekly
first order → 1 feature
Step 2 of 6 — Spec
The order becomes an authoritative spec.
The product engineer turns the feature order into a spec with edges, checks, and acceptance criteria. This is the durable artifact — the thing that survives, where a chat thread wouldn't. We call the spec layer Allium.
feature record-a-payment
edges overpay · refund · void
checks ledger stays balanced
accept receipt + audit trail
Step 3 of 6 — Assemble
The factory builds it on Grain.
Product engineers take the spec into the factory and assemble working software under constraint. Grain narrows the space of valid outputs until drift becomes structurally impossible — so what gets built matches what was specified.
event PaymentRecorded
command RecordPayment
read LedgerBalance
// built 1:1 from the spec
Step 4 of 6 — Inspect
You review the evidence, not a demo.
Every feature leaves assembly with proof: passing tests and each acceptance criterion checked off. You inspect the evidence with the product engineer before anything ships.
Step 5 of 6 — Ship
Working software leaves the line — and it's yours.
The feature ships as working software you own, not access you rent. Bug fixes are guaranteed. The first shipment installs the rail everything after rides on.
billing ledger → live
bug fixes → guaranteed
source + IP → yours
Step 6 of 6 — Production loop
Usage drives the next order.
Once the rail is installed, real usage tells you what to build next. That becomes the next feature order, and the line runs again. Change your mind — the rail holds.
usage → signal
signal → next feature order
order → line runs again
Want the reason a Grain-built system can't drift? That's the open methodology.
Why it doesn't drift → ReasonStack ↗