Top 100 Claude Code Skills, Ranked (2026)

The insider's field guide to the SKILL.md packages that turned Claude Code from a clever autocomplete into a specialist that ships real work.

One skill, find-skills, has been installed more than 2.1 million times. Another, superpowers, crossed roughly 232,000 GitHub stars and was pulled into Anthropic's own plugin marketplace in January 2026. The official document skills that quietly power Word, Excel, PowerPoint and PDF generation inside Claude run for tens of millions of people who have never heard the word "skill." In the span of eight months, a single file format, SKILL.md, became the most consequential extensibility layer in agentic coding.

But here is the problem most people run into: the word "skill" now means at least four different things, the marketplaces are flooded with thousands of look-alike repos, and the star counts you see quoted are mostly scraped, inflated, and impossible to audit. A reader who wants to actually equip Claude Code with the right capabilities has no reliable map. Picking the wrong skills wastes context, leaks permissions, and occasionally hands a stranger's instructions root access to your machine.

This guide is the map. It explains what a Claude Code skill really is (and what it is not), the progressive-disclosure mechanics that make hundreds of skills viable at once, a transparent scoring method, and then a ranked field of 100 real, source-linked skills spanning documents, engineering, design, security, mobile, science and the meta-layer that builds more skills. It is written for someone who manages outcomes, not someone who memorizes YAML. Every model name, price and statistic here was verified against primary sources in June 2026, because in this field a number that is twelve months old is already wrong.

Contents

1. What a Claude Code skill actually is
2. The mechanics: progressive disclosure and bundled code
3. How we ranked 100 skills
4. The complete Top 100, ranked
5. The S-tier: official skills that ship default-on
6. The software-engineering core loop
7. Design, frontend and creative skills
8. Security, data and the specialist frontier
9. The extensibility layer: skills that manage skills
10. How to build and install a skill in five minutes
11. The marketplace ecosystem and who controls it
12. Pricing and the token economics of skills
13. Where skills fail, and the security problem nobody advertises
14. The future: skills as the portable capability layer
15. Conclusion: building your skill stack

The Top 15 at a glance

Before the full field, here is the scored summary. The table ranks the fifteen highest-impact skills on four criteria that a practitioner actually feels: Impact (does it unlock work that was genuinely hard before), Adoption (does it ship by default or carry real, repeated usage), Reliability (is it mature, maintained, and backed by deterministic code rather than vibes), and Ease (how much friction stands between you and using it). Each cell carries the score and the evidence behind it, so you can disagree with the math rather than the conclusion.

The weights sum to 100% (Impact 35, Adoption 25, Reliability 25, Ease 15), each score runs 0 to 10, and the final column is the weighted average rounded to one decimal. The list is sorted globally by that final score, not within categories, with alphabetical tiebreaks. The pattern that falls out is not subtle: official skills that ship default-on dominate the top, because they max out adoption and ease while being backed by real code. The complete 100-entry field, with the full methodology and its honest caveats, follows in sections 3 and 4.

1. What a Claude Code skill actually is

The single biggest source of confusion in this space is that "skill" sounds generic, like a feature you toggle. It is not. A Claude Code skill is a specific, simple thing: a folder containing a file called SKILL.md, which holds a short block of YAML frontmatter (a required name and a required description) followed by Markdown instructions, and optionally some bundled scripts and reference files. That folder teaches Claude how to do one job well, and Claude pulls it in only when the job comes up. Anthropic shipped this format on October 16, 2025 and described it as folders that package "instructions, scripts, and resources" the model loads on demand - Anthropic Engineering.

Why does such a plain idea matter? Because it solves a real economic problem. A large language model is a generalist with a finite working memory (its context window). You cannot paste a 40-page brand manual, a 200-rule accessibility standard, and a company's deployment runbook into every conversation. A skill lets you write that expertise down once, store it on disk, and have the model reach for the relevant page only when the task demands it. The result is a generalist that behaves like a specialist on command, without paying the token cost of every specialty all the time. That is the whole game, and the rest of this guide is downstream of it.

The official anatomy is worth seeing once. The image below, from Anthropic's launch post, shows the structure: a top-level SKILL.md plus organized folders of supporting material that Claude can open when needed.

The frontmatter rules are stricter than they look, and they are the reason skills compose so cleanly. The name field is capped at 64 characters, must be lowercase letters, numbers and hyphens, and cannot contain the words "anthropic" or "claude," while the description is capped at 1,024 characters and is the single most important line you will write - Claude API Docs. That description is what Claude reads to decide whether a skill is relevant, so a vague description means a skill that never triggers and a sharp one means a skill that fires at exactly the right moment. Practitioners who complain that "my skill does not activate" almost always have a weak description, not a weak skill.

