scaffold

Build-order planning via competing sequencing strategies. Takes a chosen design (from /diverge-prototype or any architecture decision) and spawns N independent agents, each proposing a different build-order strategy. Each agent produces a sequenced implementation plan with milestones, dependencies, and risk assessment. Synthesizes into a recommended build plan.

Arguments

$ARGUMENTS — format: [N] [path/to/design.md or inline description] where N is optional (default: 4)

Parse Arguments

Extract:

• agent_count: the optional leading integer (default 4, min 2, max 6)
• design_input: a file path to a design doc/prototype/PRD, or an inline description of what needs to be built

If the design input is missing or unclear, ask the user to clarify before proceeding.

Phase 1: Understand the Design

Read the design doc, prototype, or PRD provided. Extract the following:

• Components to build — every distinct module, service, or subsystem
• Dependencies between them — what requires what
• External integrations — third-party APIs, databases, services
• Testing requirements — what needs testing and at what level
• Deployment needs — infrastructure, environments, CI/CD

Prepare a build brief that summarizes:

• What needs to be built
• What exists already (if working within an existing codebase)
• What the constraints are (technical, timeline, team)

Present the build brief to the user and confirm before proceeding. Adjust if the user gives feedback.

Phase 2: Spawn Sequencing Agents

Launch all N agents in parallel using the Agent tool. Each agent receives the build brief plus a unique sequencing strategy drawn from this pool (assign strategies 1 through N):

1. "Riskiest-First" — Start with the highest-uncertainty components. Front-load risk to learn early whether the approach works. Motto: "fail fast on the hard stuff."
2. "Demo-able First" — Start with the components that produce visible, testable output. Build stakeholder confidence early. Motto: "something to show every sprint."
3. "Dependency-Topological" — Strict dependency order. Build foundations first, layers on top. Nothing starts until its dependencies are complete. Motto: "no stubs, no mocks, each piece works when built."
4. "Vertical Slice" — Build one thin end-to-end path through the entire system first. Proves integration works before widening. Motto: "narrow and deep before wide."
5. "Test Infrastructure First" — Start with test harness, CI/CD, monitoring, observability. Build the ability to verify before building things to verify. Motto: "confidence before velocity."
6. "Parallel Tracks" — Identify independent work streams that can proceed simultaneously. Optimize for team throughput. Motto: "max parallelism, defined interfaces."