Workflow Routing

Workflow Routing: Superpowers + GSD

Announce at start: "Workflow Routing skill activated."

Route every task to the right toolchain. Superpowers handles task-level quality (TDD, debugging, design, review). GSD handles project-level orchestration (phases, milestones, persistent state). They are complementary — never competing.

Detection: Is GSD Active?

Check the current working directory:

digraph detect {
    ".planning/ exists?" [shape=diamond];
    "ROADMAP.md exists?" [shape=diamond];
    "GSD ACTIVE" [shape=box, style=filled, fillcolor=lightblue];
    "GSD NOT ACTIVE" [shape=box, style=filled, fillcolor=lightyellow];

    ".planning/ exists?" -> "ROADMAP.md exists?" [label="yes"];
    ".planning/ exists?" -> "GSD NOT ACTIVE" [label="no"];
    "ROADMAP.md exists?" -> "GSD ACTIVE" [label="yes"];
    "ROADMAP.md exists?" -> "GSD NOT ACTIVE\n(stale or pre-roadmap)" [label="no"];
}

GSD active signals: .planning/PROJECT.md, .planning/ROADMAP.md, .planning/STATE.md all present.

Primary Routing Decision

digraph route {
    "Task received" [shape=doublecircle];
    "GSD active?" [shape=diamond];
    "Task in current phase scope?" [shape=diamond];
    "Scope: multi-phase?" [shape=diamond];
    "Use GSD commands" [shape=box, style=filled, fillcolor=lightblue];
    "Use /gsd:quick" [shape=box, style=filled, fillcolor=lightcyan];
    "Suggest /gsd:new-project" [shape=box, style=filled, fillcolor=lightblue];
    "Use Superpowers skills" [shape=box, style=filled, fillcolor=lightyellow];

    "Task received" -> "GSD active?";
    "GSD active?" -> "Task in current phase scope?" [label="yes"];
    "GSD active?" -> "Scope: multi-phase?" [label="no"];
    "Task in current phase scope?" -> "Use GSD commands" [label="yes"];
    "Task in current phase scope?" -> "Use /gsd:quick" [label="no, small/unrelated"];
    "Scope: multi-phase?" -> "Suggest /gsd:new-project" [label="yes"];
    "Scope: multi-phase?" -> "Use Superpowers skills" [label="no"];
}

Scope Signals

Combined Workflows

Multi-Phase Project (GSD + Superpowers for Quality)

/brainstorming                    ← Superpowers: design before planning
  ↓
/gsd:new-project                  ← GSD: project structure + roadmap
  ↓
/gsd:plan-phase N                 ← GSD: detailed phase plan
  ↓
/gsd:execute-phase N              ← GSD: runs tasks with atomic commits
  ├── /systematic-debugging       ← Superpowers: if bug during execution
  └── /test-driven-development    ← Superpowers: TDD within each task
  ↓
/requesting-code-review           ← Superpowers: review before moving on
  ↓
/gsd:verify-work N                ← GSD: UAT validation
  ↓
/verification-before-completion   ← Superpowers: evidence-based "done"
  ↓
/gsd:progress                     ← GSD: route to next phase

Single-Session Task (Superpowers Only)

/brainstorming                    ← Explore intent, produce spec
  ↓
/writing-plans                    ← Break into TDD tasks
  ↓
/executing-plans                  ← Run tasks sequentially
  OR /subagent-driven-development ← Run tasks via parallel subagents
  ├── /systematic-debugging       ← If issues arise
  └── /test-driven-development    ← TDD per task
  ↓
/requesting-code-review           ← Review before done
  ↓
/verification-before-completion   ← Prove it works
  ↓
/finishing-a-development-branch   ← Merge, PR, or cleanup

Edge Case Decision Trees

"Debug this" — Which Tool?

digraph debug {
    "Bug reported" [shape=doublecircle];
    "GSD active?" [shape=diamond];
    "Bug related to current phase?" [shape=diamond];
    "Will span multiple sessions?" [shape=diamond];
    "/gsd:debug" [shape=box, style=filled, fillcolor=lightblue];
    "/systematic-debugging" [shape=box, style=filled, fillcolor=lightyellow];

    "Bug reported" -> "GSD active?";
    "GSD active?" -> "Bug related to current phase?" [label="yes"];
    "GSD active?" -> "Will span multiple sessions?" [label="no"];
    "Bug related to current phase?" -> "/gsd:debug" [label="yes"];
    "Bug related to current phase?" -> "/systematic-debugging\nthen /gsd:quick to commit" [label="no"];
    "Will span multiple sessions?" -> "/gsd:debug" [label="yes, need persistence"];
    "Will span multiple sessions?" -> "/systematic-debugging" [label="no, fix it now"];
}

"Plan this" — Which Tool?

digraph plan {
    "Planning requested" [shape=doublecircle];
    "GSD active?" [shape=diamond];
    "Feature in roadmap?" [shape=diamond];
    "/gsd:plan-phase N" [shape=box, style=filled, fillcolor=lightblue];
    "/gsd:add-phase or /gsd:quick" [shape=box, style=filled, fillcolor=lightcyan];
    "/brainstorming then /writing-plans" [shape=box, style=filled, fillcolor=lightyellow];

    "Planning requested" -> "GSD active?";
    "GSD active?" -> "Feature in roadmap?" [label="yes"];
    "GSD active?" -> "/brainstorming then /writing-plans" [label="no"];
    "Feature in roadmap?" -> "/gsd:plan-phase N" [label="yes, phase N"];
    "Feature in roadmap?" -> "/gsd:add-phase or /gsd:quick" [label="no"];
}

Scope Escalation (Superpowers → GSD)

During /brainstorming, if scope grows beyond single-session:

Detection:
  - 5+ independent subsystems identified
  - 2+ weeks estimated work
  - Multiple architectural decisions needed
  - User says "this is bigger than I thought"

Action:
  "This needs GSD's phase structure for persistence across sessions.
   Ready to initialize /gsd:new-project with the spec we just brainstormed?"

  → Convert brainstorming output into GSD project input
  → User confirms escalation

User Picks Wrong Tool

User wants Superpowers for a large project:

"This sounds like it needs 5+ phases and multiple sessions. GSD would give you persistent state and milestone tracking. Want to use /gsd:new-project instead?"

User wants GSD for a tiny task:

"This is small enough for a single session — GSD's ceremony would slow us down. Let's use /brainstorming → /writing-plans → /executing-plans instead."

Always respect the user's final choice. Suggest, don't force.

Universal Rules (Both Toolchains)

1. Always /brainstorming before creative work — regardless of GSD or Superpowers
2. Always /verification-before-completion before claiming done — no exceptions
3. Always /requesting-code-review after significant implementation — works in both contexts
4. Always /test-driven-development when writing code — embedded discipline, not optional
5. Always /systematic-debugging before proposing fixes — root cause first

Quick Reference: Command Mapping

Red Flags — You're Routing Wrong