Vendors do this for a boring reason: they ship an MCP file next to the app people already know. The ranking mechanic is what gets weird.

On 14 Aug 2026 we dumped every MCP server in the Skillselion catalog: 8,433 servers from 5,392 publishers, frozen as the MCP Server Census. On a Claude Code skill listing you can see installs. On MCP, that field is empty. Nobody published a "someone ran this server" number that covers the set. A "most used MCP" table built from our data is built from something else.

That something else is GitHub stars. Stars attach to the repository. 79.8% of these servers map to GitHub. 175 of those repos host more than one server (969 servers). Each of those servers inherits the same star total.

You see the same setup at the high end: the Metabase MCP server, PostHog, UI-TARS browser MCP (four servers, one star count), Context7 MCP. Different teams. Popular repo, MCP file inside, star number reused as adoption.

More than half of the 8,433 have zero stars. That looks dead. Last-push dates say otherwise. Of servers with a date, the median pushed about 50 days before the dump, and 43.4% pushed in the last 30 days. Quiet on GitHub often means unseen.

If you are picking a server, open the MCP directory and sort by last push. Then open the repo and check the README is the server you think you are installing. A six-month gap is rare here (about 6% of dated servers). A huge star count on a famous product is common. It answers "is this org well known?"

Skills still have installs, which is how the Agent Skill Clone Census and the Agent Economy Census can talk about adoption. This MCP edition does not rank by use. The CSV and freeze notes are on the 14 Aug MCP census. Dump rules sit in how we freeze research dumps. Related dated studies: Skillselion research and State of AI agent skills 2026.

Disclosure: we run Skillselion. This is our 14 Aug 2026 catalog snapshot, not a live scoreboard and not a review of those products.

On August 12, 2026 we dumped the production catalog and checked every listing's SKILL.md against every other. A verified copy is a content match: same name, and SKILL.md byte-identical or 90% identical on a frozen fork.

One generative-media product listed under three names accounts for 53.7% of copy-installs. The census names that family as RunComfy-branded skills listed under agentspace-so, runcomfy-com, and doany-ai. Files match. The census does not claim the three handles are one company. Errata, 16 Aug 2026: treat the doany-ai / runcomfy-com copy-install bars as catalog-as-of-dump, not as people who installed those copies. Frozen figures above are unchanged.

Publishers re-listing their own skills account for 35.0%. Copies of Anthropic skills captured 3.15% of the audience the originals earned. 98.2% of skills declared no license.

Live catalog totals move every day. The census does not. Cite the frozen page if you need a figure that stays checkable. Disclosure: we run Skillselion.

The frozen edition and companion studies

• Dataset and limits: Clone Census

• How we count: methodology

• Market shape: Economy Census

• Audits: Security Census

• Freshness of code: Maintenance Census

• What people use them for: Use-Case Census

• Servers with zero install fields: MCP Server Census

• Hub: Research

Picking without triple-counting

Open the skills catalog. Rank by installs, then open GitHub. If three listings share one product, the install graph is repeating itself.

Finding 04: Anthropic's Frontend Design was copied 59 times. The copies hold 14,818 installs against the original's 767,871. Start from that original, then Find Skills and Grill Me. Hubs: frontend design best, MCP index, Guides, live state page.

Before you install a trending name, open GitHub and check whether two other listings share the same SKILL.md.

Grill Me sat at #1 in search: 876,468 installs, 219,406 stars, query up 3,250%. Find Skills sat at the bottom of the same seven-name rail and held 2,980,173 installs with 29,037 stars.

Full writeup with the same snapshot: Which Claude Code skills are people googling that slow the agent down?. Catalog that day: 81,246 listings, 60,011 skills, 147,648,453 installs. Disclosure: we run the directory.

Why the split matters

Stars measure attention on GitHub. Installs measure whether a developer left the skill on an agent. If you sort this rail by stars, Grill Me wins. If you sort by installs, the gravity well is a search tool. That is the decision you make at the prompt.

Grill Me is user-invoked (/grill-me) so it does not fire itself. Repo: github.com/mattpocock/skills. Find Skills repo: github.com/vercel-labs/skills. The most installed skill in this set finds other skills.

The rest of the rail

• Impeccable: 235,708 installs, +140%. GitHub. A taste layer for default agent UI.

• Caveman: 438,679 installs, +90%. GitHub. It makes the agent talk less.

• Frontend Design: 784,427 installs, +70%. GitHub. Hub: best skills for frontend design and the frontend-design category.

• Security Review: 14,882 installs. GitHub. Treat 14,882 installs as search demand.

• Ui Ux Pro Max: 318,475 installs, +30%. GitHub. Another taste pack.

How we pick in a hurry

Open the skills catalog. Rank by installs. MCP servers live on /mcp and do not have install counts (MCP Server Census). Longer studies: Research. How-tos: Guides.

Pull one mid-task. MCP install: claude mcp add skillselion -- npx -y skillselion-mcp (repo).

If you only install one thing from this snapshot, install the finder or the interviewer, then come back for taste when the UI looks like a template.

The short version. On 2026-08-14 we counted 8,433 Model Context Protocol servers from 5,392 publishers. None of them carries an install count. Ranking therefore falls back to GitHub stars, and a star belongs to the repository, not to the server inside it: 175 repositories host more than one server, so 969 servers share a count they did not individually earn. Counting stars per server instead of per repository inflates the ecosystem total by 1.15x.

The finding in one line

Metabase's 48,750 GitHub stars are for a business intelligence platform. On 2026-08-14 that same number sat against Metabase's entry in the server table, because an MCP server inherits the stars of whatever repository it happens to live inside.

That is Finding 02 of The MCP Server Census, a frozen snapshot of 8,433 MCP servers from 5,392 publishers taken on 2026-08-14. If you have ever sorted a list of MCP servers by stars and picked the top one, this is what you were actually sorting.

Why stars are the only signal left

Every MCP server in the census carries a zero install count. The field is empty for all 8,433 of them, rather than present and low.

Agent skills report installs through public registries, which is what makes an install-ranked skill census possible. MCP has no equivalent per-server install event. The census states it plainly: every MCP server in it carries a zero install count.

Partial signals exist and are worth being precise about. Servers shipped as packages inherit a download counter from npm, PyPI or Docker, and PulseMCP surfaces that as a package_download_count field, populated for a minority of the servers it lists. The census declines to state a single coverage share for that field, because coverage clusters along catalog ordering, with pages running anywhere from 0% to 89%.

Even where a download figure exists, it counts package pulls, including from CI and mirrors, rather than use of the server, and it is missing entirely for anything distributed as a remote endpoint or a bare repository.

So the only population-wide signal left is stars. And stars measure the repository.

Six repositories that show the effect

79.8% of servers, 6,731 of them, map to a GitHub repository. 175 repositories host more than one server, covering 969 servers, or 14.4% of the repo-backed population. Each of those servers inherits the full star count of the repository it lives in.