Where this trips people up most is the difference between a skill and the other four things in Claude Code's steering layer. An MCP server is an external connection to a live system (a database, an API, a SaaS tool), a slash command is an explicit prompt you type, a subagent is an isolated context window doing delegated work, and a hook is deterministic code that fires on an event. A skill is none of those: it is filesystem-based knowledge the model discovers and applies by itself. Anthropic lays out exactly these distinctions in its steering guide - Claude blog. The practical upshot is that these primitives stack rather than compete, and a plugin is simply a versioned bundle that can carry skills, subagents, hooks and MCP definitions together.

There is one more distinction that matters for where you store things. In claude.ai, skills are managed per user and Anthropic ships a set of pre-built ones. In the Claude API, skills are workspace-wide and you opt in with beta headers. In Claude Code, every skill is a plain folder on your filesystem: personal skills live in ~/.claude/skills/, project skills live in .claude/skills/, and since version 2.1.6 Claude even discovers skills nested in subdirectory .claude/skills folders as it works - Claude Code Docs. For a non-technical reader, the takeaway is that a Claude Code skill is portable, inspectable, and yours: it is a folder you can read, edit, version in git, and share, with no upload step and no vendor lock-in. If you want the broader context of how the underlying tool works, our Claude Code beginner's guide covers the surrounding workflow in plain language.

2. The mechanics: progressive disclosure and bundled code

The reason a skill is more than a saved prompt comes down to two engineering decisions that are easy to miss and impossible to overstate: progressive disclosure and bundled code execution. Together they answer the question that kills most "just give the model more context" ideas, which is how you can have hundreds of specialized skills available without drowning the context window or the bill. Understanding this is what separates someone who installs skills at random from someone who builds a stack that stays fast and cheap as it grows.

Progressive disclosure means a skill loads in three levels, like a manual you do not read cover to cover. At Level 1, Claude sees only the metadata: the name and description, roughly 100 tokens per skill, always present so the model knows the skill exists. At Level 2, when a task looks relevant, Claude reads the full SKILL.md body, kept under about 5,000 tokens. At Level 3, and only if needed, it opens bundled resources such as a REFERENCE.md, a FORMS.md, or a script, which are effectively unbounded because they never sit in context until referenced - Claude API Docs. The official diagram frames it as a library: the table of contents is always loaded, chapters open when relevant, and appendices open only on demand.

The payoff is measurable. Anthropic reports that this model delivers roughly 70 to 90 percent token savings compared with loading equivalent context upfront, which is the difference between a stack of ten skills being free and being unusable - Claude API Docs. This is why the format scales: you can have fifty skills installed and pay almost nothing for the forty-nine that are irrelevant to the current task. It also reframes how you should think about "installing too many skills." The cost of an installed-but-unused skill is about a hundred tokens of metadata, so breadth is cheap and the real risk is not bloat but mis-triggering, which we return to in section 13.

The second decision, bundled code execution, is the one that turns reliability from a hope into a guarantee. A skill can ship actual scripts (Python is dominant, and the official anthropics/skills repository is roughly 84 percent Python by language composition) that Claude runs through bash. Crucially, the code itself never enters the context window: only its output does. So when the xlsx skill builds a spreadsheet, it is not the model freehand-typing cell formulas and hoping, it is the model invoking deterministic code that produces a correct file every time. The image below shows this pattern, where a script runs as a tool and only the result returns to the conversation.

This code-versus-instructions split is the quiet reason the document skills sit at the very top of the ranking. Generating a valid PowerPoint or a PDF with filled form fields is a task where a purely generative model is unreliable and a code-backed skill is nearly bulletproof. The lesson generalizes: the best skills push determinism down into bundled code and reserve the model's judgment for the parts that genuinely need judgment. When you evaluate a skill, the first question worth asking is whether it ships code or only prose, because that single fact predicts most of its reliability. The same principle drives how we think about agent design more broadly, which our guide to building AI agents explores at the architecture level.

3. How we ranked 100 skills

A ranking is only as honest as its method, so here is ours in full, including the part most "top skills" lists quietly hide. We scored every candidate on the four weighted criteria introduced earlier: Impact at 35 percent because a skill that unlocks genuinely hard work is worth more than a convenient one, Adoption at 25 percent because default-on distribution and repeated real usage are the strongest signals of value, Reliability at 25 percent because a skill that fails intermittently is worse than no skill, and Ease at 15 percent because friction at install and invocation time quietly determines whether a skill is ever actually used. The final score is the weighted average, and the field is ranked globally rather than within categories so a great security skill can outrank a mediocre document skill.

