# Use

> Use when the user invokes /use followed by a task, asks "which skills apply to this", or hands over any non-trivial task where installed skills might exist but haven't been loaded — especially when about to work from memory in a domain the skill inventory covers.

- Skill: `jpoindexter/use` (Agent Skill, multi-file: 5 files)
- Install (CLI): `npx skillmds@latest add jpoindexter/use`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jpoindexter/use/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: jpoindexter (https://skillmd.com/u/jpoindexter)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/jpoindexter/use

---


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

```markdown
## 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`](https://github.com/jpoindexter/product-management-skills) — `/pm` dispatcher for discovery, strategy, positioning, pricing, metrics, experiments, delivery, and AI-product decisions.