Star counts are the frozen census values for the repository on 2026-08-14. The named servers are live catalog listings sitting inside those repositories, not census fields.

The census is explicit about this: these six are a selection chosen to show the effect, not the top six by stars. They sit at positions 1, 3, 4, 6, 8 and 9 in the repository star ranking.

ByteDance is the clearest case. Its 38,581 stars belong to the UI-TARS desktop app and get counted four times, once per MCP server in the repository.

The inflation is measurable: 1.15x

Adding stars per server instead of per repository inflates the ecosystem total from 1,101,230 to 1,270,936, a factor of 1.15x.

The reordering effect is sharper than the total. On a per-server ranking PostHog falls to 12, because the four ByteDance servers each occupy a slot carrying the same repository count. Four rows in a per-server ranking all carry the same repository total.

A further 20.2% of servers, 1,702 of them, carry no repository at all, so they sit outside every repository-level figure in the census.

Star distribution: a Gini of 0.986

Run the Gini coefficient across the star counts of all 8,433 servers and it comes out at 0.986.

• The top 1% of servers, 84 of them, hold 89.1% of every star in the ecosystem.
• The top ten alone hold 43.6%. The top 100 hold 90.5%.
• 54.9% of servers, 4,633, have never been starred once.
• Among the 45.1% that have, the median server holds 5 stars.

For most publishers, the star count records nothing at all. That is a statement about attention, not about whether anyone runs the server, because nothing in this population records that.

The census also warns against a comparison you might be tempted to make: the August skill census reported a Gini of 0.96 on installs, and that figure describes a different population on a different metric, so the two are not like for like.

Most servers do not even say what they do

An MCP server is defined by the tools it exposes. Only 1,115 servers, 13.2%, declare at least one tool. For the remaining 86.8% there is no tool manifest we can read. Among those that do declare, the median server exposes 6 tools, and the declared total across the census is 14,349.

By category the census is concentrated. Developer tooling and AI plumbing together account for just over half of every server in it:

Publishing is a one-time act for almost everyone

4,707 of the 5,392 publishers, 87.3%, have published exactly one server. The average publisher ships 1.56. The ten largest MCP publishers together account for only 11.27% of all servers.

Server count and attention come apart completely. The largest publisher by volume, CSOAI-ORG, ships 192 servers holding 15 stars between them.

How to pick an MCP server when nothing ranks them

The census closes with the practical version of all this: rank on the fields that are actually populated.

1. Last push date. The strongest populated signal. Of the 5,926 servers carrying a last-push date, 70.3% of the census, the median pushed code about 50 days ago and 43.4% pushed within the last 30 days. 369 dated servers, 6.2% of the dated set and 4.4% of the census, have gone six months untouched.
2. Declared tool count. Only 13.2% declare one, but where present it tells you the surface area you are adopting. The median is 6 tools.
3. Whether the repository is the server. Before reading a star count, check that the repository is not a whole product that happens to contain an MCP server. You can apply this and the fields above in the MCP server directory, which exposes recency, category and publisher per listing.
4. Publisher shape. 87.3% of publishers ship exactly one server, so a suite publisher and a one-off carry different maintenance expectations. The leaderboard is the cross-catalog view.

If you want a ranked shortlist rather than the full directory, these are narrower: best MCP servers for dev tools, for AI agents, and for security. By area, the closest hubs are dev tools and AI and agents. The other listing types live at agent skills and marketplaces.

The caveats

Read 8,433 as the size of this catalog rather than the size of the ecosystem. On the same day the snapshot was taken, PulseMCP's API reported 22,070 servers against our 8,433, and the official MCP registry paginates without publishing a total. Registries differ on what they admit, how they dedupe, and whether they keep unreachable entries, so the honest reading of 8,433 is a floor for what has been found and verified.

Three more limits shape what can be said. Stars are a property of the repository, which is the whole point above. Declared tool counts exist for only 13.2% of servers, so every tool figure states that denominator instead of projecting onto the census. And the 70.3% of servers carrying a push date are not a random sample: the 2,507 servers without one are 97.8% zero-star and hold 299 of the ecosystem's 1,270,936 stars, so they are systematically the thinnest entries.

None of these figures are adoption data. Stars are not installs, this census never treats them as such, and no number above should be read as a count of anyone running a server.

Dataset, methodology and citation

Every figure above is fixed to 2026-08-14 and stays checkable. The full methodology and the complete census are public, and the dataset is 8,433 rows of CSV under CC BY 4.0. Cite it as "Skillselion MCP Server Census, August 2026".

Companion editions cover the skill side of the same catalog: The Agent Economy Census, 79,827 listings and 158M installs, and The Maintenance Census, the skill-side version of this push-date analysis. The rest sit on the research index.

Stars tell you what got noticed once. The push date tells you what is still being written.

Skillselion is an independent, automatically updated directory of AI-coding tools: live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

That number comes from the Agent Skill Security Census, published August 12, 2026: 41,791 audit verdicts from 5 independent providers across 79,848 listings, every figure frozen to the census date. Disclosure: I run Skillselion, the independent directory the census is drawn from. It has no affiliation with Anthropic, OpenAI, Cursor, or any audit provider named here, and it ran no scans of its own: the census counts published verdicts, worst one per listing, and never re-scores anything.

If you have ever looked at a skill's listing, seen one green verdict and one red one, and wondered which auditor to believe, this study is for you.

Who the auditors are

Five providers publish the verdicts this census counts: Socket, Snyk, Gen Agent Trust Hub, ZeroLeaks and Runlayer, distributed through the skills.sh registry. Coverage overlaps heavily: 99.6% of audited listings carry verdicts from at least two providers, and the median audited listing carries 5. The underlying catalog is refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

Overlap is what makes disagreement measurable. When five reviewers grade the same 9,758 audited listings, you can line their answers up.

The disagreement, quantified

Two findings stand out. First the direct conflicts: on 1,233 listings, 12.7% of the multi-rated set, one auditor's verdict is HIGH or CRITICAL while another's is LOW or SAFE for the same code. Second, the fail rates, meaning listings an auditor fails outright, spread across an order of magnitude and then some:

Snyk fails 697 of roughly 9,700 listings. ZeroLeaks, auditing 6,857 of the same ecosystem, fails none. These providers are plainly measuring different things, weighting capabilities differently, or drawing the fail line at different depths. Agent-skill auditing is a young discipline and its standards have not converged. The census's advice is short: read two verdicts before you trust one.

What HIGH and CRITICAL actually record

The disagreement makes more sense once you know what a flag is. A flag records capability and findings, such as shell execution, browser control, or network reach, together with whatever the auditor's analysis surfaced. The census is explicit that a flag is never an accusation of malicious intent, and the flagged list itself is the strongest evidence, because it includes every major vendor:

• azure-validate by Microsoft (repo): CRITICAL, 517,228 installs
• agent-browser by Vercel Labs (repo): HIGH, 659,465 installs
• skill-creator by Anthropic (repo): HIGH, 348,833 installs
• pdf by Anthropic (repo): HIGH, 177,212 installs
• playwright-cli by Microsoft (repo): HIGH, 116,690 installs

