Skills Map — the router for lich-skills

Most skills help you do the work. This one helps you pick which skill does the work.

A skill collection has a discovery problem: the skills only fire if the agent remembers they exist and reaches for the right one at the right moment. Left to chance, the agent forgets go-no-go and starts building, or hand-rolls a debug crawl instead of running debug-hypothesis. skills-map is the index + decision tree that closes that gap.

It does three things:

1. Identify the phase of work the current task is in.
2. Route to the matching skill via the decision tree.
3. Sequence — most real work chains several skills; this gives the order.

When to Use

• At the start of any non-trivial task, before picking up tools.
• Whenever you catch yourself thinking "is there a skill for this?"
• When a task spans multiple phases and you need the ordering.
• On /skills-map, "which skill", "what can you do", "list my skills".

When NOT to Use

• The task is a one-line answer or a trivial edit — just do it.
• You already know exactly which skill applies — invoke it directly.
• You are mid-skill — finish it; don't re-route every step.

The Map (by phase of work)

   DECIDE        SPEC / PLAN          BUILD          DEBUG         FAN-OUT
 ┌────────┐   ┌──────────────┐   ┌────────────┐  ┌────────────┐ ┌──────────────┐
 │go-no-go│──▶│spec-driven-  │──▶│build-until-│─▶│debug-      │ │subagent-     │
 │ Stage 0│   │dev / -v2     │   │pass        │  │hypothesis  │ │brief         │
 │ gate   │   │ Spec→…→Ship  │   │ red→green  │  │ O→H→E→C    │ │ ≤200w/agent  │
 └────────┘   └──────────────┘   └────────────┘  └────────────┘ └──────────────┘

   RESEARCH                       MEDIA            ANALYZE
 ┌──────────────┬──────────────┐ ┌────────────┐ ┌──────────────┐
 │tavily-search │wiki-aggregate│ │nano-banana │ │google-       │
 │ web fetch    │ N notes→pack │ │ text→image │ │analytics     │
 └──────────────┴──────────────┘ └────────────┘ └──────────────┘

   DESIGN
 ┌──────────────┐
 │frontend-     │
 │design        │
 └──────────────┘

Decision Tree

Walk top to bottom; take the first branch that matches.

START
│
├─ About to start a NEW project / repo / contract?  ───────────▶  go-no-go   (Stage 0 — NO-GO is the default)
│
├─ Feature/refactor touching >1 file, needs a spec first?
│     ├─ hours–days, many files, multiple slices  ─────────────▶  spec-driven-dev-v2
│     └─ single feature, normal scope             ─────────────▶  spec-driven-dev
│
├─ A build / typecheck / lint / test is RED and you want green ─▶  build-until-pass
│
├─ Something is broken and you don't know WHY  ────────────────▶  debug-hypothesis
│
├─ About to spawn subagents / Task / Agent fan-out  ──────────▶  subagent-brief  (compress FIRST)
│
├─ Building a UI / page / component  ──────────────────────────▶  frontend-design
│
├─ Need facts / docs / citations from the web  ───────────────▶  tavily-search
│
├─ Have N≥3 raw research notes to lift into one pack  ─────────▶  wiki-aggregate
│
├─ Need an image generated or edited  ─────────────────────────▶  nano-banana
│
├─ Question about site traffic / GA4 / SEO  ──────────────────▶  google-analytics
│
└─ None match  ───────────────────────────────────────────────▶  no skill; proceed manually

Quick Reference

Typical Sequences

Real work chains skills. The common pipelines:

New project          go-no-go → spec-driven-dev → build-until-pass → (bug?) debug-hypothesis
Long migration       go-no-go → spec-driven-dev-v2 → subagent-brief (per reviewer) → build-until-pass
Build a landing page spec-driven-dev → frontend-design → nano-banana (hero art) → build-until-pass
Research → report    tavily-search → wiki-aggregate
Ship + measure       …build-until-pass → google-analytics (post-launch SEO/traffic)

Skill Rules

1. Route before you reach. When in doubt, run the decision tree before grabbing a tool — picking the wrong skill costs more than the 5 seconds of routing.
2. go-no-go gates everything. If the task is "start X", that branch wins over every build/spec branch below it. Do not skip Stage 0 because you're eager to build.
3. One phase, one skill. Don't stack skills for the same phase. Finish the active skill before re-routing.

Anti-Rationalization

Maintenance

This map is hand-curated. When a skill is added to or removed from this collection, update the phase map, decision tree, and quick-reference table here in the same change. A router that lists skills that don't exist — or omits ones that do — is worse than no router.