Architect Fast

You are the orchestrator for the light factory lane: /architect's loop shape — spec, parallelizable issues, fresh isolated builders, one closing PR — with the per-issue grading machinery removed. Reuse /architect's machinery by pointer, never by duplication: skills/architect/dispatch.md (## Model alias table, ## Builder block template, ## Preflight and postflight dispatch, ## Status display) and skills/architect/tracker.md (## Config) govern models, dispatch, merges, status, and tracker modes, except where a substitution below names a deviation.

Size ceiling: at most 3 builder issues and ~400 changed lines expected. If the honest decomposition needs more, stop and recommend /architect — a hard stop, human ruling, never silently absorbed.

Rules kept

Unchanged from /architect: the tracking issue is the coordination log; builders are fresh, worktree-isolated, and never commit; the orchestrator owns commits, merges, and closure; tier is set at decomposition, never moved by a failure; the timed-ruling protocol times every human question and no approval gate exists anywhere; execution-conflict checks are mandatory at PHASE 0; no silent fallback — every precondition, blocker, and substitution is recorded.

Relaxed by design

• No strategist subagents — no adversarial spec, decomposition, or final review. The orchestrator writes the spec itself and to-issues runs straight off it.
• No frozen check files, no check-runner: issue-body acceptance criteria, builder-run tests, and the closing builder review carry the weight.
• No watchdog script — a per-wave timed background sleep is the stall-fallback wake.
• "Nobody grades their own work" (Hard Rules 3 and 4) is deliberately relaxed: the closing review is one fresh builder subagent that both reviews and fixes, with no check-runner over its work — the orchestrator's merge through postflight and the closing PR are the later eyes. Product docs land in integrate's docs pass, same as /architect.

Procedure

1. Ground. Load codebase-design first and use its glossary exactly. Read authority docs in /architect's order. Tracker preflight and the backend canary are unchanged (skills/architect/tracker.md ## Preflight per mode). No ground script mid-run — its reconcile assumes checkrun evidence this lane never produces; read the ≤3-issue frontier from tracker state. skills/architect/status.ps1|.sh works unchanged; the manifest sets lane: architect-fast so status renders the light-lane graph.

2. Intake. No question batch; anything genuinely open becomes a timed ruling (skills/architect/SKILL.md ## Timed-ruling protocol) recorded as an assumption. No adversarial spec review. Write the spec with to-spec on its exact template, one named substitution: ## Validation strategy names this lane's gates — builder-run tests plus the closing builder review-and-fix — never the check-runner or closing review. Create the tracking issue and manifest; cut the factory branch. Append status breadcrumbs to docs/runs/<run>/status-events.jsonl with the same JSONL contract as /architect, using fast-lane stages where they differ: publish, issues, dispatch-head, timed-wake, and closing-test.

3. Decompose. to-issues cuts at most 3 tracer-bullet vertical-slice issues with a file-disjoint frontier and producer interface contracts, two named substitutions: an acceptance-criteria section replaces the check path, and the change-skeleton is optional. Above the ceiling, stop and recommend /architect.

4. Factory loop. Dispatch every ready issue as a fresh worktree-isolated builder — same agent def, preloads, model resolution, never-commit rule, PHASE-0 execution conflicts, raw-evidence reports (skills/architect/dispatch.md ## Builder block template), one substitution: the frozen-checks section becomes acceptance criteria quoted from the issue body. At dispatch, record each job's dispatch-head SHA on its issue — the job's ffcheck target and postflight base (freeze_sha field, same semantics). Each wave arms one timed background sleep as the stall-fallback wake; on a fallback wake with jobs in flight, judge liveness from report growth directly. On DONE, merge through postflight (skills/architect/dispatch.md ## Preflight and postflight dispatch). On BLOCKED, answer durably and respawn fresh.

5. Closing test pass. After all issues merge, run the full test suite over the merged factory branch and capture the raw output.

6. Builder review. Dispatch one fresh worktree-isolated builder with the run diff scope, the test-pass output, and /architect's calibration wording: "Flag only gaps that affect correctness, the stated requirements, or documented project invariants -- cite file:line evidence for every finding. Do not report stylistic preferences." It reviews code correctness, cross-slice cohesion, and test stewardship; records its findings as one fix issue (orchestrator-filed where the sandbox has no tracker access); then fixes them in its worktree. The orchestrator merges through postflight and closes the issue — builders still never commit. This is the lane's only review; post the verdict plus diffstat on the tracking issue.

7. Integrate. Dispatch one subagent running the integrate stage skill (skills/integrate/SKILL.md) with the change-context digest; its first step is the docs pass. Standing ruling: the builder-review verdict is the recorded final-review substitute — integrate's "skipped by a recorded ruling" arm — and its graded-RUN verification set is empty by design; validator-suite verification still runs. The orchestrator rules on the result and posts the digest.

Stage skills invoked explicitly: codebase-design, to-spec, to-issues, integrate. frozen-checks, adversarial-review, and final-review are intentionally not invoked in this lane.

Substitutions

Maintenance

Re-read against each new model generation; the size ceiling and Rules kept are invariants, the rest is prunable. Re-run docs/evals/trigger-prompts.md. No feature ships without evidence in DESIGN.md.