A CRITICAL on Microsoft's deploy validator describes what that tool can reach. Nobody reading the verdict thinks Redmond shipped malware. The same charitable reading does not automatically extend to a no-name skill with the same flag, and that asymmetry is precisely the judgment call the auditors themselves keep landing on differently.

Across everything audited, 55.7% of listings land at MEDIUM or above on their worst verdict, 1,346 are flagged HIGH or CRITICAL with 15,221,597 installs behind them, and 1,366 listings, 14.0% of the audited set, fail at least one provider outright.

Why the disagreement matters right now

August 2026 has been the ecosystem's loudest security month. At Black Hat USA 2026, Novee Security disclosed that an unprivileged GitHub issue could reach CI secrets in the repositories of Claude Code and Gemini CLI, and on OpenAI's Codex repository could hijack the next agent run, with the Claude Code flaw tracked as CVE-2026-54316 and fixed in version 2.1.163. Within the week, the Claude Code v2.1.228 release hardened how synced skills behave, stopping them from shadowing local commands and from running ! commands or expanding @ files on the user's machine.

A harness gets fixed with one release; an ecosystem of 79,848 third-party listings has no central patch channel, which is why the audit layer matters, and why its internal disagreements are worth knowing about before you lean on any single verdict.

How to read verdicts like the census does

• Take the worst verdict as the headline. That is the conservative aggregation the census uses per listing, and it is the right default for code that will run on your machine.
• Weight agreement. Five LOWs mean more than one LOW, and a HIGH/SAFE split on the same skill means you should open the repo and look, since you now know that split happens on 1,233 listings.
• Interpret the flag through the skill's job. Browser drivers and deploy tools will carry capability flags forever. A note-taking skill declaring shell access deserves a different eyebrow.
• Remember the coverage boundary. Only 12.2% of listings are audited at all, so most skills have no verdict to disagree about. Coverage numbers are in the census, install-weighted rankings are on the leaderboard, and curated entry points live in the best-of shortlists and the security category.

The census is one of a series: the Clone Census measures duplication across the same catalog, and The State of AI Agent Skills 2026 carries the live totals. The full dataset behind this piece, 79,848 rows with per-provider verdicts, is CC BY 4.0 on the census page.

Five auditors looked at the same code and reached different conclusions about a meaningful slice of it. Until their standards converge, the reading skill sits with you, and now you know exactly how far apart they are.

I watch our trending-search rail every day, and today's snapshot is the clearest signal I have seen in weeks: of the seven fastest-rising Claude Code skill searches, four are design skills, with a combined 1,659,726 installs. Not testing, not deployment, not databases. Design. The interesting question is why, and the install data suggests an answer.

Today's seven fastest-rising skill searches

As shown on our homepage today, with search growth:

Four of the seven (Ui Ux Pro Max, Frontend Design, Impeccable, Design Taste Frontend) target visual and interaction quality. The remaining three are about discipline, more on those below.

Which design skills are actually installed?

Ranked by install count, fetched from the live catalog today:

1. Frontend Design by Anthropic - 767,871 installs. Details | GitHub
2. Design Taste Frontend by leonxlnx - 350,625 installs. Details | GitHub
3. Ui Ux Pro Max by nextlevelbuilder - 311,742 installs. Details | GitHub
4. Impeccable by pbakaus - 229,488 installs. Details | GitHub

The taste-skill repo deserves a footnote: it is a family, not a single skill. Two siblings of the trending entry are large on their own, high-end-visual-design at 265,273 installs and stitch-design-taste at 223,682, both fetched today from the same catalog.

The honest sentence inside an official skill

Anthropic's own Frontend Design skill describes its goal as making design "choices that don't read as templated defaults." Read that again: the company that makes the model ships an official skill whose stated purpose is to stop its own model's default look. Left alone, coding agents converge on the same rounded cards, gradient heroes and three-column grids. The output works, and it looks like everyone else's output.

A skill attacks this differently than a prompt. It is a versioned, reviewable file of opinions: spacing scales, type choices, what to refuse to build. Installing one imports another person's design judgment into every session, the same mechanism by which a lint config imports code judgment. The install counts above say developers have priced that trade and taken it.

The discipline cluster

The three non-design entries (Grill Me 832,797 / Caveman 429,065 / Ponytail 33,353 installs, all fetched today) share one theme: restraint. Interrogate the plan before writing code (Grill Me details | GitHub), spend fewer tokens (Caveman details | GitHub), keep every change minimal (Ponytail details | GitHub). Nothing on today's list makes an agent produce more. Every entry either constrains the process or raises the bar on the result.

Practical takeaway

If your agent's frontend output feels generic, install one taste skill, not four: they overlap heavily and stacking them mostly burns context. Frontend Design is the adoption-backed default; Design Taste Frontend and Impeccable are the opinionated alternatives if the default still feels flat. The full ranking for this category lives at skillselion.com/best/skills-for-frontend-design, and pairing any taste skill with Grill Me at the planning stage covers the other half of the problem, because a bad plan produces a confident, well-styled version of the wrong thing.

One caveat to carry with you: install counts are adoption evidence, not proof of fit for your stack, and every figure here is a snapshot from August 12, 2026. The rail moves daily, which is rather the point of watching it.

Data source: Skillselion (which I run), fetched August 12, 2026.

On July 17, Cursor added plan-first Slack replies, named multi-repository environments, and the ability for its agent to read and post across channels. Once a coding agent can start from Slack, coordination becomes the risk surface: repository selection, context, verification, and inspectable evidence.

A safe Slack-to-code workflow needs six controls: planning, task independence, fresh context, verification, root-cause debugging, and review.

Cursor's primary changelog describes three useful changes:

1. The agent can propose a plan in Slack before execution.

2. Teams can name environments that contain multiple repositories.

3. Agents can read from and post to multiple channels during a task.

Those are coordination primitives. They do not decide how your agent should plan, split work, verify claims, or request review. That policy belongs in the skills and instructions you attach to the workflow.

I checked the live Skillselion catalog on July 18, 2026. These six operational skills from the same open-source collection follow workflow order, not install rank.

1. Start with writing-plans

writing-plans had 188,754 catalog installs on July 18, 2026.

It turns a high-level specification into an executable plan with file mappings, small tasks, tests, and documentation references. The source is available on GitHub.

This is the best first gate for a Slack-launched agent. Ask it to post the plan before it edits anything. A reviewer can catch a wrong repository, missing migration, or unsafe deployment assumption while the cost of correction is still low.

2. Parallelize only independent work

dispatching-parallel-agents had 138,691 catalog installs on July 18, 2026.

It dispatches independent tasks concurrently with isolated context. Its implementation is on GitHub.

Multi-repo access makes parallel work tempting. Independence is the constraint that matters. Two agents editing the same contract, migration, or shared type are not parallel tasks. They are a merge conflict with a longer explanation.