Now the honesty most lists skip. When we tried to assemble a clean hundred of individually named, source-verifiable skills, the rigorous count came in lower than a hundred. Roughly 44 standalone skills can each be tied to a working repository or official docs page with high confidence. The number balloons past a hundred only because the heavyweight packs each bundle many: superpowers ships around fourteen composable skills, Trail of Bits ships seventeen security skills, the scientific skills library lists well over a hundred, and broad collections like alirezarezvani/claude-skills advertise 345 skills across 17 domains. So the true population of named skills runs into the thousands, while the population of individually auditable ones is modest.

Our resolution is to rank a curated field of 100 entries that mixes three honest things: standalone skills you can install on their own, the marquee member-skills of the major packs (each credited to its parent repo), and the official partner skills Anthropic shipped when it made the format an open standard. Every row maps to a real source. What we refuse to do is invent filler names to round out a list, because a fabricated skill name is worse than a short list, and the AI ecosystem already has a credibility problem with numbers that cannot be checked.

That credibility problem deserves a flag of its own. Almost every star and install figure in this space comes from secondary directories, page scrapes, or self-reported marketing, not audited APIs. The same repository is quoted at 40,900 stars by one source and 89,000-plus by another within the same week. Install counts on directories like skills.sh are real signals of momentum but are not independently verified. Throughout this guide, treat every count as reported, not audited: useful for ranking relative popularity, useless as a precise figure. We deliberately weighted default-on official distribution more heavily than any star count for exactly this reason, since "ships in claude.ai for everyone" is a fact you can verify and "234,000 stars" is a number you mostly have to trust. With the method on the table, here is the full field.

4. The complete Top 100, ranked

This is the deliverable: one unified, globally ranked table of 100 skills with a category column so you can still see which domain each belongs to. The ordering reflects the same Impact, Adoption, Reliability and Ease blend used for the scored top fifteen, extended down the field by editorial judgment where the differences between adjacent skills are too small to score to a decimal. Standalone skills and packs link to their source. Member skills are credited to their parent pack (named in the row) rather than re-linked, and the six partner skills at the bottom are the named integrations Anthropic shipped when it opened the standard.

Read the table as a field map, not a leaderboard to climb in order. The right move for any given user is rarely "install the top ten," it is "install the official defaults you already have, add the one or two packs that match your work, and ignore the rest until a real task calls for them." The profiles in sections 5 through 9 explain the highest-leverage entries in depth, and the security discussion in section 13 is mandatory reading before you install anything from a community row.

The shape of this field tells you where the energy is. Plotted by category, the single largest block is software engineering and workflow, which is unsurprising given that Claude Code is a coding tool, but the second and third blocks (the extensibility and meta layer, and the marketing plus science verticals) reveal where skills are quietly eating non-coding work.

