Routing Skill

Analyze spec content and route /implement to appropriate agents based on what the spec defines.

When Used

| Command | Routing Logic | | ------------ | ----------------------------------------------- | | /implement | Read approved spec → detect type → route agents |

NOT used by: /start, /plan, /ship, /guide, /mode (direct routing)

Implement Routing

Decision Flow

/implement
    │
    ▼
┌────────────────────────────────────────────────────┐
│  1. FIND: Locate approved spec                     │
│     Check: specs/{feature}/design.md               │
│     Verify: "Status: Approved" in frontmatter      │
└────────────────────────────────────────────────────┘
    │
    ▼
┌────────────────────────────────────────────────────┐
│  2. ANALYZE: Read spec content                     │
│     Parse: design.md sections and keywords         │
│     Identify: Backend, frontend, docs, eval scope  │
└────────────────────────────────────────────────────┘
    │
    ▼
┌────────────────────────────────────────────────────┐
│  3. ROUTE: Based on detected type                  │
└────────────────────────────────────────────────────┘
    │
    ├── Backend only → code-agent
    │
    ├── Frontend only → ui-agent
    │
    ├── Backend + Frontend → code-agent → ui-agent (sequential)
    │
    ├── Documentation only → docs-agent
    │
    ├── Evaluation only → eval-agent
    │
    └── Mixed → Route to multiple agents per section

Spec Content Detection

| Detected In Spec | Type | Routes To | | -------------------------------------------------- | -------- | ---------- | | tRPC, Prisma, API, database, model, schema, server | Backend | code-agent | | React, component, form, UI, hook, page, layout | Frontend | ui-agent | | README, documentation, guide, tutorial | Docs | docs-agent | | evaluation, grader, benchmark, pass@k, LLM test | Eval | eval-agent |

Section-Based Detection

The spec's design.md sections determine routing:

## Architecture
├── "Database" subsection → Backend component
├── "API" subsection → Backend component
├── "Components" subsection → Frontend component
└── "Pages" subsection → Frontend component

## Implementation
├── Tasks mention Prisma/tRPC → Backend
├── Tasks mention React/shadcn → Frontend
└── Tasks mention both → Mixed (code-agent → ui-agent)

Examples

| Spec Content | Detected Type | Route | | -------------------------------- | ------------- | ----------------------- | | Prisma schema + tRPC router only | Backend | code-agent | | React components + forms only | Frontend | ui-agent | | Prisma + tRPC + React components | Full-stack | code-agent → ui-agent | | README + API docs | Docs | docs-agent | | Grader + test cases + benchmarks | Eval | eval-agent | | Prisma + README | Mixed | code-agent + docs-agent |

---

No Spec Found

When /implement is called but no approved spec exists:

┌─────────────────────────────────────────────────────────────────┐
│  /implement                                                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ERROR: No approved spec found                                   │
│                                                                  │
│  Checked locations:                                              │
│  • specs/{feature}/design.md - Not found                         │
│  • specs/{feature}/requirements.md - Not found                   │
│                                                                  │
│  To create a spec, run:                                          │
│  /plan                                                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Ambiguous Spec

When spec content is unclear:

┌─────────────────────────────────────────────────────────────────┐
│  /implement                                                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Spec found but type unclear: specs/utils/design.md              │
│                                                                  │
│  What type of implementation is this?                            │
│                                                                  │
│  1. Backend (API, database, server logic)     → code-agent       │
│  2. Frontend (UI, components, styling)        → ui-agent         │
│  3. Full-stack (both)                         → code → ui        │
│  4. Documentation                             → docs-agent       │
│  5. LLM evaluation                            → eval-agent       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

---

Routing Decision Matrix

| Spec Content | Detected Scope | Route | | ----------------------------------- | -------------- | ----------------------- | | Prisma, tRPC, API only | Backend | code-agent | | React, components, UI only | Frontend | ui-agent | | Both backend + frontend sections | Full-stack | code-agent → ui-agent | | README, documentation only | Docs | docs-agent | | Evaluation, grader, benchmarks only | Eval | eval-agent | | Backend + docs sections | Mixed | code-agent → docs-agent | | Frontend + eval sections | Mixed | ui-agent → eval-agent | | Unclear or empty spec | Unknown | Ask for clarification |

---

Algorithm

interface RoutingResult {
  agents: ("code-agent" | "ui-agent" | "docs-agent" | "eval-agent")[];
  reason: string;
  spec: { path: string; sections: string[] };
}

function routeImplement(specPath: string): RoutingResult {
  // 1. Read and parse spec
  const spec = readSpec(specPath);
  if (!spec) {
    throw new Error("No approved spec found. Run /plan first.");
  }

  // 2. Detect sections
  const sections = detectSections(spec.content);

  // 3. Build agent sequence
  const agents: RoutingResult["agents"] = [];

  if (hasBackendIndicators(sections)) {
    agents.push("code-agent");
  }

  if (hasFrontendIndicators(sections)) {
    agents.push("ui-agent");
  }

  if (hasDocsIndicators(sections)) {
    agents.push("docs-agent");
  }

  if (hasEvalIndicators(sections)) {
    agents.push("eval-agent");
  }

  // 4. Handle ambiguous case
  if (agents.length === 0) {
    throw new Error(
      "Unable to determine implementation type. Please clarify: backend, frontend, full-stack, docs, or eval?"
    );
  }

  return {
    agents,
    reason: `Detected: ${agents.join(", ")}`,
    spec: { path: specPath, sections },
  };
}

function detectSections(content: string): string[] {
  const indicators = {
    backend: /prisma|trpc|api|database|schema|mutation|query|server/i,
    frontend: /react|component|form|ui|hook|page|layout|shadcn/i,
    docs: /readme|documentation|guide|tutorial/i,
    eval: /evaluation|grader|benchmark|pass@k|llm test/i,
  };

  return Object.entries(indicators)
    .filter(([_, regex]) => regex.test(content))
    .map(([type]) => type);
}

---

Error Handling

| Scenario | Handling | | -------------------- | ---------------------------------------------- | | No spec found | Error: Run /plan first | | Spec not approved | Error: Get spec approved first | | Spec unreadable | Error: Cannot parse spec file | | No sections detected | Ask user to clarify implementation type | | Multiple agent types | Execute sequentially (code → ui → docs → eval) |

---

Output

Successful Routing

## Routing: SUCCESS

**Spec:** specs/user-authentication/design.md
**Detected:** Full-stack (backend + frontend)

### Execution Chain

1. **code-agent** (backend)
   - code-researcher → code-writer → code-validator
   - Scope: Prisma schema, tRPC router

2. **ui-agent** (frontend)
   - ui-researcher → ui-builder → ui-validator
   - Scope: Login form, auth context

3. **check-agent** (verification)
   - Parallel: build, types, lint, tests, security

No Spec Found

## Routing: ERROR

**Reason:** No approved spec found

### Next Steps

1. Run `/plan` to create a spec
2. Review and approve the spec
3. Run `/implement` again

Clarification Needed

## Routing: CLARIFY

**Spec:** specs/utils/design.md
**Reason:** Unable to determine implementation type

### Detected Content

- No backend keywords (Prisma, tRPC, API)
- No frontend keywords (React, component, UI)
- No docs keywords (README, guide)
- No eval keywords (grader, benchmark)

### Question

What type of implementation is this?

1. Backend (code-agent)
2. Frontend (ui-agent)
3. Full-stack (code-agent → ui-agent)
4. Documentation (docs-agent)
5. Evaluation (eval-agent)