3. Give every subtask a fresh owner and two review stages

subagent-driven-development had 149,562 catalog installs on July 18, 2026.

It executes a plan with a fresh subagent per independent task and automated specification and quality review. The source is on GitHub.

Fresh context reduces accidental carry-over. The two review stages separate "did we build what the plan asked for?" from "is the implementation good enough?" That distinction is especially useful when Slack compresses a long task into a few status messages.

4. Make completion an evidence claim

verification-before-completion had 148,104 catalog installs on July 18, 2026.

It requires fresh command output before an agent says a task is complete. The source is on GitHub.

A green Slack reply is not a test result. A useful completion message names the commands run, their exit status, the affected repository and commit, and any test or deployment that was intentionally skipped.

5. Escalate failed verification into debugging

systematic-debugging had 191,037 catalog installs on July 18, 2026.

It forces root-cause discovery before code changes through a four-phase debugging process. The source is on GitHub.

This keeps a failed check from turning into a sequence of speculative edits across repositories. In a cross-channel workflow, post the failure evidence where the task started, then keep the detailed diagnosis in one thread.

6. Request review with a fixed contract

requesting-code-review had 171,122 catalog installs on July 18, 2026.

It dispatches a consistent reviewer that checks plan deviations and implementation quality. The source is on GitHub.

The reviewer should receive the plan, exact diff range, test evidence, and known limitations. "Please review" is not enough context for a human or an agent.

A practical Slack-to-code contract

Before you let a channel mention start a multi-repo coding task, define this contract:

• Identity: Which user, bot, and repository permissions authorized the work?

• Scope: Which repositories and directories may change?

• Plan: Where is the proposed plan, and who can approve it?

• Concurrency: Which tasks are truly independent?

• Evidence: Which tests, builds, and deploy checks prove completion?

• Provenance: Which commits, pull requests, and environments changed?

• Rollback: How will the team stop or revert the task?

Cursor's Slack improvements lower the cost of invoking an agent. The operational advantage comes from pairing easy invocation with hard boundaries and inspectable evidence.

The chat thread is becoming a control plane for code changes. It needs policy, state, verification, and audit trails.

Compare the six skill pages and review their source before installing anything.

Skillselion is an independent directory, not affiliated with Anthropic, OpenAI, or Cursor. The live catalog is refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

That last one deserves a second read. Until this fix, a malicious tool input could dress itself up to look safe in the very approval preview a reviewer was reading in chat.

None of this is a knock on Anthropic. Shipping fixes this specific, in public, weekly, is what a serious vendor does. The point is what it tells us: the attack surface of AI-assisted development has moved from the code you write to the agent that writes it. Prompt injection, permission-preview spoofing, sandbox escapes, malicious skills. This is where the incidents are now.

So here is the uncomfortable part. We run Skillselion, a directory of Claude Code, Codex and Cursor extensions ranked by real installs (live catalog, refreshed daily from skills.sh, GitHub and MCP registries). When you look at what developers actually install under "security", the picture is a decade out of date.

Agent security vs code security: what the install numbers say

The heavyweights are all code-security skills, tools that audit the software you ship:

• firebase-security-rules-auditor by Firebase (GitHub): 71,873 installs
• golang-security (GitHub): 34,000 installs
• better-auth-security-best-practices (GitHub): 20,323 installs
• security-review by Sentry (GitHub): 10,629 installs

Now the skills that secure the agent itself, the layer the changelog keeps patching:

• skill-vetter (GitHub), which audits a skill before you install it: 20,395 installs
• claude-settings-audit by Sentry (GitHub), which audits your Claude Code settings: 3,138 installs
• seatbelt-sandboxer by Trail of Bits (GitHub), which confines agent processes on macOS: 3,085 installs
• prompt-injection-scanner (GitHub): 222 installs

A Firebase rules auditor has 323 times the installs of a prompt injection scanner. Trail of Bits, one of the most respected security shops in the industry, publishes a sandboxing skill for the class of problem the changelog keeps fixing, and it sits at 3,085 installs while a Go code-security skill clears 34,000.

Takeaway 1: the attack surface moved to the agent, but install behavior hasn't caught up. Developers are still buying locks for the front door while the new entrance is the agent that holds the keys to the whole house: your shell, your filesystem, your credentials, your CI.

Skills are dependencies. Almost nobody audits them.

There are more than 61,000 skills in the catalog right now. A skill is a markdown file plus bundled scripts that you hand to an agent with Bash access. Functionally, that is an npm package with fewer guardrails: no lockfile by default, no signature, and an execution context that includes your entire dev environment.

We have been here before. npm hit this moment a decade ago, and the ecosystem answered with npm audit, lockfiles, provenance, and supply-chain scanners. The agent-skill ecosystem is at the pre-audit stage of that curve, except this time the package runs with your shell, your credentials, and your repos already in scope.

The interesting signal in the data is skill-vetter at 20,395 installs. It is the one agent-security skill with real traction, and what it does is exactly the dependency-audit reflex, ported to skills: inspect what a skill actually does before it runs. That reflex spreading is what maturity will look like.

Takeaway 2: vetting a skill before installing it is the new dependency audit. In two years, installing an unvetted skill with Bash access will look the way curl | sudo bash looks today.

How to audit your agent layer

Three habits. None of them need a framework:

1. Read the changelog of your agent the way you read security advisories for your runtime. It is one of the highest-signal security feeds in AI-assisted development right now, and it is free.
2. Audit the agent layer, not just the code layer. Your permission allow-lists, your installed skills and MCP servers, and your sandbox settings are production config now.
3. Before installing a skill, look at what it bundles and what it can touch. Install counts and the file tree are public on every Skillselion listing, and the skillselion-mcp server lets your agent check a skill's footprint before it installs anything.

The vendors are doing their part of the job. The install data says most of us have not started ours.

I work on Skillselion, the directory the install numbers above come from. All counts were read from the live catalog on July 17, 2026.

The loud posts are still about the 132-agent mega-stack: dozens of subagents, a wall of MCP servers, nested orchestration, a CLAUDE.md the length of a short novel. But the skills that are actually breaking out in search, and the ones developers are actually installing, lean the other way. They are about restraint. About taste. About making the model do less, more predictably.

That gap between what gets talked about and what gets installed is the whole story.

What developers are actually installing

Here is the shortlist from the live catalog, refreshed daily from skills.sh, GitHub and MCP registries and ranked by real installs. Every one of these makes the output better and quieter rather than handing the agent more power.

