What Is find-skills, and Why Did an AI Skill Finder Top the Charts?

If an AI Skill had been installed millions of times, what would you expect it to do?

Write production-ready code?

Build a complete website?

Create presentations or analyze financial markets?

The answer is none of those things.

It is called find-skills, and its main purpose sounds almost recursive:

It helps an AI agent find other Skills.

That answer may seem underwhelming at first.

However, the more closely you examine the idea, the more reasonable its popularity becomes.

AI users do not always need a more powerful model. Sometimes, what they really need is a map that answers a much simpler question:

“What is the right capability or workflow for this task?”

According to the Skills.sh leaderboard snapshot dated July 24, 2026, find-skills appeared near the top of the installation chart with approximately 2.6M installs. It is distributed through the vercel-labs/skills GitHub repository, which showed approximately 27.1K Stars at the same time.

These figures require context.

An installation count does not necessarily represent the same number of unique users. The GitHub Star count belongs to the entire repository, not to find-skills as an individual Skill. Neither metric should be treated as a security audit or a guarantee of quality.

Still, the attention reveals something important:

Skill discovery has become a high-frequency problem of its own.

The Short Answer: What Problem Does find-skills Solve?

find-skills does not provide another specialized capability.

It provides an entry point to specialized capabilities.

The Skill is designed to help answer three questions:

1. Does a mature Skill already exist for the current task?
2. Which candidate should the user evaluate first?
3. How can the source, popularity, and maintenance status be checked before installation?

Instead of viewing find-skills as a simple downloader, it is more useful to think of it as:

A capability search engine, navigation layer, and preliminary filter for AI agents.

It does not complete every task itself. It helps the agent identify a more appropriate method before execution begins.

What AI Users May Be Missing Is a Capability Directory

Many people still use AI by starting with a short request:

• “Build a login page.”
• “Test this API.”
• “Optimize my React project.”
• “Create a product presentation.”
• “Review this code.”

The model usually responds immediately.

Sometimes the result is useful. In more complex situations, however, several weaknesses begin to appear:

• The workflow is incomplete;
• The wrong tool is selected;
• Important steps are omitted;
• The output lacks acceptance criteria;
• The user has to repeat the same requirements every time.

Many of these tasks already have established processes.

Developers and domain experts may have created reusable Skills for:

• Front-end design;
• End-to-end testing;
• API security review;
• Document processing;
• Deployment automation;
• Code review;
• Technical SEO audits.

The problem changes as the ecosystem grows.

When hundreds or thousands of Skills become available, users may not know that the right one exists—or even what keywords they should use to find it.

That is the problem find-skills addresses.

Instead of trying to become an expert in every domain, it helps the agent locate more specialized expertise.

What Is an AI Skill?

In an AI agent ecosystem, a Skill can generally be understood as a reusable package of instructions, workflows, and supporting resources.

A Skill may include:

• A sequence of task steps;
• Tool-use rules;
• Output requirements;
• Review checklists;
• Scripts or reference materials;
• Error-handling instructions;
• Acceptance criteria.

A Skill does not necessarily retrain the model or give it new model weights. It is closer to providing the agent with a structured operating manual.

For example, a code-review Skill might instruct an agent to:

1. Understand the purpose of the code;
2. Run static analysis;
3. Check for security issues;
4. Review performance risks;
5. Add file and line references;
6. Produce a structured report.

That process is usually more reliable than simply saying, “Review my code.”

Compatibility should not be assumed, however. Different agents and CLI tools may use different formats, directories, and permission models.

How Does find-skills Work?

The core idea is to turn Skill discovery into a repeatable process instead of returning a random list of links.

Step 1: Understand the Actual Task

Before searching, the agent needs to identify:

• The domain;
• The desired outcome;
• More specific search terms;
• Whether a dedicated Skill is necessary.

For example, “optimize my website” is too broad.

It could mean:

• Improve page-loading speed;
• Optimize React rendering;
• Perform a technical SEO audit;
• Redesign the interface;
• Increase conversions.

If the task is not clearly defined, even a large number of search results will not solve the problem.

Step 2: Look for Established Options

Once the task is clear, find-skills can help identify relevant options from Skills.sh and related directories.

Popular or widely used Skills may be easier to evaluate because they often have more visible documentation, usage history, and community feedback.

That said:

Popular does not mean secure, and installation volume does not guarantee quality.

Leaderboards should be treated as discovery signals, not final verdicts.

Step 3: Search Using More Precise Keywords

If no obvious result appears, the Skills CLI can be used to search for relevant terms:

npx skills find <keyword>

For a React performance task, the search might look like:

npx skills find react performance

Better keywords generally produce more relevant results.

One benefit of find-skills is therefore not only executing a search, but also converting a vague request into a more useful query.

Step 4: Evaluate the Candidates

A candidate Skill should not be installed immediately.

