# Agile Router

> Routes to the appropriate agile skill based on context. Use when you need guidance on which skill to use — planning, ceremonies, tracking, prototype/UX, TDD, or memory.

- Skill: `djalmajr/agile-router` (Agent Skill)
- Install (CLI): `npx skillmds@latest add djalmajr/agile-router`
- Raw SKILL.md: https://api.skillmd.com/api/skills/djalmajr/agile-router/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: djalmajr (https://skillmd.com/u/djalmajr)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/djalmajr/agile-router

---


# 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), `ask_user_question` (Codex), or `question` (OpenCode) — for the decision points below.

| Decision point | Why structured | Suggested options |
|---|---|---|
| Suggested skill when ambiguous | Routes the work | list the 2–4 candidates with the recommendation flagged |

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:

| Area | Question | Skills |
|---|---|---|
| UI / flow | Need to validate a screen, mockup, or journey? | `/agile-proto` (+ `htm-ui` skill), `/agile-design`, `/ux-flows`, `/ux-persona` |
| Test | Need TDD, coverage, or red-green? | `/agile-tdd` |
| Memory | Wire or query project knowledge? | `/aim-init`, `/aim-query`, `/aim-write` |
| What to create | What planning artifact fits this work? | `/agile-intake`, `/agile-roadmap`, `/agile-epic`, `/agile-story` |
| What ceremony to run | Where are we in the sprint cycle? | `/agile-sprint`, `/agile-review`, `/agile-retro` |
| What to track | How should I report progress? | `/agile-status` (checkpoint, consolidation, closure) |

## 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?

```mermaid
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.

| Size | Description | Artifact | Skill |
|---|---|---|---|
| Extra small | Localized adjustment, 1 file, low risk | Task | `/agile-story` |
| Small | Small delivery, few files, simple validation | Task | `/agile-story` |
| Medium | Vertical delivery, several files, moderate validation | Epic story file or Task | `/agile-epic` or `/agile-story` |
| Large | Multiple coordinated stories, needs decomposition | Epic | `/agile-epic` |
| Extra large | Multi-story initiative, coordination needed | Epic | `/agile-epic` |

## 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

| Skill | Purpose |
|---|---|
| `/agile-intake` | Capture vague problems |
| `/agile-roadmap` | Map multi-phase trajectories with dependencies (any duration) |
| `/agile-epic` | Structure initiatives, decompose into stories |
| `/agile-story` | Execution plan for localized changes |
| `/agile-refinement` | Validate planning artifacts and review code |
| `/agile-status` | Track progress (checkpoint, consolidation, closure) |
| `/agile-sprint` | Sprint planning ceremony |
| `/agile-review` | Sprint review, metrics, and demo |
| `/agile-retro` | Retrospective with improvement actions |
| `/agile-tdd` | TDD coaching and optional enforcement |
| `/agile-proto` | Static browser prototype process (complement: `htm-ui` skill) |
| `/agile-design` | Screens, states, and flows in any design tool |
| `/agile-onboarding` | New team member onboarding |
| `/ux-flows` / `/ux-persona` | Usage-flow catalog and persona walkthroughs |
| `/aim-init` / `/aim-query` / `/aim-write` | Wire and use ai-memory |
| `/agile-router` | This skill — guidance on which skill to use |

## Relationship with the flow

```mermaid
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.