find-skills

Overview of find-skills skill

What the find-skills skill does

The find-skills skill helps an agent discover relevant installable skills in the broader skills ecosystem, then guide the user toward installing the right one. It is best used when the real question is not “solve this task directly,” but “is there already a skill for this job?”

Who should install find-skills skill

find-skills is a strong fit for users who regularly ask for new agent capabilities, workflow extensions, domain-specific help, or reusable tooling. It is especially useful for builders, operators, and prompt designers who want faster skill discovery instead of manually browsing repositories.

The job-to-be-done it handles best

The main job of the find-skills skill is triage: turn a vague request like “can you help with testing, deployment, or design?” into a more precise search and installation path. It reduces guesswork when the user likely needs a specialized skill rather than a one-off answer.

Why use find-skills instead of a generic prompt

A generic prompt may brainstorm possible tools, but find-skills is designed to recognize when a request maps to the skill ecosystem and to route the user toward search, installation, and next-step commands such as npx skills find and npx skills add. That makes it more actionable for Skill Discovery than a plain chat response.

What matters most before installing

This is a lightweight discovery skill, not a domain skill itself. It does not add testing, design, or deployment capability on its own; it helps locate those capabilities. Install it if you want better discovery and install guidance. Skip it if you already know the exact skill you need.

How to Use find-skills skill

Install context for find-skills install

Install the find-skills skill from the Vercel Labs skills repository:

npx skills add https://github.com/vercel-labs/skills --skill find-skills

This assumes you are using the Skills CLI ecosystem referenced by the skill itself.

Core commands you will use with it

The skill points users toward the Skills CLI workflow:

• npx skills find [query]
• npx skills add <package>
• npx skills check
• npx skills update

In practice, find-skills is most useful before installation of another skill, not after.

What input the skill needs to work well

The find-skills skill works best when the request includes:

• the task or outcome needed
• the domain or tech stack
• whether the user wants discovery, installation, or comparison
• any constraints such as local-only, framework, language, or hosting preferences

Weak input: “Find me a skill.”

Better input: “Find a skill for React component testing in a TypeScript repo, ideally something installable through the Skills CLI.”

Turn a rough request into a strong find-skills usage prompt

A good find-skills usage pattern is:

1. State the goal.
2. Name the domain.
3. Add constraints.
4. Ask for search terms or install candidates.

Example:

“Use find-skills to help me discover a skill for deployment automation. I’m working with Next.js on Vercel, and I want something that improves release workflow rather than general DevOps advice. Suggest what to search for with npx skills find and what to inspect before installing.”

This gives the skill enough structure to narrow the search.

Best workflow for Skill Discovery

A practical workflow is:

1. Clarify the user’s real job.
2. Identify the domain and desired capability.
3. Search with npx skills find [query].
4. Review the candidate skill’s SKILL.md.
5. Install the best match with npx skills add ....
6. Re-run or refine the query if the first result is too broad.

This makes find-skills for Skill Discovery useful as a front door to the ecosystem rather than a passive catalog entry.

Repository files to read first

For this skill, the important source file is:

• skills/find-skills/SKILL.md

Because there are no substantial support files listed for this skill, most of the value is in the usage criteria and CLI guidance inside SKILL.md. Read that first before judging the skill as too simple; its purpose is routing, not deep automation.

How find-skills decides when to trigger

The skill is meant for requests like:

• “how do I do X?”
• “find a skill for X”
• “is there a skill that can do X?”
• “can you help me extend agent capabilities?”

It is less about solving the task directly and more about noticing that a reusable skill may already exist.

What good search queries look like

When calling npx skills find, prefer capability-plus-context queries:

• npx skills find react testing
• npx skills find design system
• npx skills find deployment workflow
• npx skills find api documentation

Avoid queries that are too abstract, like productivity or coding help, unless you plan to refine them immediately.

Practical tips that improve output quality

Ask the skill to return:

• 2 to 5 candidate search phrases
• the best first query to try
• signs of a good match
• reasons a candidate skill may be too broad or too narrow

That turns find-skills guide output into something operational instead of just descriptive.

Common misread of this skill

A common mistake is expecting find-skills to execute the downstream task. It does not write tests, deploy apps, or generate designs by itself. It improves discovery, selection, and installation of another skill that does those things.

find-skills skill FAQ

Is find-skills skill worth installing if I can browse skills manually

Yes, if you often start from user intent rather than a known package name. find-skills is helpful when the problem is ambiguous and you need a repeatable way to map requests to skill search queries and install paths.

Is find-skills beginner friendly

Yes. The scope is narrow and the commands are simple. A beginner can use the find-skills skill to learn the basic Skills CLI flow without committing to a complex domain-specific setup first.

When should I not use find-skills

Do not use find-skills when:

• you already know the exact skill to install
• you need direct execution of a task right now
• the request is too vague to classify even at a domain level

In those cases, either install the known skill directly or clarify the problem before searching.

How is this different from ordinary prompting

Ordinary prompting may suggest ideas, but find-skills gives a tighter workflow around ecosystem discovery and installation. Its value is not hidden complexity; it is consistent routing to search and install actions that users can actually run.

Does find-skills cover the whole ecosystem

It is designed around the open skills ecosystem and the Skills CLI workflow mentioned in SKILL.md. If a capability exists outside that ecosystem, the skill may still help frame the search, but its strongest guidance is for CLI-manageable skills.

What if the first result is wrong

That is normal for broad queries. Refine by adding domain, stack, output type, or operational constraints. “testing” is weak; “playwright e2e testing for next.js” is much stronger.

How to Improve find-skills skill

Give find-skills clearer intent signals

The single biggest quality lever is specificity. Tell find-skills whether you want:

• a skill recommendation
• search query suggestions
• install guidance
• comparison between candidates

Without that, responses tend to stay generic.

Include the user environment early

Mention framework, language, platform, and repo context upfront. For example:

“Use find-skills to suggest installable skills for CI testing in a Python monorepo on GitHub Actions.”

This reduces false-positive matches from adjacent domains.

Ask for narrowing questions before searching

If your initial request is broad, tell the skill to ask 2 or 3 clarifying questions first. That often produces better search terms than starting with an underspecified query.

Improve find-skills usage with better output format requests

Ask the skill to answer in a structure like:

• recommended search terms
• likely matching skill categories
• best first install candidate
• why it fits
• what to inspect before installing

This makes the result easier to act on immediately.

Watch for common failure modes

Typical failure modes include:

• queries that are too broad
• asking for direct task execution instead of discovery
• not naming the stack
• assuming a general skill is equivalent to a specialized one

If the result feels generic, the input is usually underconstrained.

Iterate after the first recommendation

After the first pass, improve the query with one additional constraint at a time:

• domain
• stack
• output type
• environment
• beginner vs advanced preference

This is a better refinement pattern than rewriting the request from scratch.

Use repo reading as a quality filter

Once find-skills suggests a candidate, inspect that skill’s SKILL.md first. Look for explicit workflow, constraints, and install steps. If the candidate lacks those, keep searching rather than installing on hope.

How to get more value from find-skills for teams

For shared environments, standardize how requests are phrased. A small template such as “goal + stack + constraints + desired output” makes find-skills much more reliable across team members and reduces repeated browsing work.