Useful quality and risk signals include:

• Installation volume;
• Repository owner;
• Recent update history;
• Open Issues and Pull Requests;
• Documentation quality;
• License information;
• External scripts;
• File-system access;
• Network requirements;
• Elevated permissions;
• Signs of abandoned maintenance.

GitHub Stars can provide context, but they should never be the only selection criterion.

A highly starred project may be outdated. A smaller project may be better documented, more focused, and safer for a specific task.

Step 5: Present a Small Number of Options

A useful discovery Skill should not overwhelm the user with dozens of links.

A better response includes:

• Two or three relevant candidates;
• A clear explanation of each use case;
• Repository and documentation links;
• Permission or security notes;
• Installation commands;
• A request for user approval.

This is where human-in-the-loop design matters.

AI can reduce the cost of searching and comparison. The user should still make the final decision when third-party code, file access, or network permissions are involved.

Example: Finding a React Performance Skill

Imagine asking an AI agent:

“Is there an existing Skill for optimizing React performance?”

Without a discovery workflow, the agent might immediately recommend:

• React.memo;
• Lazy loading;
• Code splitting;
• Fewer re-renders;
• State-management changes.

Those suggestions may be reasonable, but the agent has not yet identified whether the real problem is runtime performance, bundle size, or initial loading speed.

With find-skills, an ideal workflow would be:

1. Clarify the performance problem;
2. Search for React Performance or Web Performance Skills;
3. Identify relevant candidates;
4. Review maintainers, documentation, popularity, and permissions;
5. Present a short list;
6. Wait for approval before installation;
7. Use the selected Skill to perform the analysis.

The role of the AI has now changed.

It is no longer only answering a question. It is performing the first stage of technical solution selection.

That is still a preliminary review, not a final recommendation. The user must consider the project stack, source code, security requirements, and maintenance status.

Why Is Skill Discovery Such a Common Need?

The simplicity of find-skills hides several important characteristics.

1. More Skills Create Higher Discovery Costs

When an ecosystem contains only a few Skills, users can browse them manually.

When it grows to hundreds or thousands of options, discovery becomes a separate problem.

The same pattern has appeared in:

• App stores;
• Browser extensions;
• WordPress plugins;
• IDE marketplaces;
• Open-source package registries.

As an ecosystem expands, users need:

• Search;
• Categories;
• Rankings;
• Reviews;
• Compatibility information;
• Security signals.

find-skills addresses this entry point.

2. It Can Be Used Across Many Domains

A coding Skill serves software-development tasks. A presentation Skill serves slide creation. An SEO Skill focuses on websites and content.

The need to find a suitable Skill, however, appears before almost every specialized task.

Users may need capabilities for:

• Software development;
• Data analysis;
• Scientific research;
• Document processing;
• UI design;
• Content marketing;
• DevOps;
• Automated testing.

This makes find-skills a type of meta-skill.

It does not perform every task. It connects users and agents with other capabilities.

3. It Tries to Reduce the Most Expensive Cost: Rework

Tokens are not always the most expensive part of an AI workflow.

Rework can cost much more.

It often happens because:

• The requirement was unclear;
• The wrong tool was selected;
• An existing workflow was ignored;
• An unverified search result was trusted;
• The process was found to be incomplete halfway through execution.

find-skills places “find the right method” before “start executing.”

That may appear slower at first, but it can make the overall task significantly faster.

4. It Preserves Human Control

A responsible AI agent does not need to automate every decision.

When installing third-party Skills, a safer design is:

Let AI search, compare, and explain. Let the human approve and accept the risk.

Automation should not eliminate human control. It should preserve human attention for the decisions that matter most.

What find-skills Cannot Guarantee

Popularity does not make find-skills or its recommendations infallible.

Rankings Measure Attention, Not Complete Adoption

Installation counts may include:

• Repeated installations;
• Automated environments;
• Testing;
• Updates;
• Redeployments.

Therefore, 2.6M installations should not automatically be described as 2.6 million unique users.

GitHub Stars Are Not a Security Audit

Stars show interest and visibility.

They do not prove that:

• A repository contains no malicious code;
• Installation scripts are safe;
• Skill instructions are accurate;
• The project is suitable for your environment;
• Future updates will remain trustworthy.

Source and permission review are still necessary.

Search Results Can Become Outdated

The Agent Skills ecosystem changes quickly.

A once-popular Skill may become unmaintained or incompatible with a newer CLI or agent version.

Every recommendation should be checked against the current environment.

Finding a Skill Does Not Guarantee Success

A Skill may provide a structured workflow, but it cannot replace:

• Business understanding;
• Domain expertise;
• Testing;
• Security review;
• Human judgment.

It can help an agent avoid common mistakes, but it cannot remove all risk.

How to Install find-skills