1. caveman - forces blunt, literal, no-hedging output; strips the filler and the "as an AI" throat-clearing. Skillselion · GitHub - 343k installs.
2. ui-ux-pro-max - a taste layer for interfaces: spacing, hierarchy, restraint, the things a model gets wrong by default. Skillselion · GitHub - 263k installs.
3. design-taste-frontend - opinionated frontend taste so generated UI stops looking generated. Skillselion · GitHub - 250k installs.
4. improve (shadcn) - a tight "make this better" pass that refines what you already have instead of regenerating it. Skillselion · GitHub - 22.4k installs.
5. karpathy-guidelines - Andrej Karpathy's coding taste, distilled into a skill the agent can follow. Skillselion · GitHub - 17.8k installs.
6. ponytail - minimal-code discipline: ship the smallest change that works, not the cleverest one. Skillselion · GitHub - 14.2k installs.
7. stop-slop - a filter that cuts the AI writing tells: the hedges, the rule-of-three, the "as an AI" tic. Skillselion · GitHub - 6.9k installs.

None of these add a tool. None of these spawn a subagent. Every one narrows what the model is allowed to do and how it is allowed to sound.

Why the quiet skills are winning

A more powerful setup gives you more surface area to go wrong. Another MCP server is another routing decision the agent can fumble. Another subagent is another context window to keep coherent. The marginal agent you bolt on rarely earns the coordination cost.

caveman is the clearest case. It adds no capability at all. What it does is govern the output, and 343k developers decided that governor was worth more to them than another agent. Most people, most of the time, will make the same call, and the install numbers say a lot of them already have.

There is a search signal underneath this too. When someone types "taste" or "stop slop" or "minimal" into Google, they are not looking for capability. They already have capability. They are looking for a governor on it. The breakout terms are the tell: the demand is for judgment, not horsepower.

Two things worth taking away

• The install-ranked list disagrees with the discourse. The viral setups optimize for how impressive a screenshot looks. The installs optimize for what people keep using on Tuesday. When those two diverge, trust the installs.
• Taste is now a distributable artifact. A year ago good taste lived in a senior engineer's head. Now it ships as a skill file that 250k people can install. That is a genuinely new thing, and it is the most underrated category in the ecosystem right now.

If you are stacking agents to feel productive, try deleting most of them and adding one taste skill instead. The install-ranked catalog says you will not miss the agents.

Skillselion is an independent directory of Claude Code, Codex and Cursor skills, MCP servers and marketplaces, ranked by real installs. Not affiliated with Anthropic, OpenAI or Cursor.

What is the intended flow?

Pocock's video tutorial (July 9, 2026) walks five skills and is explicit that the order is the point:

"Watch me walk through the essential skills: /grill-with-docs, /to-spec, /to-tickets, /implement, /code-review. It's the whole flow, end-to-end."

Read it as a pipeline, not a toolbox:

1. /grill-with-docs: a relentless one-question-at-a-time interview that sharpens the plan and writes terminology and decisions to docs as it goes. Pocock calls it "the easy entry point" (reply).
2. /to-spec: turns the conversation into a spec (a PRD) and publishes it to the issue tracker. No interview, pure synthesis.
3. /to-tickets: breaks the spec into tracer-bullet tickets, each declaring which tickets block it.
4. /implement: executes the tickets test-first at agreed seams.
5. /code-review: judges the diff on two axes: repo standards and conformance to the spec.

One prerequisite makes it portable: run /setup-matt-pocock-skills once per repo. "Works with literally anything you can connect to programmatically, with zero changes to the skills" (GitHub, Jira, Linear, or local files) (Jul 8, Apr 28).

Where does /wayfinder fit?

Above the flow. /wayfinder, the v1.1 headliner, plans work "too big for one agent session" as a shared map of investigation tickets. It plans; it does not build (aihero.dev doc). Pocock's positioning, in his words:

"/grill-with-docs? No I think that will remain the easy entry point. /wayfinder for intermediate/advanced users." (Jul 9)

"You'll find wayfinder intuitive, I promise. It's just a more organized and foolproof grill-me." (Jul 2)

/research and /prototype exist to feed it, "or can be used independently" (v1.1 announcement).

What was deprecated, and what replaced it?

The deprecated folder's README is one line: "Skills I no longer use." On the culling philosophy, replying about an unused skill: "Yah I experimented with it, never used it, deprecated it and will remove it" (Jun 21).

A detail from the commit log: during the v1.1 release a sequential /to-plan skill was added at 13:11 UTC and unified away into /to-spec + /to-tickets at 13:18. Seven minutes (commit history).

Why did /to-prd become /to-spec?

Announced six days before v1.1, with an apology:

"/to-prd is changing to /to-spec. /to-issues is changing to /to-tickets. Apologies for the churn, but I've been wanting to make this change for a while and now's the time to do it." (Jul 2)

The reasoning is semantic, from the same thread: "Yep, /to-prd currently produces a spec. Tickets and issues are basically interchangeable" (reply). A skill's name is part of the prompt an agent reads, so the name now matches the artifact the next skill in the chain consumes. The same logic drove v1's split into model-invocable and user-invocable skills and its "63% reduction in token cost for skill descriptions" (v1 announcement).

What explicitly survived?

"/grill-me and /grill-with-docs still around" (Jul 6), and v1.1 shipped "crucial fixes to /grill-me". Install data agrees: grill-me is the repo's flagship at roughly 508k installs, ahead of grill-with-docs (424k) and tdd (400k).

How do you keep up?

• Update: run npx skills@latest add mattpocock/skills (v1.1 announcement).
• Watch the changelog on aihero.dev and his X profile. Every removal so far came with a successor or an explanation.
• His video overview: 5 Claude Code skills I use every single day (YouTube, @mattpocockuk).
• The living version of this map, with install counts and the full SKILL.md for every skill including the deprecated ones: Matt Pocock's skills, mapped on Skillselion.

Disclosure: I build Skillselion, an install-ranked directory of agent skills and MCP servers. Every quote above links to the original post and was verified against it before publishing. Skillselion is not affiliated with Matt Pocock or AI Hero.

Here is the part nobody at the launch party mentioned: developers already voted for this feature, months ago, with installs.

What were developers installing before the browser arrived?

The install counts below come from the Skillselion live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs.

• agent-browser (GitHub) - Vercel's browser-automation CLI for agents. 533,255 installs, which puts it in the top handful of skills across the entire catalog. Not top of the browser niche. Top of everything.
• playwright-cli (GitHub) - Microsoft's Playwright driver for agent sessions, 82,449 installs.
• playwright-best-practices (GitHub) - 59,422 installs for a skill that just teaches the agent to write non-flaky tests.
• chrome-devtools (GitHub) - 13,334 installs from GitHub's own skill collection.
• chrome-devtools-mcp (GitHub) - the Chrome team's official MCP server, 4,923 installs against a 46,640-star repo.
• browser-automation (GitHub) - 5,732 installs.
• a11y-debugging (GitHub) - 1,439 installs for accessibility audits driven from the agent.

Add that up and you get well over 700,000 installs of "give my coding agent a browser" across one directory. That is the single largest capability gap developers have been patching by hand.

Takeaway 1: browser access is the gap between an agent that writes code and an agent that verifies code. An agent that cannot load the page it just changed is doing open-loop control, and every developer who installed one of the tools above had already figured that out.