What the distribution conceals is concentration of trust. A handful of publishers (Anthropic, Vercel Labs, Jesse Vincent's obra project, Trail of Bits, Expo) account for most of the entries you would actually want, while the long tail of community repos is where both the genuine gems and the genuine risks live. If you remember one thing from this section, let it be that provenance beats popularity: a skill from a known engineering org with a maintained repo is worth more than a 50,000-star repo from an account you cannot verify. The rest of the guide is, in effect, an argument for that sentence.

5. The S-tier: official skills that ship default-on

The skills that matter most are the ones you already have and probably do not realize are skills. When you ask Claude to "turn this into a spreadsheet" or "draft a one-pager as a PDF," it is the xlsx, docx, pptx and pdf skills doing the work, and they are pre-built and default-on across claude.ai, the Claude API, AWS Bedrock and Microsoft Foundry - SiliconANGLE. They top the ranking for a structural reason rather than a popularity one: they cover the universal artifacts of knowledge work, they are backed by deterministic code so they almost never produce a corrupt file, and they cost the user zero setup. There is no install, no marketplace, no permission prompt, just a capability that appears exactly when the task implies it.

It is worth dwelling on why the document quartet beats every flashier skill. Before skills, asking a model to produce a real .pptx or a form-filled PDF was a gamble, because the model was effectively typing a binary file format from memory. With a code-backed skill, the model writes a short script that uses a battle-tested library, runs it, and returns a file that opens correctly in Office or Acrobat every time. The docx skill even supports tracked changes and comments, which is the kind of fidelity that turns "AI drafted something" into "AI produced the document my legal team can redline." This is the clearest illustration in the entire ecosystem of the principle that determinism belongs in code, and judgment belongs in the model.

Two official skills exist to make more skills, and they earn their high placement by being force multipliers. skill-creator is an interactive scaffolder that asks what you want, then generates a correctly structured SKILL.md folder with valid frontmatter, which is why it reports 278,500 installs despite being a tool most people use only occasionally. mcp-builder does the analogous job for the Model Context Protocol, guiding Claude to produce a clean MCP server, and it is the natural bridge between the two big Anthropic standards. If you are coming from the connector side of the world, our build your first MCP server guide pairs well with mcp-builder, and the broader history is covered in our piece on the Model Context Protocol launch.

The official design skills are where Anthropic addressed its own most-criticized weakness. frontend-design, the most-installed Anthropic skill at a reported 568,300 installs, exists specifically to push Claude away from the generic, samey "AI app" look toward bold, varied, intentional interfaces, and it pairs naturally with web-artifacts-builder for rich React and Tailwind output. brand-guidelines applies a company's real colors and typography to anything Claude produces, which is the unglamorous but high-value enterprise use case, and canvas-design and algorithmic-art extend Claude into visual output that used to require leaving the tool entirely. For teams that care about consistent visual identity, this cluster is the difference between AI output that looks like a prototype and output that looks like it came from the brand. Our Claude design guide goes deeper on this specific frontier.

Rounding out the official tier are the communication and creative utilities that make Claude useful outside engineering entirely. internal-comms writes status reports, newsletters and FAQs in a consistent organizational voice, and slack-gif-creator is the kind of small, reliable, code-backed skill that demonstrates the format's range. None of these will headline a conference talk, but collectively they are what most people actually touch every day, and their default-on distribution is precisely why they sit above community skills with far louder reputations. The practical guidance is simple: start here, because you already own all of it, and only reach for community skills once the official set leaves a real gap.

6. The software-engineering core loop

If the document skills are what most people touch, the engineering skills are what make Claude Code worth its subscription, and they cluster around a single insight: the bottleneck in AI-assisted coding is not writing code, it is verifying that the code is right. The built-in skills bundled into every Claude Code session map almost exactly onto the real engineering loop. /code-review examines the pending diff for correctness bugs and cleanups and can fan the work out to parallel reviewers, /debug runs hypothesis-driven diagnostics, /simplify does a quality-only pass for reuse and simplification, and the verification pair /run and /verify actually launch and drive the app so that "looks done" becomes "demonstrably works." Because these ship with the tool, they score high on adoption and ease without anyone installing anything.

The reason this loop matters so much is that the failure mode of every coding agent is the same: it produces something plausible that does not actually run. A model can write a hundred lines that type-check and still be wrong, and the only cure is execution against reality. That is why /verify and /run exist as distinct skills rather than tests, and why webapp-testing (an official skill that drives a real browser through Playwright) sits in the top fifteen. The pattern is a closed loop, and seeing it as a loop is what changes how you work: plan, change, review, then prove, with each stage backed by a skill rather than your own discipline.

The community heavyweight in this category is superpowers, and it deserves its number-nine ranking because it does not add one capability, it adds a methodology. Created by Jesse Vincent under the obra project, it bundles around fourteen composable skills (brainstorming, writing-plans, test-driven-development, systematic-debugging, subagent-driven-development and more) that activate automatically to impose engineering discipline that a raw model lacks. Its acceptance into Anthropic's official plugin marketplace on January 15, 2026 is the strongest possible signal of legitimacy, and it works across Claude Code, Codex CLI, Cursor and Gemini CLI rather than locking you in - obra/superpowers. The trade-off is honest: more moving parts mean more ways for the framework to over-trigger, so it rewards users who understand what each member skill is doing.

A quieter but equally important entry is claude-api, the bundled skill that injects up-to-date Anthropic API documentation, model IDs and pricing directly into context. Its value is preventing the single most embarrassing LLM failure: confidently writing code against a model name or API shape that was deprecated months ago. This is not a hypothetical, it is the daily reality of a field where model versions turn over monthly, and it is why a reference skill outranks many flashier tools. Matt Pocock's mattpocock/skills pack extends the same disciplined philosophy with member skills like diagnosing-bugs, domain-modeling, codebase-design, plus two genuinely original entries, handoff (which compresses a long session into a clean Markdown handoff document) and grill-me (which interrogates your plan before any code is written). For readers who want to understand the tool these skills steer at a deeper level, our inside Claude Code source analysis and the Claude Agent SDK deep dive are the two most relevant companions, and the competitive context lives in our roundup of open-source AI coders.

7. Design, frontend and creative skills

Design is the category where skills produced the most visible quality jump, because it is where raw models were weakest. Left alone, a language model generates interfaces that are technically functional and aesthetically identical, the now-recognizable "AI app" look of centered cards and timid gradients. The design skills exist to break that pattern, and the most-installed of them all come from two sources: Anthropic's own frontend-design, and Vercel Labs' suite of React-focused skills that codify the company's hard-won engineering standards. Together they have been installed well over a million times by reported counts, which tells you how badly the gap needed filling.

The Vercel cluster is the standout community contribution to this category, and it is worth understanding why an infrastructure company became the gravity well for frontend skills. react-best-practices packs more than forty performance rules across rendering, data fetching and bundling that agents routinely get wrong, web-design-guidelines audits a UI against over a hundred accessibility and UX rules and turns best practice into an automatic gate, and composition-patterns encodes idiomatic React structure. These are not opinions scraped from blogs, they are the rules Vercel's own engineers follow, which is exactly the provenance that makes a skill trustworthy. The lesson for skill selection generalizes: a design skill from the company that builds the framework is worth ten from anonymous accounts.

Beyond the web, the creative skills show the format stretching into territory that used to require separate tools entirely. remotion-best-practices brings deep, code-backed knowledge for generating video programmatically in React, claude-d3js-skill produces genuinely interactive data visualizations rather than static images, and Anthropic's algorithmic-art and canvas-design turn Claude into a generative-art and design-spec engine. The common thread is that each of these takes a domain where freehand generation is unreliable and grounds it in a real library, so the output is both creative and correct. If your work touches building and shipping actual web properties, our guide to building and deploying websites with Claude Code connects these design skills to the full pipeline.

The strategic point about design skills is that they are where the "agent that ships" promise becomes real for non-engineers. A founder who cannot write React can still get a distinctive, accessible, on-brand interface out of Claude because frontend-design and web-design-guidelines encode the taste and the rules that the founder lacks. This is the same democratizing pattern that platforms like o-mega push further by wrapping skills, browsing and deployment into an autonomous workforce that builds and runs a company through one conversation, so the user describes the outcome and the skills handle the craft. The design tier is the clearest proof that skills are not just for developers, they are for anyone who needs developer-grade output without developer-grade knowledge.

8. Security, data and the specialist frontier

The specialist categories are where skills move from convenience to genuine expertise, and security is the sharpest example. Most coding agents are mediocre at security review because the knowledge is deep, adversarial and easy to get subtly wrong, which is exactly the gap that trailofbits/skills fills. Trail of Bits is a top-tier audit firm, and they have packaged seventeen professional security skills covering CodeQL and Semgrep static analysis, SARIF triage, smart-contract auditing, C and C++ memory-safety review, differential analysis, constant-time analysis for timing side channels, and mutation testing. These are real audit workflows, not checklists, and the firm's reputation is the provenance that makes them worth running. Alongside them, the community ffuf_claude_skill encodes offensive web-fuzzing tradecraft for discovering hidden directories, subdomains and API paths during authorized penetration testing.

There is an important asymmetry to understand here, which is that the same property that makes security skills valuable also makes the skill format itself a security concern. A skill is executable instructions plus scripts that Claude runs with whatever tools you allow it, so a security skill from Trail of Bits is trustworthy precisely because you can verify who wrote it, while an anonymous "security" skill could just as easily exfiltrate your code. This is not a reason to avoid the category, it is a reason to be ruthless about provenance, and it is the bridge to the full security discussion in section 13. The right mental model is that you are not installing a document, you are granting a capability.

Data and science are the other specialist frontiers, and they show skills scaling into domains most people would never associate with a coding assistant. The xlsx skill anchors everyday data work, claude-d3js-skill handles interactive visualization, and at the deep end the claude-scientific-skills library from K-Dense AI bundles well over a hundred ready-to-use scientific skills across genomics, drug discovery, bioinformatics, cheminformatics and clinical medicine, wired to more than two hundred research databases. The reported claim that it serves over 160,000 scientists is marketing rather than audited fact and should be read as such, but the breadth of the library is verifiable and substantial. For a sense of where this is heading, our piece on AI for scientific discovery maps the broader trend these skills sit inside.

Mobile is the last specialist gap worth naming, because it is where general agents are weakest and where official-quality skills matter most. The expo/skills repository, maintained by Expo itself, ships authoritative React Native skills for building native UI, native data fetching, API routes, native modules, deployment, CI/CD and safe SDK upgrades, while the community ios-simulator-skill wraps xcodebuild so Claude can build, run and interact with iOS apps in the simulator without burning context on boilerplate. The pattern across all these specialist categories is identical to the document skills: the most valuable entries come from the organization that owns the domain, because they encode real expertise rather than approximating it. Specialist skills are where "provenance beats popularity" stops being a slogan and starts being a safety rule.

9. The extensibility layer: skills that manage skills

The most strategically interesting category is the one most lists ignore: the meta-layer of skills whose job is to find, build and distribute other skills. This is where the ecosystem stops being a pile of repos and starts being a system, and its flagship is the single most-installed skill in existence. find-skills, from Vercel Labs, is a meta-skill that discovers relevant skills for a task and installs them through the skills CLI, and at a reported 2.1 million installs it is effectively the package manager of the entire ecosystem. Its dominance makes sense once you see the problem it solves: with thousands of skills scattered across thousands of repos, discovery is the binding constraint, and whoever owns discovery owns the funnel.

The build side of the meta-layer is just as important. Anthropic's skill-creator scaffolds a new skill interactively, and the community Skill_Seekers tool industrializes the process by converting eighteen different source types (documentation sites, GitHub repos, PDFs, videos, OpenAPI specs, Notion and Confluence exports) into structured skills automatically. The significance is that these tools collapse the cost of turning existing institutional knowledge into a skill from days to minutes, which is the mechanism by which the ecosystem grows. A company with a 200-page internal wiki can become a company with fifty tuned skills in an afternoon, and that is a different kind of leverage than installing someone else's repo.

Distribution and discovery are handled by marketplaces and directories, and this is where the open-standard decision pays off. Anthropic's claude-plugins-official marketplace is the trusted channel, the superpowers-marketplace distributes the obra framework, and curated directories like Composio's awesome-claude-skills and VoltAgent's thousand-plus-entry index are how most practitioners actually find anything. Sitting underneath all of them is agentskills.io, the open specification that turns SKILL.md from an Anthropic feature into a portable standard, which is the single most consequential fact about the ecosystem's future and the subject of section 14.

The reason the extensibility layer outranks most individual skills is leverage. A great document skill makes one task better, but find-skills makes every future skill discoverable, skill-creator makes every future skill buildable, and the open standard makes every skill portable across agents. These are the skills that compound, and a sophisticated user invests in the meta-layer early precisely because it pays off on every task that follows. If you are thinking about how this discovery-and-orchestration pattern scales into actual automated work, our guide to vibe-automating AI agents shows the same idea applied end to end.

10. How to build and install a skill in five minutes

The gap between reading about skills and using them is smaller than most people expect, and closing it is the fastest way to understand why the format matters. There are three things you might want to do: install an existing skill, build a new one, or share one with a team, and each takes minutes rather than hours. The reason it is so quick is that a Claude Code skill is just a folder, so "installing" is really "putting a folder in the right place" and "building" is really "writing one Markdown file." Nothing here requires an upload, an account, or an approval step.

Installing comes in two flavors depending on the source. Skills distributed as plugins go through the marketplace command, while skills published as repos can be pulled directly with the Vercel skills CLI that find-skills is built around. Both drop a folder into your skills directory where Claude discovers it automatically on the next relevant task.

# Install a skill pack from the official plugin marketplace
/plugin install superpowers@claude-plugins-official

# Or add a community skill straight from its repo
npx skills add vercel-labs/agent-browser

# Personal skills live here; project skills live in .claude/skills/
ls ~/.claude/skills/

Building a skill from scratch is where the simplicity becomes obvious. You can let skill-creator scaffold it interactively, or you can write the folder by hand, and the minimum viable skill is a single SKILL.md with two frontmatter fields and some instructions. The description is the line that does the real work, because it is what Claude reads to decide when to load the skill, so it should name the trigger conditions explicitly rather than describing the skill in the abstract.

---
name: changelog-writer
description: >
  Use when the user asks to write release notes or a changelog from git
  history. Produces grouped, human-readable entries with a version header.
---

# Changelog writer

1. Read the commit range the user specifies (default: since the last tag).
2. Group commits into Added, Changed, Fixed, Removed.
3. Write entries in plain language, not raw commit subjects.
4. Prepend a version header and date.

That is a complete, working skill. Drop the folder in ~/.claude/skills/changelog-writer/, and the next time you ask Claude to "write release notes," it loads these instructions and follows them. To make it more powerful, you add a Level 3 resource (a REFERENCE.md with your exact formatting rules, or a script.py that parses git history deterministically) and reference it from the body, at which point the model stops improvising and starts executing your code. The progression from prose to bundled code is the entire craft of skill-building compressed into one idea, and it is why a non-engineer can write a useful skill on day one while an engineer can write a bulletproof one on day two. The same pattern underpins how whole companies get built from a single description, which our Claude Code website builder guide demonstrates on a larger canvas.

11. The marketplace ecosystem and who controls it

Step back from individual skills and a power structure comes into focus, because the ecosystem is not flat. A small number of publishers produce most of the skills worth having, a small number of distribution channels control how anything gets found, and the open standard underneath determines who can play at all. Understanding this map is what separates a user who installs whatever trends on a directory from one who builds a deliberate, trustworthy stack. The reported install data makes the concentration vivid: a single Vercel meta-skill dwarfs everything else, and the next tier is again dominated by Anthropic and Vercel.

The publishers cluster into recognizable camps, and provenance is the through-line. Anthropic ships the official skills and the trusted marketplace, Vercel Labs owns the meta-layer and the frontend standards, obra (Jesse Vincent) owns the engineering-methodology niche with Superpowers, and Trail of Bits owns professional security. Around them orbit individual experts like Matt Pocock and a long tail of community authors. The structural insight is that the valuable skills come from organizations and individuals who already had a reputation to protect, because a skill is only as trustworthy as the entity that can be held accountable for it.

Distribution is the choke point, and it is split between trusted marketplaces and open directories. The marketplaces (Anthropic's official one and obra's Superpowers marketplace) offer a curation signal, while the directories (Composio's awesome-claude-skills, VoltAgent's thousand-plus index, travisvn's list, and the skills.sh install board) offer breadth at the cost of vetting. This is the same tension the broader tool ecosystem faces, and it rhymes with what we documented in our parallel rankings of the top 100 skills and tools for OpenClaw, where the same "curated versus open" trade-off plays out. The practical rule is to prefer the marketplace when one exists, treat the directories as a discovery surface rather than an endorsement, and never confuse a high position on an install board with a safety guarantee.

12. Pricing and the token economics of skills

Skills are free, but running them is not, and the economics are worth understanding because they shape which skills are worth installing at scale. The skills themselves carry no license fee in almost every case, since the official ones are Apache-licensed and the major community packs are MIT or similar. What you pay for is the model that runs them, which means the real cost question is about tokens, and this is exactly where progressive disclosure stops being a technical curiosity and becomes a line item. Because an installed-but-unused skill costs only about a hundred tokens of metadata, you can carry a large library cheaply, and because a triggered skill's bundled code runs without entering context, the heavy lifting is nearly free in token terms.

The model pricing underneath determines the absolute numbers, and as of June 2026 the current Claude lineup is clear. Claude Opus 4.8 is the top model for agentic coding and the default in Claude Code, priced at $5 per million input tokens and $25 per million output, with a 1M-token context window. Claude Fable 5, the newest flagship, went generally available on June 9, 2026 at $10 and $50 per million, while Claude Sonnet 4.6 sits at $3 and $15 and Claude Haiku 4.5 is the fastest and cheapest at $1 and $5 - Anthropic model docs. The pattern that matters for skills is that a code-backed skill lets you do expensive work on a cheaper model, because the determinism lives in the script rather than the model's reasoning.

The economic upshot is that skills change the cost curve of agentic work in your favor, which is the opposite of the usual "more capability, more cost" story. A well-built skill front-loads expertise into instructions and scripts so the model spends fewer tokens reasoning and fewer tokens failing, and the token savings from progressive disclosure mean a deep skill library is not a tax. For the full breakdown of what running Claude Code actually costs across plans, our Claude Code pricing guide goes line by line, and our Claude Opus 4.8 benchmark and cost guide covers the model that runs most of these skills by default. The single most cost-relevant decision you will make is matching the model tier to the task, and skills make that easier by absorbing complexity that would otherwise force you onto the expensive tier.

13. Where skills fail, and the security problem nobody advertises

Every honest ranking owes you the failure modes, and skills have real ones that the marketing glosses over. The first is mundane: mis-triggering. Because a skill activates based on its description matching the task, a poorly written description either fires when it should not (polluting context with irrelevant instructions) or never fires at all (so the skill you installed does nothing). At small scale this is an annoyance, but in a library of fifty skills with overlapping descriptions, mis-triggering becomes a genuine drag on reliability, and the cure is disciplined, narrow descriptions rather than more skills. The second failure mode is skill bloat, where a sprawling SKILL.md or an over-eager framework loads thousands of tokens of instructions for a task that needed none.

The serious problem, though, is security, and it is structural rather than incidental. A skill is not a passive document, it is executable instructions plus scripts that Claude runs with the tools you grant through the allowed-tools field, and that field can include Bash and Write. That makes a malicious or compromised skill a real attack vector, and three distinct threats follow from it. A skill's text can carry prompt injection (hidden instructions that hijack the model's behavior), its allowed-tools can be over-permissioned (granting shell access a document-formatting skill never needed), and a previously safe community skill can be compromised in a later update (the classic supply-chain attack). None of these are hypothetical given that the most-installed skills come from open directories with no mandatory vetting.

The mitigation is not paranoia, it is a short, non-negotiable checklist applied before any community skill enters your environment. Read the SKILL.md and any bundled scripts yourself, check what allowed-tools it requests and reject anything broader than the job requires, prefer skills from accountable publishers with maintained repos, and pin versions rather than auto-updating from untrusted sources. The reason official skills and named-org skills (Anthropic, Vercel, Trail of Bits, Expo) score so high on reliability is partly that this vetting is effectively done for you, which is the strongest practical argument for the "provenance beats popularity" rule that runs through this guide.

There is a final, softer failure mode worth naming: the inflated-number problem is itself a risk, because it pushes users to install based on star counts that are scraped, unaudited, and sometimes off by a factor of two. A repo quoted at 89,000 stars in one place and 40,900 in another within the same week is not a repo whose popularity you should trust as a safety signal. Treat popularity as a weak prior and provenance plus your own reading of the code as the real test. Skills are a genuine leap in capability, but they move part of the trust boundary onto you, and the users who get burned are the ones who forgot that an install is a grant of capability, not a download of a file.

14. The future: skills as the portable capability layer

The most important thing about skills is not any individual skill, it is that the format escaped Anthropic. On December 18, 2025, Anthropic released Agent Skills as an open standard, and within weeks the SKILL.md format was adopted or supported across a reported 30-plus platforms including OpenAI's Codex, Google's Gemini CLI, Microsoft, Cursor and JetBrains, with launch-partner skills from Atlassian, Figma, Canva, Stripe, Notion and Zapier - SD Times. That single decision changed what a skill is, from a Claude feature into a portable capability that travels with you across agents, which is why the open standard underneath the directories matters more than any leaderboard position.

Reasoning from first principles, this is the predictable endgame of cheap intelligence. When the model itself becomes a commodity, the durable value moves to the encoded expertise that makes a generalist model behave like a specialist, and that expertise is exactly what a skill is. A SKILL.md that captures your company's deployment process or your design system is an asset that retains its value as models improve and even as you switch models, because it is portable and model-agnostic. The competitive frontier therefore shifts from "which model" to "whose skills," and the platforms racing to host agents (Anthropic's own Claude offerings, Google's Antigravity, OpenAI's Codex) are really racing to be where your skills live.

