Router

Use this skill to decide which agile skill is appropriate and get directed to the correct one.

Initial context received via slash: $ARGUMENTS

If $ARGUMENTS is filled, use as context to determine the right skill. If empty, ask the user what they need help with.

Prompting

Follow the project-wide convention in CLAUDE.md / AGENTS.md ("Skill Prompting Conventions"). Use the harness's structured-question tool — AskUserQuestion (Claude Code), askuserquestion (Codex), or question (OpenCode) — for the decision points below.

Free-form prompts (no structured tool):

• Problem description (so the router can decide)

No-pause mode: if the user has explicitly disabled mid-skill clarification, pick the highest-confidence recommendation and proceed; surface the decision and reasoning rather than asking.

Scope

This skill covers these areas. Resolve UI / test / memory first, then fall through to planning:

Decision tree

First: UI, test, or memory?

• Clickable browser prototype / validate a flow without a backend → /agile-proto (complement: htm-ui skill)
• Screens and states in a design tool (Paper, Figma, Pen.dev, Penpot…) → /agile-design
• Walk the app (or the served proto) as a user → /ux-flows, /ux-persona
• TDD, coverage, red-green, test enforcement → /agile-tdd
• Wire ai-memory, recall, durable annotation → /aim-init, /aim-query, /aim-write
• Otherwise → planning, ceremony, or tracking below

Planning: What artifact do I need?

flowchart TD
    A[New problem or request] --> B{Is the problem clear?}
    B -- No --> C["/agile-intake"]
    B -- Yes --> D{Multi-phase trajectory<br/>with dependencies?}
    D -- Yes --> I["/agile-roadmap"]
    I --> G["/agile-epic"]
    D -- "No, single initiative" --> E{What size?}
    E -- "Small, localized" --> F["/agile-story"]
    E -- "Medium/large, needs decomposition" --> G
    C --> H{Intake recommends...}
    H -- Multi-phase trajectory --> I
    H -- Single initiative --> G
    H -- Small/clear --> F

Note on /agile-roadmap: Roadmap is NOT defined by time horizon (e.g., "3-12 months"). It is defined by trajectory complexity. Even a 4-week initiative benefits from a roadmap if it has multiple sequenced phases with dependencies between them.

Note on /agile-epic: Handles both the epic overview and story decomposition. There is no separate story skill. Medium work that needs richer acceptance criteria goes through /agile-epic for structure, or directly to /agile-story if it's a single vertical delivery.

Ceremonies: Where am I in the cycle?

• Starting a sprint? → /agile-sprint
• Sprint just ended? → /agile-review (demo deliveries) then /agile-retro (reflect on process)
• Backlog items unclear? → /agile-epic (decompose) or run /agile-refinement (validate)
• Need metrics? → /agile-review (metrics are a section of the review artifact)

Tracking: How do I report progress?

• Quick daily checkpoint? → /agile-status (checkpoint mode)
• Period or milestone consolidation? → /agile-status (consolidation mode)
• Delivery finished? → /agile-status (closure mode)

Light sizing

Internal reference for AI agent — not exposed to users. Use plain language when communicating the recommendation.

When to use roadmap vs epic

Sizing alone is not enough to decide between roadmap and epic. Use this checklist:

Use /agile-roadmap when 2+ apply (regardless of duration):

• Multiple initiatives need sequencing (can't all run in parallel)
• Decisions today affect future decisions (local optimization can become tech debt)
• Stakeholders need to see the whole journey before approving individual steps
• External dependencies (other teams, vendors, deadlines)
• Total complexity exceeds what fits in a single epic

Use /agile-epic when:

• Single coordinated initiative with clear scope
• Can be broken into stories without needing a parent plan
• Fits on one delivery wave (no distinct phases with different goals)

Anti-pattern: Assume roadmap = "long-term strategic plan". A 4-week work with 5 phases and hard ordering also benefits from a roadmap. The criterion is trajectory complexity, not duration.

Process

1. Listen to the user's context.
2. Determine which area applies: UI/test/memory, planning, ceremony, or tracking.
3. Apply the decision tree for that area.
4. Recommend the specific skill with a brief explanation.
5. Confirm with the user before they proceed.

Rules

• This is a router skill — it evaluates and directs, but does not produce artifacts.
• If the problem isn't clear, suggest /agile-intake before routing.
• Use plain language when explaining the recommendation. Do not reference size codes.
• Always confirm the recommendation with the user.

Available skills

Relationship with the flow

flowchart LR
    A["/agile-intake"] --> B["/agile-roadmap"]
    B --> C["/agile-epic"]
    C --> D["/agile-story"]
    D --> E[execution]
    E --> F["/agile-status"]
    F --> G["/agile-review"]
    G --> H["/agile-retro"]

This skill is a router. It evaluates and directs, but does not produce the final artifact. For specific work, use the recommended skill directly.