Does the built-in browser kill the browser-skill stack?

Mostly no, and the reason is scope.

The in-app browser is sandboxed and session-scoped. It is excellent at the read-and-poke loop: pull the docs for the library you are wiring in, click the button you just rendered, check the network tab equivalent, iterate. The tab-switching tax on that loop was real, and it is gone. That is what 16,000 people were cheering.

What it does not replace:

• CI-grade end-to-end testing. Playwright skills exist so the agent writes tests that survive after the session ends. A sandboxed session browser produces no artifact your pipeline can rerun. The 82,449 installs of playwright-cli are not going anywhere.
• Performance work. Tracing layout shifts and LCP regressions is DevTools-protocol territory, which is exactly why the Chrome team ships chrome-devtools-mcp as a full MCP server rather than a browsing feature.
• Accessibility audits. a11y-debugging runs structured checks, not clicks.
• Anything headless at scale. Crawls, form-fill batches, screenshot matrices: agent-browser exists precisely because a visible single tab is the wrong tool for that shape of work.

Takeaway 2: the built-in browser replaces glue, not the stack. Verification is consolidating into the agent, and the specialized layers (test generation, DevTools traces, a11y) are the parts that compound.

What should you actually do on Monday?

If you are on the Claude Code desktop app, update and try Cmd+Shift+B on your own dev server. Then look at what the heavy installers pair with it: the best-of catalog ranks browser, testing and debugging skills by live install counts, so you can see which of the tools above developers keep after the honeymoon.

The agents got eyes this week. The interesting question is what they look at.

I help maintain Skillselion, a directory of Claude Code, Codex and Cursor extensions ranked by real installs. Stats above are live catalog numbers as of July 11, 2026. Originally published on dev.to.