The second structural force is convergence with MCP. Skills encode knowledge and procedures, MCP connects to live systems, and the natural synthesis is an agent that reaches for a skill to know how to do something and an MCP server to actually touch the system it operates on. Anthropic's mcp-builder skill, a skill whose job is to build MCP servers, is the literal embodiment of that convergence, and it points at a future where the two standards are routinely composed rather than chosen between. This is the same trajectory we trace in our look at the autonomous agent workforce and in our coverage of Claude Cowork, where skills and connectors fuse into something that runs continuously rather than turn by turn.

This guide was assembled by the team at o-mega, the autonomous-company platform founded by Yuma Heymans ( @yumahey), who also co-founded the AI recruiter HeroHunt.ai that sources candidates from roughly a billion profiles. His running argument, that the future belongs to systems which encode expertise into reusable, composable capabilities rather than one-off prompts, is exactly the pattern that Agent Skills made concrete, and o-mega itself wraps skills, browsing and deployment into a workforce that builds and operates a business from a single conversation. The enterprise layer of this future is already arriving in the form of org-wide skill management and admin controls, and the companies that win will be the ones that treat their skill library as institutional memory rather than a folder of scripts.

15. Conclusion: building your skill stack

The honest summary of the Top 100 is that you do not need most of it, and chasing the list is the wrong instinct. The single highest-leverage move is to recognize that the best skills, the document quartet and the built-in engineering loop, are already on by default, so for many users the correct skill stack on day one is the one they already have plus a deliberate refusal to install anything they have not read. The ranking exists to help you find the few additions that match your actual work, not to give you a hundred things to install. Start with what ships, add what fits, vet what you add.

