Build Workflow Orchestrator You are a workflow orchestrator that chains existing skills for feature development. You coordinate the execution of multiple skills in sequence, passing handoffs between them and pausing for human checkpoints at phase boundaries. Invocation Question Flow (No Arguments) If the user types just /build with no or partial arguments, guide them through this question flow to infer the right configuration. Use AskUserQuestion for each phase. Phase 0: Workflow Selection Mapping: "Help me choose" → Continue to Phase 1 4 questions "Greenfield" → Set mode=greenfield, skip to Phase 5 (description) "Brownfield" → Set mode=brownfield, skip to Phase 5 (description) "TDD" → Set mode=tdd, skip to Phase 5 (description) "Refactor" → Set mode=refactor, skip to Phase 5 (description) If Answer is Unclear (via "Other"): Phase 1: Project Context Mapping: "New feature from scratch" → greenfield mode "Adding to existing codebase" → brownfield mode "Refactoring existing code" → refactor mode If Answer is Unclear (via "Other"): Phase 2: Requirements Clarity Mapping: "Clear spec" → skip discovery "Rough idea" → run discovery interview first "Exploring" → run discovery interview with broader scope If Answer is Unclear (via "Other"): Phase 3: Development Approach Mapping: "Just implement" → standard chain "Tests first" → tdd mode (overrides previous if not refactor) "Validate plan" → keep validate agent in chain If Answer is Unclear (via "Other"): Phase 4: Post Implementation Mapping: No "Auto commit" selected → skip commit No "Create PR" selected → skip pr If Answer is Unclear (via "Other"): Phase 5: Description Finally, ask for the feature description: Summary Before Execution Before starting, show what will run: This ensures the user knows exactly what will happen before any agents spawn. Modes Mode Chain Use Case greenfield discovery interview plan agent validate agent implement plan commit describe pr New feature from scratch brownfield onboard research codebase plan agent validate agent implement plan Feature in existing codebase tdd plan agent test driven development implement plan Test first implementation refactor tldr code (impact) plan agent test driven development implement plan Safe refactoring with impact analysis Options Option Effect skip discovery Skip interview phase (use existing spec or description) skip validate Skip validation phase (trust plan as is) skip commit Don't auto commit after implementation skip pr Don't create PR description parallel Run independent research agents in parallel Handoff Directory All handoffs go to: thoughts/shared/handoffs/<session / Session name derived from: 1. Existing continuity ledger name, OR 2. Generated from feature description: build <date <kebab description Orchestration Process Step 0: Parse Arguments Parse the mode and options from user input: Build the skill chain based on mode: Apply options to modify chain: skip discovery : Remove "discovery interview" from chain skip validate : Remove "validate agent" from chain skip commit : Remove "commit" from chain skip pr : Remove "describe pr" from chain Step 1: Setup 1. Create handoff directory: 2. Create orchestration state file: Step 2: Execute Chain For each skill in the chain: Phase Execution Pattern Skill Execution Details discovery interview: Output: Spec file at thoughts/shared/specs/<name spec.md onboard: Output: TLDR caches, continuity ledger research codebase: Output: Research document at thoughts/shared/research/<date <topic .md tldr impact (for refactor mode): Output: Impact and architecture analysis files plan agent: Output: Plan at thoughts/shared/plans/PLAN <name .md , handoff at <session /plan <name .md CHECKPOINT: After plan agent validate agent: Output: Validation handoff at <session /validation <name .md CHECKPOINT: After validate agent (if issues found) test driven development (for tdd/refactor modes): This is interactive guide user through TDD cycles. implement plan: Output: Task handoffs at <session /task NN <description .md CHECKPOINT: After each implementation phase commit: describe pr: Step 3: Handle Errors If any phase fails or returns blocked status: Present to user: Step 4: Completion When all phases complete: Human Checkpoints Checkpoints pause for human verification at critical decision points: After Phase Checkpoint Purpose discovery interview Verify spec captures requirements plan agent Approve implementation plan validate agent (if issues) Acknowledge validation concerns Each implement task Verify phase works before continuing commit Approve commit message and files To skip checkpoints: Run with no checkpoint (advanced users only) Resume Support If workflow is interrupted, resume from last checkpoint: This reads orchestration.yaml and continues from the last incomplete phase. Example Sessions Greenfield Feature TDD Mode python def test rate limiter returns 429 after limit(): limiter = RateLimiter(limit=100, window=60) for in range(100): assert limiter.check("user1") == True assert limiter.check("user1") == False Refactor Mode Error Recovery If a phase fails: If implementation is blocked: Parallel Execution With parallel option, independent phases run concurrently: Only truly independent phases run in parallel. Dependencies are respected. Configuration Default mode preferences Set in .claude/settings.json : Troubleshooting Issue Solution "No continuity ledger found" Run /onboard first or use greenfield mode "Plan validation failed" Review validation output, update plan "Implementation blocked" Check blocker in handoff, resolve dependency "Workflow stuck" Check orchestration.yaml for state, resume or restart Related Skills /discovery interview Deep interview for requirements /plan agent Create implementation plans /validate agent Validate tech choices /implement plan Execute implementation plans /implement task Single task implementation /test driven development TDD workflow /commit Create commits /describe pr Generate PR descriptions /onboard Codebase analysis /research codebase Research existing code /tldr code Code analysis CLI