The 10 Most Popular Agent Skills, Ranked by Installs

What this popularity ranking measures—and what it does not

This is a popularity snapshot, not a universal best-of list. We ranked named Skills by the all-time installation count shown on the public Skills.sh leaderboard when checked on September 7, 2026. The registry is useful because it makes one consistent adoption signal visible across sources.

An install can mean that someone tried a Skill, included it in a pack, or adopted it for a team workflow. It does not demonstrate that the Skill is safe, suitable for every agent, or better than an alternative on your repository. The useful question is whether its instructions, scripts, and permissions match a task you can inspect.

For a source-first starting point, browse the AI Vitamin Agent Skills directory. It groups records by workflow and keeps the original source link close to the listing, so you can evaluate a candidate before you install it.

Top 10 Agent Skills by all-time Skills.sh installs

The table preserves the registry’s order at the time of review. Counts are rounded as displayed by the source, because they move over time.

Source: Skills.sh — All Time leaderboard

1. find-skills: discover a narrow, relevant capability

The most installed entry is Vercel Labs’ find-skills. Its job is not to implement an application by itself. It helps an agent translate a need such as testing, deployment, or research into a focused search, then compare sources before installation.

Use it when the work is common enough that a reusable workflow might already exist, but you do not know which one. The valuable habit is the selection filter: check the source, install count, repository reputation, and the actual Skill file. Skip it for a simple task you can already complete directly.

2. grill-me: pressure-test a plan before implementation

Matt Pocock’s grill-me is an interviewing workflow for turning a vague plan into one that has been tested against decisions, trade-offs, and edge cases. Its source describes systematic questioning and codebase exploration when relevant context is available.

It fits an architecture proposal, product change, or design review that still has important assumptions hidden inside it. Expect questions rather than an immediate patch. If a decision is already documented and accepted, repeated interrogation can add friction without improving the result.

3. grill-with-docs: connect a design review to the project’s language

The related grill-with-docs workflow adds a domain glossary and architecture records to the questioning process. It is intended to expose fuzzy terminology, test decisions against concrete scenarios, and update contextual documentation only when the work warrants it.

Choose it when a repository already has a meaningful domain model, a CONTEXT.md file, or ADRs that a proposed change must respect. It is less useful in a small prototype with no established language; there, a compact written brief may be the better starting point.

4. improve-codebase-architecture: find the seams that make change hard

The improve-codebase-architecture Skill examines architectural friction and proposes refactors intended to improve testability and codebase navigation. Its public description frames the work around deeper modules, smaller interfaces, and alternatives that make the trade-offs explicit.

This is best for an area that keeps producing costly changes, unclear ownership, or brittle tests. Treat the output as a design proposal to review, not an instruction to rewrite broad areas of code. A current test suite and a bounded change target make its recommendations easier to validate.

5. frontend-design: give a product interface a deliberate visual direction

Anthropic’s frontend-design focuses on distinctive, production-oriented interface work. The source emphasizes choosing a visual direction before implementation, then applying typography, color, motion, spacing, and code in service of the actual product brief.

It is a strong starting point for a public page or application surface that needs a clear point of view. Pair it with the Design and Frontend Agent Skills category when you need to compare adjacent source files. It still needs real content, accessibility checks, and product constraints; an aesthetic brief cannot replace those inputs.

6. tdd: keep the agent’s implementation loop tied to behavior

The tdd Skill turns red-green-refactor into a more concrete agent workflow. It asks for behavior-focused tests at agreed public seams, incremental vertical slices, and refactoring after the relevant tests pass.

Use it for a bounded feature where you can name observable behavior and run the resulting test suite. It is not a promise that tests are sufficient: a green suite can still miss security, performance, integration, and product-quality problems. Review the test target and the diff before shipping.

7. agent-browser: automate browser work with a real permission boundary

Vercel Labs’ agent-browser provides persistent browser automation for navigation, page inspection, interaction, data extraction, and session-oriented tasks. Its record describes several browser modes and a command set that can act through a live browser.

That makes it useful for repeatable website checks and workflow automation, but it also makes access control central. Start with a non-sensitive account or a read-only workflow, inspect the target actions, and require a person to approve consequential submissions, uploads, or transactions.

8. setup-matt-pocock-skills: configure an engineering workflow once

The setup-matt-pocock-skills Skill scaffolds repository context for a related engineering set. Its description covers detecting the issue tracker and existing guidance, then collecting decisions about labels and domain documentation before writing the configuration other Skills will read.

This is a setup task, not a generic coding command. Use it only after deciding that the associated workflow is a fit for the team, and review the configuration draft before it changes repository guidance or creates reference documents.

9. handoff: preserve the useful context between agent sessions

The handoff Skill turns a working conversation into a compact handoff document for the next agent. Its stated process references existing artifacts rather than duplicating them, proposes relevant next Skills, and instructs the agent to redact sensitive values.

It is most valuable when a task spans sessions, people, or agent contexts. Review the resulting handoff before sharing it outside the original workspace: redaction guidance reduces risk, but the person responsible for the project should still decide which context can travel.

10. triage: give issue intake a repeatable state machine

The triage Skill organizes issues through named categories and states, checks for missing information, and prepares concise briefs for later work. Its published instructions also cover reproduction checks and how to label AI-generated tracker comments.

Adopt it when the project has enough inbound issues to benefit from a shared operating model. Because triage can affect external issue-tracker records and communicate with contributors, configure labels carefully and retain human ownership of prioritization, replies, and final state changes.

Why these ten rise together on the leaderboard

The top ten are not ten versions of the same capability. They cover discovery, plan review, documentation-aware design, architecture, interface work, testing, browser automation, setup, handoff, and issue intake. Taken together, they describe the work around implementation as much as implementation itself.

Seven of the ten came from the same mattpocock/skills repository in this snapshot. That concentration is a reason to be careful with interpretation: an installation count can reflect a coherent pack, onboarding path, or a team’s shared setup. It does not prove independent preference for every individual Skill.

How to choose a popular Agent Skill for a real workflow

Start with the work, then find the smallest compatible set of instructions. The Developer Agent Skills section is a useful next stop for coding, testing, documentation, and automation workflows; the full directory is better when the job crosses categories.

Read the original SKILL.md and every linked script or reference before installing. Confirm the agent platform supports the format, identify files and accounts it can reach, run it on a bounded non-sensitive task, and inspect the resulting changes. Keep permissions narrow until the workflow has earned broader access.

• Define a repeatable task and the evidence that would prove success.
• Check the maintainer, source path, dependencies, and update history.
• List file, network, browser, account, and external-action permissions before use.
• Test in a branch, sandbox, or non-sensitive project before production work.
• Measure the review burden, not only how quickly the agent returns an answer.

The practical takeaway

The most popular Agent Skills are useful signals of where teams want repeatable help: finding the right capability, interrogating decisions, improving code, testing behavior, operating browsers, and carrying context forward. They are a shortlist to investigate, not a substitute for due diligence.

Use the AI Vitamin Agent Skills directory to inspect original source files by workflow, then adopt the smallest Skill that fits your task and permission model. That is a more reliable use of popularity than installing a large pack simply because its counts are high.