Use skill

/use — Skill Sweep Dispatcher

Overview

Never work from memory when an installed skill covers the task. This meta-skill sweeps the entire installed-skill inventory, selects every skill relevant to the task, loads them all, and then does the task with their combined guidance.

The failure mode this fixes: an agent receives a task, feels competent, and answers from memory — invoking zero of the 5+ installed skills whose descriptions literally name the task. Partial recall of a skill is not having read it.

When to use

• The user typed /use <task> — the text after /use is the task.
• The user asks "what skills apply?" / "use whatever skills fit".
• You're starting a task and haven't checked the inventory yet.

When NOT to use: pure conversation, trivial one-line answers, or when the user already named the exact skills to load (just load those).

Procedure

1. State the task in one line. If /use had no task text, ask for it — nothing else.
2. Enumerate the full inventory. Primary source: the available-skills list already in your context (system prompt / system-reminder). Fallback when no list is in context (e.g. non-Claude agents): list the skill directories and read each SKILL.md frontmatter — ~/.claude/skills/, ~/.codex/skills/, plus any project .claude/skills/. Sweep ALL of it; do not stop at the first plausible match.
   • When changing a skill, resolve the installed copy to its canonical source-controlled repository before editing. Compare bytes, inspect the installer or provenance, and preserve unrelated work. Never edit a plugin cache, generated copy, or vendored snapshot as if it were the source. If ownership is ambiguous, report the ambiguity instead of guessing.
3. Select every relevant skill. A skill is relevant if its description's triggers overlap the task's:
   • work type (new feature → brainstorming/planning; bug → debugging; review → review skills; estimate → outside-view)
   • domain/artifact (UI screen, API, form, doc, deploy, git)
   • platform/technology (iOS, React, CSS, SQL)
   • quality dimensions the task implies (accessibility, performance, security, testing) Cast wide — include process skills, domain skills, AND verification skills. When in doubt about a borderline skill, include it; you can discard after reading.
4. Dedupe families. If a family dispatcher exists (e.g. ios, design, dec, blind, userflow, biz, pm), invoke the dispatcher once instead of each member — unless the task names a specific member skill.
5. Declare the roster. Before loading, output one line: Skills matched (N): a, b, c…. Then load them ALL — no cap. If N is huge (>12 after family dedupe), that's still the roster; the user asked for all of them.
6. Load in this order: process skills (brainstorming, planning, debugging) → domain/implementation skills → verification/review skills. In Claude Code, load via the Skill tool. In other agents, Read each skill's SKILL.md.
7. Do the task applying the combined guidance. Where two skills conflict, follow the more specific one and say so. Where a loaded skill's process (interactive Q&A gates, mandated report files) conflicts with the user's explicit instructions (e.g. "answer in one message"), the user instruction wins — note the conflict in one line and fold the skill's substance into the deliverable.
8. Footer: end with Skills applied: a, b, c (only the ones that actually shaped the output).

Quick reference — task signal → skill families

Task signal	Look for skills about
build / add / create feature	brainstorming, planning, TDD, the domain itself
bug / broken / flaky / error	systematic debugging, root-cause, testing
screen / UI / component / layout	design systems, flows, components, accessibility, platform HIG
review / audit / "is this good"	code review, security, a11y audit, heuristics, blind-spot
estimate / plan / roadmap	outside-view, premortem, prioritization
business / pricing / strategy	business frameworks, negotiation, focus
product discovery / strategy / metrics / AI product	pm dispatcher
ship / deploy / release	verification, preflight, release checklists

Common mistakes

• Working from memory: "I know React forms" → the inventory has form-flow, a11y, and component-state skills that know more. Sweep first.
• First-match satisficing: loading one skill and starting. The instruction is every relevant skill, not the best one.
• Skipping process skills: jumping to domain skills without brainstorming/debugging discipline when the work type calls for it.
• Double-loading families: invoking a dispatcher AND five of its members. Dispatcher covers the family.
• Description-recall as reading: deciding a skill "basically says X" from its description. Load it; skills evolve.
• Silent roster: loading skills without declaring the matched list — the user can't correct scope they can't see.
• Editing the installed copy: changing ~/.codex/skills, ~/.claude/skills, a plugin cache, or a vendor snapshot without locating the canonical Git source. The apparent fix will drift or be overwritten.

Red flags — stop and re-sweep

• "This doesn't really need a skill" — check the inventory anyway; that instinct is the failure mode.
• "Too many skills matched, I'll trim to the top 2" — the point of /use is all of them.
• "I remember what that one says" — you remember its description. Read the skill.

Always-on mode (recommended)

Typing /use requires knowing this skill exists — the same discovery problem it solves. Fix: make the sweep the default by adding one directive to your agent's global instruction file, so /use becomes the manual override instead of something to remember.

Drop this block into the file for whichever agents you run. Keep the MUST/imperative wording — smoke-testing showed milder phrasing ("run the sweep before working") gets silently skipped by fast models, while Codex-class models honor it either way:

## Skill Sweep — always on (MANDATORY)
BEFORE answering any non-trivial task (build, debug, review, design, plan — anything
beyond a one-line factual answer), you MUST run the `use` skill sweep: enumerate the
installed skill inventory, select every skill relevant to the task, read those skills,
and apply them. Output a "Skills matched (N): ..." line before your answer and end
with "Skills applied: ...". Do NOT skip this because the task seems simple enough to
answer from memory — that instinct is the exact failure this rule exists to prevent.

For agents without a native skills folder, replace "run the use skill sweep" with: "read <repo path>/use-skill/SKILL.md with your file-read tool and follow its procedure (inventory at ~/.claude/skills/, one subfolder per skill, description in each SKILL.md frontmatter)".

Agent	Global instruction file
Claude Code	~/.claude/CLAUDE.md
Codex CLI	~/.codex/AGENTS.md
Gemini CLI	~/.gemini/GEMINI.md
opencode	~/.config/opencode/AGENTS.md
Cursor / Copilot CLI	AGENTS.md in each project (no reliable global file)

For agents where this skill isn't installed as a native skill, change the directive's second line to: "follow the procedure in <repo path>/use-skill/SKILL.md".

Related

• find-skills — discovers and installs NEW skills from the ecosystem (skills.sh). /use routes skills you already have; if the sweep finds a gap, suggest find-skills.
• product-management-skills — /pm dispatcher for discovery, strategy, positioning, pricing, metrics, experiments, delivery, and AI-product decisions.