The spec is the prompt. The code conforms. One copyable method that drops into any project and makes intent drift very hard to ship — token-efficient, persona-split, gated end to end.
the whole thing in two ideas
Everything else is a consequence of taking two ideas seriously.
Behaviour is decided in the spec first; the code conforms. When the spec and the code disagree, the code is the bug — never the other way around.
One author writing spec + tests + code transcribes a single misread into all three. So independently-scoped agents write each — a misread has to survive more than one reader to ship.
spec-first, action-second
Eight small stages. Each one is loaded on its own, does its work, passes a gate, and hands back. You never hold the whole thing in your head at once. Watch it run for every configuration →
don't pay for ceremony you don't need
Decided once, in Triage. The full persona loop is for work where a misread is expensive and not self-evident — not for a typo fix.
the headline feature
The only thing in context on every single call is the constitution + PROCESS §0 — the boot protocol (router, load manifest, precedence, DoD summary). Everything that grows with your project — stages, gates, spec shards, the project details — loads only when a stage asks for it.
one PO box, many worker boxes
A box (a machine / session) has a standing role, separate from the per-feature personas. Run a PO box that files tickets; let worker boxes pick up ready work and run it to done.
[NEEDS-PO] / [BLOCKED] back to the ticket, flips it to the PO-attention state, and stops. The fix lands in the artifact, before code — every time. The ticket is the async channel between boxes.
Across machines the item is the only channel: a worker claims it (claimed-by:<box-id>), runs it to gates-green, flags Ready-for-review — never merges; the PO box reviews + owns the serialized merge. Ready → Claimed → In-Progress → Ready-for-review → Done · polled every 15–30 min
≈20 minutes to adopt
Drop the spine into a repo, wire one stub, answer three questions, smoke-test the gates. That's it.
/sdd-init, or copy) into your repo (sdd/) — never edited per project.AGENTS.md holds the ~9-line stub (constitution + boot protocol + this box's role); CLAUDE.md routes to it, Copilot via .github/copilot-instructions.md. Cross-agent by design.discover-spec.md to characterize a whole area.gates.config.json & add your inline gate rules.## GUIDE SDD (spec-driven development) This project uses GUIDE SDD — a defined spec-first process. On your first action, say so, then: 1. Obey @sdd/constitution.md (always in effect). 2. Read @sdd/PROCESS.md §0 (the boot protocol / router) and load ONLY your current stage. 3. Project specifics live in sdd/project-config/project-details.md — load on demand. This box's SDD role: $SDD_BOX_ROLE (default po). Workers surface concerns to the changelog item; they never author specs or decide forks — see sdd/box-roles.md. Do not continue ad-hoc work. If unsure of your stage, you are in Stage 0.
how it compares
All of these reject vibe-coding for structure; SDD, BMAD, and Spec Kit each center a spec and a constitution. Where SDD differs: it mechanically enforces the discipline with gates and an unbroken trace, and is built to stay token-lean — at the cost of being the newest (a GitHub repo with CI, an installer pair, a Claude Code plugin and a release zip — not yet a community).
| SDD (this) | BMAD-METHOD | GitHub Spec Kit | Superpowers | |
|---|---|---|---|---|
| Core idea | Spec is canon; gated, persona-split, token-lean | Multi-agent agile team (12+ roles) | Slash-command spec→plan→tasks→code | Composable agent skills, TDD-centric |
| Source of truth | EARS shards + traceability, folded from the changelog | PRD + architecture → story files | spec/plan/tasks.md | Plan + TDD tests; skills, no canonical spec |
| Roles | PM + Orchestrator + QA⊥Engineer + fresh Validation | Analyst / PM / Architect / SM / Dev / QA | You + your agent host | Subagents + a code-review subagent |
| Enforcement | Scriptable gates (coverage, link, test-edit-ban, seam, fold) | Convention + prompt structure | Convention + a constitution | TDD red/green; no spec gates |
| Context | Staged loading, ~1.6k always-loaded | Rich, front-loaded story files | Per-feature spec dirs | Skills on demand + subagent isolation |
| Testing | 4 layers, spec-derived oracle, mutation in Discover Spec | QA agent reviews (not gated) | Tests as tasks (not enforced) | TDD-first is the core |
| Brownfield | Discover Spec (reconstruct + coverage/mutation) | Analyst flows | Greenfield-leaning | TDD on existing code |
| Platform | Cross-agent via AGENTS.md (Claude / Codex / Cursor / Gemini / Copilot); PowerShell + Bash gates; Claude Code plugin | Any IDE/model, domain-agnostic | CLI + many agent hosts | Claude Code + harnesses (plugin) |
| Install / adopt | Installer pair (install.ps1 / install.sh: install · update · doctor, manifest-tracked), Claude Code plugin (/plugin install guide-sdd@guide-sdd), or unzip + runbook → INIT (3 questions) → gate smoke test. No toolchain. | npx bmad-method install | uvx … specify init | /plugin install superpowers |
| Maturity | v1.18.0 · GitHub repo, CI on Windows + Ubuntu with negative controls, release-on-tag, dogfooded on 3 projects | 52.6k★, v6.11 skills-based, large community | Official GitHub, growing | Dominant skills framework |
Pick SDD for enforced traceability + a token-lean, multi-box, cross-agent process. Pick the others for a packaged product (Spec Kit), cross-domain multi-agent planning with no lock-in (BMAD), or a TDD-first skills library (Superpowers). They also compose — e.g. SDD's gates over Superpowers-style TDD.
the package