If your AI agent supports the relevant Skills CLI, use the installation command provided by the project:

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

Before running it, confirm that:

1. Node.js and npm/npx are installed;
2. Your agent supports the required Skill format;
3. The repository URL and Skill name are correct;
4. You have reviewed the Skill and installation scripts;
5. You can test it in a sandbox or non-production project.

Installation instructions may change over time. Always check the current README and Skills.sh listing.

How to Use It

After installation, you can ask your agent:

Find a Skill for React performance optimization.Or:Is there an existing Skill for API security testing?

For a more controlled workflow, use a detailed request:

Search Skills.sh and relevant repositories for a technical SEO audit Skill. Compare maintenance status, installation volume, permissions, and documentation.

Give me no more than three candidates, and do not install anything until I approve it.

For security-sensitive tasks, add:

Do not execute third-party scripts automatically. List all required permissions, dependencies, and network requests first.

That is safer than asking the agent to install the most popular result without review.

Security Checklist for Third-Party Skills

Before installing any Skill, check:

•  Is the repository owner trustworthy?
•  Is the project still maintained?
•  Does it have clear documentation?
•  Does it include installation scripts?
•  Does it read environment variables?
•  Can it access API keys, SSH keys, or configuration files?
•  Does it send data to external servers?
•  Does it execute shell commands?
•  Does it request elevated permissions?
•  Can file access be restricted?
•  Can the version or commit be pinned?
•  Can it be tested in a container or sandbox?

Remember:

Installation volume measures popularity, not security assurance.

Four Design Lessons from find-skills

The design of find-skills may be more valuable than the specific feature itself.

1. Solve a Frequent Problem That Appears Before Other Tasks

Many Skill creators begin by asking:

“What impressive feature can I build?”

A better question may be:

“What obstacle appears before users begin almost every task?”

find-skills focuses on capability discovery.

Its scope is narrow, but the need occurs frequently.

2. Support Recommendations with Evidence

An AI agent should not simply say:

“I think this Skill is good.”

A better recommendation includes inspectable evidence:

• Source;
• Installation volume;
• Maintenance activity;
• Documentation quality;
• Permission requirements;
• Task relevance.

Evidence cannot guarantee a perfect conclusion, but it makes the recommendation easier to evaluate.

3. Do Not Make High-Risk Decisions for the User

A Skill can help users:

• Discover projects;
• Compare options;
• Summarize strengths and weaknesses;
• Generate installation commands.

It should pause before executing unknown scripts, accessing sensitive directories, or sending private code to external services.

4. Short Does Not Mean Shallow

A useful Skill does not need to be long.

It needs to define:

• When it should activate;
• What to do first;
• How to handle missing results;
• Which evaluation criteria to use;
• How to present recommendations;
• Which actions require approval;
• When to stop.

Good Skill design is not about covering everything. It is about being unambiguous at critical decision points.

Frequently Asked Questions

What is find-skills?

find-skills is a Skill that helps AI agents discover and evaluate other Agent Skills. Its purpose is to identify suitable existing workflows rather than directly complete one specialized task.

Is find-skills an official Vercel product?

It is distributed through the vercel-labs/skills GitHub repository. Whether it is a formal product, an experimental project, or a community resource should be verified through the latest repository and Vercel documentation.

Does find-skills automatically install other Skills?

Behavior depends on the Skill instructions, agent configuration, and CLI version. For safety, require explicit approval before any third-party Skill is installed.

Are Skills.sh installation numbers reliable?

They can indicate popularity, but they may not represent unique users and do not prove security or effectiveness.

Can find-skills guarantee safe recommendations?

No. It can assist with preliminary filtering, but it cannot replace source-code review, permission controls, or security testing.

Can Agent Skills be used across different AI tools?

Some instructions and Markdown-based workflows may be reusable, but formats, directories, and permission models vary. Compatibility should be tested rather than assumed.

Final Thoughts: Finding the Right Method Is a Skill of Its Own

Many people believe the AI era will be won by whoever writes the longest or most sophisticated prompt.

find-skills suggests a more practical answer:

The person who finds a proven workflow faster will spend less time taking the wrong path.

It does not promise to build a revolutionary application for you.

It simply moves one frequently ignored question to the beginning of the process:

“Before we start, is there already a more specialized and reliable way to do this?”

That question may sound ordinary.

Yet real productivity often begins not when an AI starts executing, but when the user and the agent finally choose the right method.

That is the real value of find-skills.

It does not encourage AI agents to collect capabilities blindly. It helps them select capabilities with more context, evidence, and human oversight.

Sources

1. Skills.sh
2. vercel-labs/skills on GitHub
3. The current find-skills listing and project README
4. Data note: Rankings, installation numbers, and GitHub Stars change continuously. Include the date of measurement and update the figures when the article is revised. Installation counts should not be described as unique users unless the platform explicitly provides that metric.