/find-skills-combo

name: find-skills-combo
description: Discover and recommend **combinations** of agent skills to complete complex, multi-faceted tasks. Provides two recommendation strategies — **Maximum Quality** (best skill per subtask) and **Minimum Dependencies** (fewest installs). Use this skill whenever the user wants to find skills, asks "how do I do X", "find a skill for X", or describes a task that likely requires multiple capabilities working together. Also use when the user mentions composing workflows, building pipelines, or needs help across several domains at once — even if they only say "find me a skill". This skill supersedes simple single-skill search by decomposing the task into subtasks and assembling an optimal skill portfolio.

Find Skills Combo

Discover and install **skill combinations** from the open agent skills ecosystem. Unlike single-skill search, this skill decomposes complex tasks into subtasks, searches for candidates per subtask, evaluates coverage, and recommends two strategies: **Maximum Quality** (best skill per subtask, highest output quality) and **Minimum Dependencies** (fewest installs, lean setup). Users pick the strategy that fits their priorities.

When to Use This Skill

Use this skill when the user:

• Asks "how do I do X" where X involves multiple capabilities or domains
• Says "find a skill for X" or "is there a skill for X"
• Describes a task that spans several concerns (e.g., "build a quarterly report with charts, risk analysis, and executive summary")
• Wants to compose a workflow from multiple skills
• Asks "can you do X" where X is a complex, multi-step task
• Expresses interest in extending agent capabilities for a non-trivial project

**Fallback**: If the task is genuinely single-domain and simple (one clear capability), skip the decomposition — run a single `npx skills find` query, present results, and offer to install. Don't over-engineer simple requests.

What is the Skills CLI?

The Skills CLI (`npx skills`) is the package manager for the open agent skills ecosystem.

**Key commands:**

• `npx skills find [query]` — Search for skills by keyword
• `npx skills add <package>` — Install a skill from GitHub or other sources
• `npx skills add <package> -g -y` — Install globally, skip confirmation
• `npx skills check` — Check for skill updates
• `npx skills update` — Update all installed skills

**Browse skills at:** https://skills.sh/

---

The 5-Phase Pipeline

For complex tasks, follow all five phases in order. For simple tasks, see the Fallback section above.

Phase 1: Task Decomposition

Break the user's request into independent subtasks. Each subtask represents a distinct capability needed to complete the overall task.

**Step 1: Extract Task-Specific Constraints**

Before decomposing, scan the user's request for **task-specific constraints** — these are requirements that narrow the problem space and must be preserved in the subtasks. Look for:

• **Domain-specific terminology**: Jargon, proper nouns, named standards, or specialized vocabulary the user explicitly uses (e.g., "WCAG 2.1 AA compliance", "GAAP reporting", "OpenAPI 3.1 spec"). These terms signal that generic skills won't suffice — the subtask must target this exact domain.
• **Scenario constraints**: Environmental or contextual restrictions (e.g., "offline-only", "must run in CI", "single-page app with no backend", "monorepo with pnpm workspaces"). These filter out skills that technically do the right thing but in the wrong context.
• **Format / output requirements**: Specific file formats, templates, or delivery formats (e.g., "output as PDF", "Helm chart", "Jupyter notebook", "Markdown with Mermaid diagrams").
• **Toolchain lock-ins**: Explicit technology choices the user has already committed to (e.g., "using Svelte, not React", "PostgreSQL only", "must integrate with our existing FastAPI backend").

Collect these into a **Constraints List** — a flat list of non-negotiable requirements extracted verbatim (or near-verbatim) from the user's request. Every subtask you create must trace back to at least one constraint, and no constraint should be orphaned.

**Step 2: Decompose into Subtasks**

1. Read the user's request carefully. Identify every distinct outcome or deliverable they need. 2. Group related outcomes into subtasks. Each subtask should be a "capability unit" — something one skill could plausibly handle. 3. Write a short completion criterion for each subtask so you know what "covered" means later. 4. **Attach relevant constraints** from the Constraints List to each subtask. A subtask without any attached constraint is likely too generic — refine it. A constraint not attached to any subtask is a gap — either create a subtask for it or fold it into an existing one.

**Constraints:**

• Aim for 2–7 subtasks. Fewer than 2 means the task is simple — use the fallback. More than 7 means you're splitting too fine — merge related items.
• Each subtask needs a clear boundary. If two subtasks always require the same skill, merge them.
• **Preserve the user's own words**: When a subtask maps to a domain-specific term the user used, keep that term in the subtask description and completion criteria — don't paraphrase it into a generic synonym. This ensures Phase 2 keyword generation stays precise.

**Output format** (present this to the user for confirmation):

Constraints List:

• C1: `[verbatim constraint from user]`
• C2: `[verbatim constraint from user]`
• ...

| ID | Subtask | Completion Criteria | Constraints | |----|---------|---------------------|-------------| | S1 | ... | ... | C1, C3 | | S2 | ... | ... | C2 |

Before proceeding to Phase 2, briefly show the user the decomposition and constraints list: "I've identified N constraints and broken this into M subtasks — does this look right?" If they want to adjust, iterate. Don't spend too long here — a reasonable decomposition is better than a perfect one.

Phase 2: Precision-Focused Search

For each subtask,