playbooks

home / skills / bbeierle12 / skill-mcp-claude / router-template

router-template skill

/skills/router-template

This skill routes requests to multiple specialized skills by classifying, matching, and loading the best ensembles for production tasks.

npx playbooks add skill bbeierle12/skill-mcp-claude --skill router-template

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.7 KB
---
name: router-template
description: Template for creating router skills. Use as a starting point when building a new router that dispatches to multiple specialized skills. Copy and customize for your domain.
---

# [Domain] Router

Routes to N specialized skills based on task requirements.

## Routing Protocol

1. **Classify** — Identify primary task type from user request
2. **Match** — Find skill(s) with highest signal match
3. **Combine** — Most production tasks need 2-4 skills together
4. **Load** — Read matched SKILL.md files before implementation

## Quick Route

### Tier 1: Core (Always Consider)
| Task Type | Skill | Primary Signal Words |
|-----------|-------|---------------------|
| [task] | `skill-name` | word1, word2, word3 |

### Tier 2: Enhanced (Add When Needed)
| Task Type | Skill | Primary Signal Words |
|-----------|-------|---------------------|
| [task] | `skill-name` | word1, word2, word3 |

### Tier 3: Reference Only
| Task Type | Skill | Primary Signal Words |
|-----------|-------|---------------------|
| [task] | `skill-name` | word1, word2, word3 |

## Signal Matching Rules

### Priority Order
When multiple signals present, resolve by priority:
1. **Explicit framework** — React/Vue/vanilla overrides generic signals
2. **Specific feature** — "multi-step wizard" beats generic "form"
3. **Platform constraint** — mobile/VR/accessibility takes precedence
4. **Default tier** — Fall back to Tier 1 core skills

### Confidence Scoring
- **High (3+ signals)** — Route immediately
- **Medium (1-2 signals)** — Route with Tier 1 defaults
- **Low (0 signals)** — Ask user for clarification

## Common Combinations

### [Scenario Name] (N skills)
```
skill-1 → [what it provides]
skill-2 → [what it provides]
skill-3 → [what it provides]
```
Wiring: [one-line integration summary]

### [Scenario Name] (N skills)
```
skill-1 → [what it provides]
skill-2 → [what it provides]
```
Wiring: [one-line integration summary]

## Decision Table

| Framework | Scale | Features | Route To |
|-----------|-------|----------|----------|
| React | Standard | Auth form | skill-a + skill-b + skill-c |
| Vue | Standard | Data entry | skill-a + skill-d |
| None | Simple | Basic form | skill-e + skill-b |
| Any | Complex | Wizard | skill-f + skill-a + skill-b |

## Fallback Behavior

- **Unknown framework** → Use skill with broadest compatibility
- **No clear signals** → Ask: "What framework?" and "What's the core requirement?"
- **Conflicting signals** → Prefer Tier 1 skills, ask for clarification on Tier 2

## Reference

See `references/integration-guide.md` for:
- Complete wiring patterns
- Code examples for all combinations
- Architecture diagrams
- Edge case handling

Overview

This skill is a router template that dispatches requests to multiple specialized skills. It provides a lightweight protocol for classifying requests, matching relevant skills, and combining them into a multi-skill workflow. Use it as a starting point to build a domain-specific router that coordinates 2–4 skills per task.

How this skill works

The router classifies the user request to identify the primary task type, then scores available skills by signal match. It applies priority rules to resolve conflicting signals, selects the highest-confidence skills, and recommends combinations for production tasks. When signals are weak, the router prompts for clarification to improve routing accuracy.

When to use it

  • Building a coordinator that dispatches work across multiple specialized skills
  • When tasks require combining 2–4 capabilities (e.g., UI, validation, auth)
  • When you need a repeatable protocol for classifying and scoring requests
  • Integrating domain-specific skills with clear precedence and fallback rules
  • Rapidly scaffolding new routers for different application frameworks

Best practices

  • Define clear signal keywords for each skill and group them into tiers
  • Prioritize explicit framework and platform constraints over generic signals
  • Combine complementary skills for production flows rather than single-skill answers
  • Implement a confidence threshold: route immediately for high scores, ask for clarification for low scores
  • Keep wiring patterns small and documented so combinations are predictable

Example use cases

  • Web form builder: classify form type, attach validation, UI rendering, and auth skills
  • Multi-platform feature: prefer mobile-optimized skills when a mobile signal is present
  • Complex wizard: route to orchestration, state management, and UI stepper skills
  • Quick prototype: use Tier 1 core skills as defaults, then add Tier 2 enhancements
  • Fallback handling: detect unknown frameworks and route to the broadest-compatible skill

FAQ

How many skills should be combined for a typical production task?

Most production tasks combine 2–4 skills: one for core functionality, one or two for features, and one for integration or platform concerns.

What if multiple signals conflict?

Resolve by priority: explicit framework > specific feature > platform constraint > default tier. If still ambiguous, prefer core skills and ask the user a clarifying question.