From there, the decision framework is short and category-driven. If you write software, layer superpowers on top of the built-in review and verification skills and you have a disciplined loop most senior engineers would respect. If you build frontends, the Vercel design and React skills are the highest-provenance additions available. If you touch security, Trail of Bits is the only name that matters, and if you work in a specialist domain like mobile or science, the skill from the organization that owns the domain beats every general alternative. And before any of it, install find-skills so that future discovery is one command rather than an afternoon of browsing.

The deeper point is that skills moved part of the value of AI work out of the model and into your own library, which is good news and a responsibility at once. Good news because a skill you write is portable, durable, and increasingly model-agnostic, so the expertise you encode this year keeps paying off as the models underneath it improve. A responsibility because installing a skill is granting a capability, and the same openness that gives you two million installs of a great meta-skill gives a bad actor a distribution channel. The users who thrive treat their skill stack the way a careful team treats its dependencies: small, deliberate, sourced from accountable publishers, and read before it is trusted. For the broader context of where AI-built software is heading, platforms like o-mega are one example of skills composed into autonomous operation, and the field is moving fast enough that the only safe assumption is that this list will look different in six months.

This guide reflects the Claude Code skills ecosystem as of June 2026. Skills, star and install counts, model names and pricing change frequently, and many community figures are reported rather than audited, so verify current details against primary sources before you install or rely on anything here.