OpenAI claims roughly 54% better token efficiency for coding in this generation. Developers are discovering the opposite problem in practice: stronger models invite heavier consumption. An agent that runs longer eats the efficiency gain in raw volume, and every plan (OpenAI's 5-hour windows, Anthropic's limit windows, Cursor's credits) still caps you the same way. Tokens in, tokens out.

Here is the uncomfortable take: most of the tokens your coding agent burns are spent on context you did not need to send. Re-exploring the repo it explored yesterday. Re-reading a 900-line CLAUDE.md on every turn. Carrying a whole conversation into a task that needed three files. A bigger plan does not fix that. It just raises the ceiling on the same waste.

There is a second signal worth taking seriously. Claude Code shipped a /checkup command two days ago that scans for exactly this: unused skills, oversized CLAUDE.md files, config bloat. When the tool vendor starts shipping hygiene tooling, the waste is no longer a niche complaint: even the vendor is telling you your setup is burning tokens it does not need.

What developers actually install to spend fewer tokens

We track install counts across the live Skillselion catalog (refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs). Filtered to token and context efficiency, this is the ranked shortlist developers are voting for with their installs:

1. subagent-driven-development - 140,798 installs (GitHub) Dispatch each task to a fresh subagent with a bounded context instead of dragging one long conversation through an entire plan. The parent pays for a summary, not the whole transcript. This is the single most installed context-control pattern in the catalog.

2. improve - 20,365 installs (GitHub) shadcn's planning skill: survey the codebase once, produce prioritized, self-contained implementation plans that another agent can execute without additional context. That last clause is the token play. Sitting at #2 on our trending-in-search rail right now.

3. ponytail - 12,544 installs (GitHub) Forces the simplest, shortest solution at every step and deletes speculative code before it exists. Flagged Breakout on our trending-in-search rail over the last 30 days. Minimal solutions are cheaper twice: fewer output tokens now, less code for the agent to re-read on every future turn.

4. context-engineering - 9,762 installs (GitHub) Addy Osmani's take on deliberately curating what the agent sees, when it sees it, and how it is framed. The discipline layer the other skills assume.

5. context-map - 9,357 installs (GitHub) Generate a precise map of relevant files, dependencies and tests up front, so the agent navigates instead of exploring. Exploration is the silent budget killer: every wrong file opened is paid for again in every later turn that carries it.

6. remembering-conversations - 8,891 installs (GitHub) Recall relevant past sessions instead of re-deriving decisions. The cheapest token is the one you already paid for last week.

7. claude-md-improver - 6,960 installs (GitHub) Anthropic's own auditor for CLAUDE.md files. Your project memory file is loaded on every single turn; a bloated one is a tax on everything. This is the standing version of what /checkup now does as a one-shot.

Two takeaways

Takeaway 1: usage limits are a context-engineering problem, not a pricing problem. The developers complaining loudest about 5-hour windows and the developers installing plan-first, subagent and memory skills are solving the same problem from opposite ends. One end costs $200/month more. The other is mostly free.

Takeaway 2: the install data says efficiency is becoming a default stack layer. Hygiene and context-control skills now sit among the most installed tools in the catalog, and the breakout search trends (ponytail, improve) are both efficiency plays. The ecosystem is maturing from "make the agent do more" to "make the agent carry less."

New models will keep landing every few weeks. GPT-5.6 today, the next Claude tomorrow. The developers who get the most out of every one of them are the ones whose setup sends the fewest wasted tokens per task. That stack is above, ranked by the people already running it.

Data: live Skillselion catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs. Install counts captured July 10, 2026.

I run Skillselion, a directory of Claude Code, Codex and Cursor skills, MCP servers and marketplaces ranked by real installs.

Supply was never the problem. There are tens of thousands of MCP servers and agent skills on GitHub right now. The problem is that "which one" is a data question, and most registries answer it with vibes.

I build one of these directories, so consider this both a field guide and a confession. Here is what each major registry is actually for, with the receipts.

The landscape, honestly

The official MCP Registry (registry.modelcontextprotocol.io) is the canonical namespace. It is machine-first: a JSON API of server manifests with exact install metadata, maintained under the Model Context Protocol org. What it deliberately is not: a ranking. There is no "best", no adoption data, no editorial. If you publish a server, you should absolutely be in it. It is the closest thing MCP has to npm's registry. But if you are choosing a server, it cannot tell you which of the four Notion entries people actually use.

mcpmarket.com is the volume play, and credit where due: they registered the domain two days after Anthropic announced MCP in November 2024, and 19 months of compounding first-mover authority shows. Their sitemap advertises roughly 38,000 server pages and around 250,000 skill pages, they publish daily top-10 lists, and they localize into four languages. Two things worth knowing as a user. First, rankings are by GitHub stars, a popularity proxy that ignores whether anyone installs the thing. Second, their robots.txt blocks AI crawlers like GPTBot, ClaudeBot, CCBot and Google-Extended: a deliberate trade that keeps their content out of the corpora your AI assistant learns from. That is their right. It also means the place many developers now ask first ("Claude, what's a good Postgres MCP server?") increasingly cannot cite them.

mcp.so was one of the first community directories and is still one of the largest link collections. It is a good breadth-first sweep. Its answer to "which one" is mostly "here are all of them."

Glama approaches from the client side. It is an AI workspace that happens to maintain a solid MCP server directory with quality signals attached. If you live in Glama, its directory is conveniently close to where you run things.

Smithery is the hosted angle: less "directory", more "we run the server for you." That is genuinely useful when you do not want to babysit processes, and beside the point when you are picking open-source software to run yourself.

Skillselion (skillselion.com) is ours, so grade this paragraph hardest. The bet is different: rank everything by real adoption. 81,864 tools tracked (agent skills, MCP servers, marketplaces) with 125 million recorded installs from the skills.sh registry and GitHub, refreshed daily. The Top 100 is one stable, install-ranked list. Per-vendor pages like the best Postgres MCP servers come with a hand-written verdict, and every vendor page is required to include the vendor's official server, marked OFFICIAL, because a "best Notion servers" page without Notion's own server is theater. Where install data does not exist (most MCP servers report none), we say so and rank by stars instead of pretending. All of it is open to every AI crawler, deliberately: the opposite trade from mcpmarket's.

Two takeaways worth arguing about

1. Catalogs answered 2024's question. Rankings answer 2026's. When there were 500 servers, "a big list" was the product. At 50,000+, the list is a commodity; GitHub search is a list. The scarce thing is trustworthy ordering: install counts, freshness, dead-repo pruning, duplicate collapsing. Judge any registry by whether its #1 result carries evidence, not by its total.

2. A registry that blocks AI crawlers is invisible in the place developers now ask. Developers increasingly pick tools by asking their assistant, not by browsing directories. Whatever you think of AI training economics, blocking GPTBot and ClaudeBot means the assistant answering "which Postgres MCP server?" literally cannot read your rankings. Watch this become the quiet dividing line between registries over the next year.

The boring, practical answer

Publish to the official registry (canonical), then check an adoption-ranked directory before installing anything with filesystem or network access. If you want the current state of the ecosystem in numbers (how many servers, skills and marketplaces exist, and what people actually install), the data report is free to cite: The State of AI Agent Skills 2026.

And if your server made a Top 100 or a vendor page, there is a badge for your README. Backlinks are the oldest ranking system there is.

Disclosure: I build Skillselion. Every number above is either from a public file you can check (sitemaps, robots.txt, the registry API) or from our live catalog, dated July 9, 2026. Skillselion is an independent directory, not affiliated with Anthropic, OpenAI, or any vendor named here.

1. Clean up unused skills, MCPs and plugins to save context
2. Dedup your local CLAUDE.md against the checked-in CLAUDE.md
3. Break up a large root CLAUDE.md into nested CLAUDE.md files plus skills
4. Turn off slow hooks
5. Update Claude Code to the latest version
6. Enable auto mode by default
7. Pre-approve frequently denied read-only commands

The 2.1.205 changelog frames it as /doctor growing into "a full setup checkup that can diagnose and fix issues", with /checkup as its alias.

Why unused skills are not free

The interesting part is item 1. Skills feel free because they sit on disk until triggered. They are not. Every installed skill contributes its name and description to what the model reads when deciding what to load, so a pile of skills you never use costs tokens on every session and makes routing worse: two skills with overlapping descriptions can silently steal each other's triggers.

Anthropic building deletion into a first-party command is a strong signal. The ecosystem phase where you install 50 skills to feel prepared is ending. The question that matters now is the opposite one: which skills actually earn a permanent slot?

The skills that survive a /checkup

Install counts answer that better than any listicle, because an install that survives cleanup week after week reflects real use. The data below is from the Skillselion live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs (checked today, July 9).

1. find-skills (vercel-labs/skills) - 2,402,309 installs. A meta-skill that discovers and loads other skills on demand. It is the /checkup philosophy productized: install one small router, load everything else mid-task, keep nothing resident.
2. frontend-design (anthropics/skills) - 640,200 installs. Anthropic's own skill for building interfaces that do not look AI-generated. Fires on a huge share of real sessions, which is exactly why it survives.
3. vercel-react-best-practices (vercel-labs/agent-skills) - 535,433 installs. Framework guidance the model would otherwise guess at. If you write React weekly, this triggers weekly.
4. agent-browser (vercel-labs/agent-browser) - 524,998 installs. Gives the agent a browser for verifying its own frontend work. Capability skills like this cannot be replaced by a better prompt.
5. grill-me (mattpocock/skills) - 486,725 installs. Matt Pocock's plan stress-tester: it interviews you about your design until the gaps show. A workflow skill, not a knowledge skill, and one of the few that developers keep.
6. web-design-guidelines (vercel-labs/agent-skills) - 447,981 installs. Design review against concrete guidelines instead of vibes.
7. remotion-best-practices (remotion-dev/skills) - 415,415 installs. Narrow, single-domain, maintained by the vendor. The exact shape of skill that never gets flagged as cruft.
8. tdd (mattpocock/skills) - 381,925 installs. Enforces test-first discipline on the agent. Process skills survive because they change behavior on every coding task, not just some.

One bundle deserves its own mention: microsoft/azure-skills (GitHub) ships 16 skills that each sit between roughly 380,000 and 440,000 installs. Vendor bundles ride together: teams deploying on Azure install the whole set and keep the whole set.

The pattern

Three traits separate keepers from cruft:

• They trigger weekly, not theoretically. Framework and process skills fire on ordinary work. The conference-demo skill you installed in March does not.
• They are narrow. A skill that does one job has a precise description, so the router finds it reliably. Kitchen-sink orchestrator skills are the first thing /checkup should eat.
• They either know something or do something. Vendor-maintained knowledge (React, Remotion, Azure) or a real capability (a browser). Skills that merely rephrase what the model already knows do not survive contact with a cleanup pass.

Run the numbers on your own setup

You do not need to wait for /checkup to reach your version. Ask Claude Code to list your installed skills, then ask which of them actually fired in your last twenty sessions. Anything at zero is a candidate. Keep the router-style discovery skill, keep what fires weekly, cut the rest, and let install-ranked data arbitrate what is worth re-adding: the full ranked catalog is at skillselion.com/skills.

I run Skillselion, a directory of Claude Code, Codex and Cursor extensions ranked by real installs. Install counts above are from the live catalog, checked July 9, 2026.

I pulled the numbers from the Skillselion catalog, ranked by real installs, so this is what developers run rather than what a thread says they should.

The idea in one line

A single Claude Code agent loses the plot over many files. A dev-team setup splits the work: an orchestrator delegates, subagents each own a slice, results return to the main thread. You are running a few reliable roles, not 132 personalities. The skills below are those roles.

The stack, ranked by installs

1. frontend-design (anthropics/skills) - 628,875 installs The most-installed skill here. It is the teammate you hand UI work to, carrying taste and layout conventions so the agent stops shipping generic scaffolding.

2. brainstorming (obra/superpowers) - 261,134 installs The planning gate. It blocks code until the design is approved, one question at a time, turning "sounds reasonable" into an actual spec.

3. systematic-debugging (obra/superpowers) - 173,346 installs Reproduce, minimise, hypothesise, fix, regression-test. The on-call teammate you route a failing test to instead of asking the main thread to guess.

4. using-superpowers (obra/superpowers) - 171,091 installs The orchestration meta-skill, the layer that knows which other skill to reach for. Closest single install to the "one bot into a team" idea.

5. requesting-code-review (obra/superpowers) - 155,120 installs The reviewer seat, a separate review pass with its own standards. This is exactly where OpenAI's Codex-in-Claude-Code plugin slides in: let Codex read the diff Claude just wrote.

6. subagent-driven-development (obra/superpowers) - 135,061 installs The build loop that spawns focused subagents per task. The literal dev-team pattern, and 135k installs say a lot of people run it rather than tweet it.

7. mcp-builder (anthropics/skills) - 85,298 installs Not "which MCP do I install" but "how do I build one for my stack." This teammate writes the server so the rest of your team gets a new tool to call.

8. workflow-orchestration-patterns (wshobson/agents) - 8,946 installs The patterns layer for wiring multi-step agent workflows, from the wshobson/agents pack a lot of setups pull from. Worth it once you have more than three roles talking.

Where OpenAI's Codex plugin fits

codex-plugin-cc runs Codex as an agent inside Claude Code. It is another seat, not a replacement: Claude plans and builds, Codex reviews or takes the rescue pass, and requesting-code-review above is the natural handoff. Already running that review skill? Wiring Codex in is a small step.

How to read the numbers

Install count is a rough vote: it means a lot of developers kept the skill, not that it is best for your repo. Treat the top as a worth-installing shortlist and pick the roles you actually need. Build plus review covers most days.

I run Skillselion, the directory these counts come from: live catalog, refreshed daily from skills.sh, GitHub and MCP registries, ranked by real installs. For the full ranked list per role, browse the skills catalog. Independent project, not affiliated with Anthropic, OpenAI or Cursor.

The setup making the rounds on AI-coding X this week is turning one Claude Code CLI into a small dev team: specialized agents for review, testing and DB work, hooks for guardrails, and a shelf of MCP servers for real tooling. The viral screenshots (132 agents, dozens of commands, 25+ MCPs) look impressive, but they raise a practical question: which pieces are actually worth installing, and which are noise?

We run a directory that ranks Claude Code skills, MCP servers and marketplaces by real install counts, refreshed daily from skills.sh, GitHub and the MCP registries. So instead of guessing, here is what the install data says a defensible "dev team" stack looks like right now.

What the catalog actually holds

Today the catalog tracks 67,052 skills, 8,120 MCP servers, 10,246 marketplaces and 2,385 plugins: 87,803 listings across every type, carrying over 128 million recorded installs. The single largest slice is agent-tooling, 37,468 skills whose whole job is to make an agent behave like part of a team. That is the raw material the "dev team" trend is built from.

How you turn one agent into several

If you want parallel subtasks instead of one long serial prompt, the install counts point to a clear starting set: subagent-driven-development (134,040 installs) fans independent steps out to subagents; writing-plans (170,580) and executing-plans (141,389) are the plan-then-execute loop that keeps a long task from drifting; and using-superpowers (169,910) is the entry-point skill that teaches Claude when to reach for the rest. These change how the agent works rather than what it can call, which is why they sit under almost every serious multi-agent setup.

The specialist roles: review, testing, debugging

A dev team is only useful if the specialists are real. The most-installed role skills: requesting-code-review (154,036) and receiving-code-review (126,571) run the request-and-address loop that catches bugs before they ship; systematic-debugging (172,160) is a disciplined bug hunt instead of guess-and-check; and webapp-testing (109,599) drives a browser to actually exercise the app. One security note the viral threads skip: a "reviewer" agent that still holds a Bash tool is not read-only. A Bash tool can still run commands that change the repo, even with Write denied. If you want a genuinely read-only role, gate it with a PreToolUse hook, not just a tools allowlist.

A starter stack that is not 132 agents

You do not need the maximal setup. The minimum viable Claude Code dev team is about four skills and two MCP servers: using-superpowers plus writing-plans for the orchestration spine, subagent-driven-development for parallel work, requesting-code-review and systematic-debugging for the specialists, and two or three MCP servers for your real stack (DB, browser, your API). Add roles when a task actually needs them, not because a screenshot had 25 MCPs.

Browse the ranked stack

Every skill and server above is a real, installable entry ranked by install count. Browse the full agent-building set at https://skillselion.com/category/ai-agents , or load the ranked shortlist mid-task without installing anything through the Skillselion MCP at https://skillselion.com/skillselion-mcp .

Skillselion is an independent directory, not affiliated with Anthropic, OpenAI or Cursor. Counts come from the live catalog, refreshed daily from skills.sh, GitHub and the MCP registries, ranked by real installs.

The catalog in numbers

Across Claude Code, Codex, Cursor, and other coding agents this week:

• 86,047 extensions total

• 65,933 agent skills

• 9,828 plugin marketplaces

• 7,901 MCP servers

• 2,385 plugins

• 120.2 million recorded installs

Skills make up 77% of the catalog. One skill is one SKILL.md file, so anyone with a text editor and a git push ships one.

What everyone is building

Sort by the job each extension does and the pattern jumps out:

• Agent tooling: 37,265 (context, memory, orchestration, sub-agents)

• Integrations: 12,165 (agents wired to APIs and services)

• Backend: 6,786

• Frontend: 5,070

• Security and review: 2,386

• Docs: 1,897

Agent-tooling beats backend, frontend, docs, and security put together. Developers sharpen the agent before they point it at the actual product.

The gap almost nobody is working

Now count the extensions for shipping and growing a product instead of building it:

• Launch and distribution: 627

• App store optimization: 107

• Generative engine optimization: 71

• Audience and positioning: 84

Seventy-one extensions help you get your work in front of users. Thirty-seven thousand help the agent write code. If you build for these agents and want a niche nobody has crowded, that space is wide open.

The real problem is finding the one you need

66,000 skills is not too few. It's too many to hold in your head. You won't remember a skill exists at the moment you need it, and you won't scroll a 66k-row list in the middle of a task.

Two things we lean on:

1. Rank by installs, not stars. A star means someone bookmarked it. An install means someone ran it. The top of those two lists barely overlaps.

2. Pull skills in mid-task. We built an MCP that queries the catalog from inside the agent. Describe the gap in plain words, get the top-ranked skill loaded, keep working. It runs in Claude Code, Codex, and Cursor.

See what ranks for your stack

Type your stack into the catalog and watch which skills people actually install, no signup needed: skillselion.com. Or drop the loader, skillselion-mcp, into your agent and let it pull the right skill the next time you hit a wall.

Numbers here come from the live catalog on the day of writing, discovered daily from skills.sh, GitHub, and the MCP registries, and ranked by real installs. Independent project, not affiliated with Anthropic, OpenAI, or Cursor.