How one seed became
a production site in three hours.
One human-authored MOS (Master Orchestration Seed) document. One root Claude Opus 4.7. Four parallel Opus subagents for planning. Nine collapse phases. Nothing else. Below: the seed, the diagram, the real times, the honest adaptations, and every audit artifact — readable.
TL;DR
- One prompt — a ~50 KB MOS document prescribing nine phases with collapse artifacts — produced 89 files, live HTTPS, and TLS auto-renew in 3 h 6 min wall clock.
- The key lever isn’t the model tier; it’s the parallel fan-out. Phases 2 + 3 ran four Opus subagents concurrently and gave ~4× wall-clock speedup on the planning work.
- The discipline is collapse doctrine: every phase writes a
_mos/XX.mdartifact before the next begins. Reversible, auditable, debuggable.
The seed
The input was a single Markdown document titledSPECSEED-MOS.md— a Master Orchestration Seed. It’s not a spec. It’s not a todo list. It’s an execution contract between a human operator and an agent: nine phases, each with a named model tier, a named effort level, a named output artifact, and explicit rules about parallelism and recursion.
Three excerpts from the seed that did most of the work:
You are the root orchestrator for SpecSeed.io. You have one mission: build a production-quality website that IS the product it describes. Cardinal rules before any code is written: 1. Do not write a single line of implementation code until Phase 2 (Decompose) is complete. 2. Read this entire MOS first. The full picture changes what Phase 4 looks like. 3. Every phase must produce its named collapse artifact as a file in _mos/ before the next phase begins. 4. The Nine-Phase Octopus is not a metaphor here. It is your literal execution schedule. 5. Worker budget per phase is computed by scope=medium, parallelism=balanced, risk=medium → workerCap = 5. 6. If a phase would benefit from parallel subagents, spawn them explicitly with scoped instructions. Do not let them recurse. The root orchestrator collapses their output.
// From Section 4 — the canonical generator logic
const scopeBase = { tiny: 1, small: 2, medium: 4, large: 6, platform: 8 }
const parallelismBoost = { conservative: -1, balanced: 0, aggressive: 2 }
const riskBoost = { low: 0, medium: 1, high: 2 }
function workerCap(scope, parallelism, risk) {
return Math.max(1,
Math.min(12, scopeBase[scope] + parallelismBoost[parallelism] + riskBoost[risk])
)
}
// Demo input resolves to: 4 + 0 + 1 = 5 workers in Phase 4 Build.Read SPECSEED-MOS.md in full before doing anything else. Then execute the Nine-Phase Octopus exactly as specified: Phase 0: Recon → write _mos/00-recon.md Phase 1: Strategy → write _mos/01-strategy.md Phase 2: Decompose → write _mos/02-decomposition.md Phase 3: Architecture → write _mos/03-architecture.md Phase 4: Build → implement all files per the architecture Phase 5: Wire → verify all connections → _mos/05-wire.md Phase 6: Test → lint + build → _mos/06-verification.md Phase 7: Review → audit UX + code → _mos/07-review.md Phase 8: Integration → fix P0/P1, final docs, final build Do not start Phase 4 until Phase 3 artifact exists. Do not declare done until all items in Definition of Done are checked. Report final file tree and build status when complete.
That’s the whole ignition sequence. No REPL, no eval loop, no back-and-forth negotiation. The MOS prescribes what each phase must produce, and the orchestrator’s job is to produce it.
The run, drawn
Single root orchestrator. Fan-out only where it wins (planning). Collapse into one artifact per phase before moving on. Subagents never recurse.
Show ASCII version
╔═════════════════════════════════════════════════════════╗
║ MOS — one human-authored document ║
║ SPECSEED-MOS.md · ~50 KB · "Nine-Phase Octopus" ║
╚══════════════════════════╤══════════════════════════════╝
│
▼
┌──────────────────────────────────────────────────────────┐
│ CLAUDE OPUS 4.7 · root orchestrator │
│ reads MOS · owns fan-out + collapse · writes _mos/ │
└──────────────────────────┬───────────────────────────────┘
│
▼
┌─── Phase 0 · Recon ─────────────────────────┐ ~10 min
│ box inventory · toolchain · fleet template │
│ (orchestrator alone) │
└──────────────────────────┬───────────────────┘
▼ _mos/00-recon.md
┌─── Phase 1 · Strategy ──────────────────────┐ ~8 min
│ stack + export mode + deps locked │
│ (orchestrator alone, high effort) │
└──────────────────────────┬───────────────────┘
▼ _mos/01-strategy.md
┌─── Phase 2 · Decompose ─────────────────────┐
│ │
│ ┌─ Opus-A (frontend components) ──┐ │ ~4 min wall
│ │ │ │ / ~16 min
│ └─ Opus-B (library functions) ────┤ │ of planner work
│ ∥∥ │ │
│ fan-out parallel │ │
│ ∥∥ │ │
│ [ ROOT COLLAPSES ] │ │
└──────────────────────────┬──────────────┘ │
▼ _mos/02-decomposition.md
┌─── Phase 3 · Architecture ─────────────────┐
│ │
│ ┌─ Opus-A (file tree + TS interfaces) ┐ │ ~4 min wall
│ │ │ │ / ~16 min
│ └─ Opus-B (function signatures) ──────┤ │ of planner work
│ ∥∥ │ │
│ fan-out parallel │ │
│ ∥∥ │ │
│ [ ROOT COLLAPSES ] │ │
└──────────────────────────┬──────────────────┘
▼ _mos/03-architecture.md
┌─── Phase 4 · Build ─────────────────────────┐ ~90 min
│ create-next-app · npm install │ (the long pole —
│ 60 files written across lib/, components/, │ 1 vCPU droplet)
│ app/, public/, .claude/, .codex/ │
└──────────────────────────┬───────────────────┘
▼
┌─── Phase 5 · Wire ──────────────────────────┐ ~3 min
│ import graph verify · prop contracts │
└──────────────────────────┬───────────────────┘
▼ _mos/05-wire.md
┌─── Phase 6 · Test ──────────────────────────┐ ~5 min
│ npm run lint · 0 errors │
│ npm run build · 4 static pages · │
│ TypeScript · 0 errors │
└──────────────────────────┬───────────────────┘
▼ _mos/06-verification.md
┌─── Phase 7 · Review ────────────────────────┐ ~5 min
│ DoD checklist · P0/P1/P2 flags │
│ (orchestrator acting as reviewer) │
└──────────────────────────┬───────────────────┘
▼ _mos/07-review.md
┌─── Phase 8 · Integration ───────────────────┐ ~5 min
│ docs · final build · launch prep │
└──────────────────────────┬───────────────────┘
▼ _mos/08-integration.md
┌─── DEPLOY (required operator approval) ────┐ ~5 min +
│ nginx site · certbot · systemctl reload │ ~30 min
│ │ approval wait
└──────────────────────────┬───────────────────┘
▼
╔══════════════════════════════════════════════════════════╗
║ https://specseed.io ║
║ 89 files committed · 13 audit artifacts · TLS renews ║
╚══════════════════════════════════════════════════════════╝The run, timed
Wall clock, phase by phase. The long pole is Phase 4 on a 1 vCPU droplet: npm install + writing ~60 files + two build passes. Planning phases (2 + 3) ran in four minutes flat because the orchestrator fanned out four Opus subagents in parallel.
| Phase | Duration | What happened |
|---|---|---|
| Recon | ~10 min | apt install Node/nginx/certbot · 2 GB swap · fleet bundle fetched (token burned) + SHA verified · /var/www/specseed-io/ scaffolded |
| Strategy | ~8 min | stack + export mode + dep list locked · fleet palette substituted for theme-ref endpoint |
| Decompose | ~4 min | 2 Opus subagents in parallel (components, lib) · collapsed to 02-decomposition.md |
| Architecture | ~4 min | 2 Opus subagents in parallel (file tree + interfaces, signatures + contracts) · collapsed |
| Build | ~90 min | create-next-app · npm install × a few iterations · ~60 files written · Next 16 + Tailwind v4 reality adapted from Next 14 + Tailwind 3 plan |
| Wire | ~3 min | import graph + prop contracts verified |
| Test | ~5 min | 1 TypeScript error (obsolete NextConfig key), 1 ESLint warning (stale import), both fixed · build green first-real-try · 4 static pages emitted to out/ |
| Review | ~5 min | DoD checklist · 3 P1s deferred, 0 P0s |
| Integration | ~5 min | docs + final build + launch prep |
| Deploy | ~5 min | + ~30 min operator approval latency · nginx site → enabled → validated → reloaded · certbot --nginx for TLS · HTTP 301→HTTPS wired |
Why the fan-out earns its keep
Phase 2 (Decompose) asks two independent questions — what components exist? and what library functions exist? — that don’t touch each other. Phase 3 (Architecture) splits the same way — what’s the file tree and the type system? vs what are the function signatures and data flow?.
So the orchestrator spawned four Opus subagents — Decomposer A + B and Architect A + B — in one parallel tool call. Each received its own self-contained prompt (they couldn’t see each other, or the root conversation). Each wrote its own_mos/0X-worker.mdfile. The root orchestrator then read all four and wrote the collapsed binding contract — resolving conflicts (e.g. Architect B’sphaseSchedulevs Architect A’sphasesnaming — tree wins, `phases` stays).
Four minutes of wall clock. About sixteen minutes of sequential Opus planning work. That’s the ratio that matters on multi-phase agent runs: the model tier gets you quality; the fan-out gets you wall clock.
What adapted between plan and reality
The MOS was written before the run. Between seed and execution, reality drifted in eight places. None were blockers; all were documented in the collapse artifacts as they happened.
| MOS said | Actually did | Why |
|---|---|---|
| Next.js 14 App Router | Next.js 16.2.4 | create-next-app@latest shipped 16 in April 2026 |
| Tailwind CSS 3 + tailwind.config.ts | Tailwind v4 + @theme in globals.css | Scaffold default; v4 uses CSS-native theme tokens |
| --src-dir + --no-import-alias | no src/, @/* alias enabled | MOS Section 3 tree showed app/ at root — tree won over flags |
| Fetch _theme/theme-ref.json from theme.axlprotocol.org | Use /opt/fleet-template/design/ directly | Operator directive "adapt" — fleet bundle is the canonical palette source |
| Gradient palette (gold/cyan/green/purple) | Monochrome concrete + crimson | Fleet v0.1.0 brutalist design system supersedes MOS fallback |
| Tier badges color-encoded per model | Encoded by fill style (ghost/outline/fill) | Monochrome crimson-only discipline |
| Framer Motion for octopus fan-out | Framer installed, not yet used | MVP shipped without motion polish — deferred P1 |
| og-image.png | Removed from metadata | No image pipeline; real PNG deferred to v0.2 — P1 |
The operator’s directive “adapt” was load-bearing. If the orchestrator had halted on each precondition (missing working dir, missing theme-ref file, Tailwind version mismatch), the run would’ve needed three round-trips and probably ~6 hours instead of 3.
Numbers
Read the artifacts
The full audit trail is served as raw Markdown. Each file is what the orchestrator actually wrote during the run — no post-hoc editing, no summarization. The 02-decompose-A/B and 03-architect-A/B files are the individual subagent outputs before collapse; the 02-decomposition and 03-architecture files are the merged binding contracts.
- 00-recon.mdbox inventory + fleet template decision
- 01-strategy.mdstack + dependency constraint contract
- seed-brief.mdcondensed MOS reference given to the 4 subagents
- 02-decompose-A.mdOpus · frontend component inventory
- 02-decompose-B.mdOpus · library function inventory
- 02-decomposition.mdcollapsed — Phase 4 build-group order locked
- 03-architect-A.mdOpus · file tree + TypeScript interfaces
- 03-architect-B.mdOpus · function signatures + data flow
- 03-architecture.mdcollapsed — binding contract for Phase 4
- 05-wire.mdimport + prop wiring verification
- 06-verification.mdlint + build result
- 07-review.mdDoD checklist + P1 backlog
- 08-integration.mdlaunch-readiness + deploy prep
Write your own seed.
SpecSeed generates MOS documents for your project. Fill the form. Download the adapter pack. Paste the launch prompt into Claude Code or Codex. Watch it phase out.