The 100 Best Claude Code Skills in 2026

A skill is a folder with a SKILL.md file in it. The frontmatter carries a name and a description; the body carries instructions. Claude Code loads the name and description at startup, and pulls the body into context only when the task matches or when you type /skill-name. That two-stage load is the whole design: you can keep fifty procedures on hand and pay for one.

The Claude Code skills documentation puts the threshold plainly: create a skill when you keep pasting the same instructions into chat, or when a section of CLAUDE.md has stopped being a fact and started being a procedure. Content in CLAUDE.md is always loaded. A skill body is loaded on demand.

This list has 100 numbered entries. Every one is verified against either Anthropic's own documentation or a public repository, and every one carries a direct source URL. I have not invented download counts, star counts, or rankings. Where a number appears, it came off the page I cite.

How to read this list

Three labels appear throughout, and they mean different things for trust and for installation.

Official (bundled) ships inside the Claude Code binary. Nothing to install. Anthropic maintains it, and it appears in the commands reference marked Skill in the Purpose column.

Official (Anthropic repo or marketplace) lives in anthropics/skills or anthropics/claude-plugins-official. Anthropic wrote it, but you install it yourself. Note the disclaimer in the skills repo: these are provided for demonstration and educational purposes, and the behavior you get from Claude may differ from what the skill shows.

Community is written by someone outside Anthropic. It may be excellent. It is also a set of instructions you are handing to an agent with file and shell access, so read the section on security review before you install any of it.

A fourth distinction matters: Agent Skills compatible. The SKILL.md format is an open standard documented at agentskills.io, originally developed by Anthropic and now read by a long list of clients. A skill written to the spec runs in Claude Code and also in Codex, Cursor, Gemini CLI, OpenCode, Copilot, and others. Claude Code accepts spec fields plus its own extensions (context: fork, allowed-tools, argument-hint, dynamic shell injection). Skills using those extensions still run in Claude Code, but uploading them to claude.ai or the Skills API fails with an unexpected-key error, because those paths accept only the six spec fields: name, description, license, compatibility, metadata, allowed-tools.

If you are wiring Claude Code up for the first time, start with connecting Claude Code. If you want the format itself rather than this particular client, see the 100 best AI agent skills. Skills and MCP servers solve different problems and compose well; the 100 best MCP servers covers the tool-connection half.

---

Part 1: Bundled skills (nothing to install)

These ship with Claude Code. They are prompt-based: detailed instructions handed to Claude, which then orchestrates using its own tools. Most built-in commands instead execute fixed logic. You can disable the whole set with disableBundledSkills, which turns off everything except /doctor.

Source for this section: docs.claude.com/en/docs/claude-code/commands

1. /verify — Builds your project's app, runs it, and observes the result to confirm a code change does what it should, instead of settling for a passing test suite or a clean type check. Requires v2.1.145 or later. From v2.1.200, /verify writes what worked to .claude/skills/verify/SKILL.md so later runs follow the same recipe. It only runs when you invoke it; before v2.1.215 Claude could trigger it on its own.
Source: https://docs.claude.com/en/docs/claude-code/skills

2. /run — Launches and drives your app so you can watch a change work. Infers the launch from project type, README, package.json, or Makefile. That inference degrades on anything needing a database, an env file, or a multi-step build.
Source: https://docs.claude.com/en/docs/claude-code/skills

3. /run-skill-generator — Gets your app running from a clean environment, records the install commands, env vars, and launch script, then commits the recipe as a per-project skill at .claude/skills/run-<name>/. Run it once per project, and again when the build changes. After that, /run, /verify, and any other agent in the repo follow the recorded steps rather than rediscovering them.
Source: https://docs.claude.com/en/docs/claude-code/skills

4. /code-review — Reviews the current diff, or a PR number, branch, or path you pass, for correctness bugs and cleanup opportunities. Takes effort levels low through max, plus ultra for a cloud review. --fix applies findings; --comment posts them as inline GitHub PR comments. From v2.1.218 it runs as a background subagent so it does not fill your conversation. /review is an alias.
Source: https://docs.claude.com/en/docs/claude-code/commands

5. /simplify — Four review agents run in parallel over changed code, covering reuse of existing helpers, simplification, efficiency, and whether the change sits at the right level of abstraction. From v2.1.154 it deliberately stops looking for correctness bugs; that is /code-review's job. Accepts a path or PR reference.
Source: https://docs.claude.com/en/docs/claude-code/commands

6. /batch — Researches the codebase, decomposes a large change into 5 to 30 independent units, presents the plan, and on approval spawns one background subagent per unit in its own git worktree. Each subagent implements, tests, and opens a PR. Requires a git repository. Example from the docs: /batch migrate src/ from Solid to React.
Source: https://docs.claude.com/en/docs/claude-code/commands

7. /loop — Runs a prompt repeatedly while the session stays open. /loop 5m check if the deploy finished polls on an interval; omit the interval and Claude self-paces. Omit the prompt and it runs the maintenance check or whatever sits in .claude/loop.md. Alias: /proactive.
Source: https://docs.claude.com/en/docs/claude-code/commands

8. /debug — Turns on debug logging for the current session and reads the session debug log to troubleshoot. Logging is off by default unless you launched with claude --debug, so invoking mid-session starts capture from that point. Pass a description to focus the analysis.
Source: https://docs.claude.com/en/docs/claude-code/commands

9. /doctor — Setup checkup that diagnoses and can fix installation health, duplicate installs, PATH problems, and unparseable settings. It also finds unused skills, MCP servers, and plugins versus their context cost, flags slow hooks, deduplicates local CLAUDE.md against checked-in copies, and migrates always-loaded guidance into on-demand skills. It reports first and asks before changing anything. Alias: /checkup.
Source: https://docs.claude.com/en/docs/claude-code/commands

10. /fewer-permission-prompts — Scans your transcripts for read-only Bash and MCP calls you keep approving, then writes a prioritized allowlist into project .claude/settings.json. The most direct fix for approval fatigue, because it derives the list from what you actually ran.
Source: https://docs.claude.com/en/docs/claude-code/commands

11. /dataviz — Design guidance for charts, graphs, and dashboards. Picks the chart form for the data, assigns color by role, and runs a bundled script that validates the palette for colorblind safety and contrast. Ships a brand-neutral placeholder palette you swap for your own. Requires v2.1.198 or later.
Source: https://docs.claude.com/en/docs/claude-code/commands

12. /claude-api — Loads Claude API and Managed Agents reference material for your project's language, and activates automatically when your code imports anthropic or @anthropic-ai/sdk. Subcommands: migrate upgrades existing API code to a newer model, managed-agents-onboard walks through creating a Managed Agent, and prompt-audit flags instructions written for older models across your prompts, skills, and tool descriptions, proposing fixes as a diff.
Source: https://github.com/anthropics/skills/tree/main/skills/claude-api

13. /design-sync — Converts your repo's React design system and uploads it to Claude Design so generated designs use your real components. A first-time sync verifies every component and can take hours on a large repo. Available on the Anthropic API; unavailable on Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, and Claude Platform on AWS, where the underlying tool cannot reach claude.ai.
Source: https://docs.claude.com/en/docs/claude-code/commands

---

Part 2: Document and content skills (Anthropic repo)

The docx, pdf, pptx, and xlsx skills power Claude's document capabilities in production. Anthropic publishes them as source-available rather than open source, explicitly as reference implementations for complex skills. Everything else in the repo is Apache 2.0.

Install both bundles at once:

/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills
/plugin install example-skills@anthropic-agent-skills

14. docx — Word document creation and editing, including tracked changes and comment handling. Last updated July 2026 alongside pptx and xlsx.
Source: https://github.com/anthropics/skills/tree/main/skills/docx

15. pdf — Form field extraction, text and table extraction, page manipulation. The docs give the canonical invocation: "Use the PDF skill to extract the form fields from path/to/some-file.pdf".
Source: https://github.com/anthropics/skills/tree/main/skills/pdf

16. pptx — Deck generation and editing with layout and template awareness. Worth reading as an example of a skill that carries substantial bundled reference material rather than a single prompt.
Source: https://github.com/anthropics/skills/tree/main/skills/pptx

17. xlsx — Spreadsheet reading, writing, and formula work. Use it any time a spreadsheet is the primary input or output, rather than asking Claude to reason about CSV dumps.
Source: https://github.com/anthropics/skills/tree/main/skills/xlsx

18. doc-coauthoring — Collaborative document drafting with a human in the loop, structured so revisions stay reviewable instead of arriving as a wall of new text.
Source: https://github.com/anthropics/skills/tree/main/skills/doc-coauthoring

19. internal-comms — Internal announcement, update, and memo drafting. An enterprise workflow example rather than a coding skill, and a good template if you are encoding your own company's comms conventions.
Source: https://github.com/anthropics/skills/tree/main/skills/internal-comms

20. brand-guidelines — Applies a brand's typography, color, and voice rules to generated output. The pattern generalizes: swap Anthropic's rules for yours and you have a house-style enforcer that loads only when design work starts.
Source: https://github.com/anthropics/skills/tree/main/skills/brand-guidelines

---

Part 3: Design and front-end skills (Anthropic repo)

21. frontend-design — Anthropic's front-end design guidance, updated June 2026. Also shipped as a plugin in the official marketplace, so you can install it either way.
Source: https://github.com/anthropics/skills/tree/main/skills/frontend-design

22. canvas-design — Layout and composition guidance for canvas-based visual output.
Source: https://github.com/anthropics/skills/tree/main/skills/canvas-design

23. theme-factory — Generates coherent theme systems, which is the difference between a page with colors and a page with a palette.
Source: https://github.com/anthropics/skills/tree/main/skills/theme-factory

24. web-artifacts-builder — Builds self-contained web artifacts. Pairs with the visual-output pattern in the skills docs, where a bundled script generates an HTML file and Claude handles orchestration.
Source: https://github.com/anthropics/skills/tree/main/skills/web-artifacts-builder

25. algorithmic-art — Generative art, included in the repo to show that skills are not limited to enterprise workflows.
Source: https://github.com/anthropics/skills/tree/main/skills/algorithmic-art

26. slack-gif-creator — Produces animated GIFs sized for Slack. A small, complete example of a skill that bundles scripts and runs them rather than reasoning in prose.
Source: https://github.com/anthropics/skills/tree/main/skills/slack-gif-creator

---

Part 4: Skills for building on Claude (Anthropic repo)

27. mcp-builder — Guidance for creating MCP servers with well-designed tools. Use it when a capability belongs behind a protocol rather than inside a prompt. If you are deciding which of the two you need, the MCP server list is the other half of that decision.
Source: https://github.com/anthropics/skills/tree/main/skills/mcp-builder

28. skill-creator — Creates new skills, modifies existing ones, and measures skill performance. The measurement half is the reason to install it: it stores test prompts in evals/evals.json inside the skill directory, spawns a subagent per case so each run starts clean, records pass or fail with evidence to grading.json, and aggregates pass rate, time, and tokens for with-skill versus without-skill into benchmark.json. It also runs blind A/B comparisons between two versions, and generates should-trigger and should-not-trigger prompts to tune your description when the skill fires on the wrong requests.
Source: https://github.com/anthropics/skills/tree/main/skills/skill-creator
Plugin install: /plugin install skill-creator@claude-plugins-official

29. webapp-testing — Drives a web app to test it, rather than asserting against a DOM snapshot. Complements /verify when the thing you need to confirm lives in a browser.
Source: https://github.com/anthropics/skills/tree/main/skills/webapp-testing

---

Part 5: The everyday development loop (official marketplace)

These are Anthropic-maintained plugins in claude-plugins-official. Install with /plugin install {name}@claude-plugins-official. The repo's own warning is worth repeating: Anthropic does not control what MCP servers or files are included in third-party plugins, and cannot verify they work as intended or will not change.

30. feature-dev — End-to-end feature development workflow.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/feature-dev

31. commit-commands — Commit-time workflow: staging discipline, message conventions, and the checks that belong before a commit rather than after a PR.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/commit-commands

32. code-simplifier — The plugin form of simplification review, separate from the bundled /simplify.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/code-simplifier

33. pr-review-toolkit — Pull request review agents. Updated April 2026 to replace transcript-style agent examples with prose trigger descriptions, which is itself a useful lesson about writing descriptions the model can match against.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/pr-review-toolkit

34. code-modernization — Pilot-first uplift migration with brief-driven execution. Built for the case where you are moving a large codebase off an old framework or language version and need the first slice to prove the approach before the rest follows.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/code-modernization

35. project-artifact — Produces project-level artifacts. The README was trimmed to usage essentials in June 2026, so it reads quickly.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/project-artifact

36. session-report — Generates a report of what happened in a session. Useful for handoffs and for the weekly question of where the tokens went.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/session-report

37. claude-md-management — Keeps CLAUDE.md files from growing into procedures. Pairs with /doctor, which from v2.1.206 also trims checked-in CLAUDE.md by cutting content Claude could derive from the codebase (directory layouts, dependency lists, architecture overviews) while keeping pitfalls, rationale, and conventions that differ from tool defaults.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/claude-md-management

38. claude-code-setup — Setup recommender, including MCP coverage for databases and backends. Convex was added to that coverage in May 2026.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/claude-code-setup

39. ralph-loop — A loop-style autonomous workflow with session lifecycle hooks. Read the hook configuration before enabling it; loops that run unattended are exactly the category where you want to know what fires on session start.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/ralph-loop

---

Part 6: Extending Claude Code itself

40. plugin-dev — Plugin development guidance. Its March 2026 commit deprecated commands/ in favor of skills/<name>/SKILL.md, which is the clearest signal in the repo about where the format is going. Custom commands have merged into skills: a file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create /deploy, and existing command files keep working.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/plugin-dev

41. agent-sdk-dev — Building on the Agent SDK. Relevant if you are embedding Claude Code's behavior in your own product rather than driving it from a terminal.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/agent-sdk-dev

42. mcp-server-dev — MCP server development covering hosting, payload caps, lifecycle, and directory guidance. More operational than mcp-builder; use both.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/mcp-server-dev

43. mcp-tunnels — Tunneling for MCP servers. Renamed from mcp-gateway to mcp-proxy terminology in May 2026, so older write-ups referencing the gateway name are describing this.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/mcp-tunnels

44. hookify — Turns behavior you want enforced into hooks. This matters because of a specific failure mode the docs call out: when a skill seems to stop influencing behavior after the first response, the content is usually still in context and the model is choosing other approaches. Hooks enforce deterministically where a skill only persuades.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/hookify

45. receipts — Produces a record of what an agent did. The README shows a sample receipt, added July 2026.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/receipts

---

Part 7: Security and language servers

46. claude-security — Anthropic's security plugin for Claude Code, at version 0.10.0 as of July 2026.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/claude-security

47. security-guidance — Security guidance with hooks. A June 2026 commit handles signal-killed venv builds and adds a cooldown, which tells you it is being run against real repositories rather than demos.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/security-guidance

Separately, /security-review is built into Claude Code and reachable through the Skill tool. It analyzes the diff between your branch and origin's default branch for injection, auth, and data exposure risks. It needs an origin remote.

48. typescript-lsp — Language server integration for TypeScript, giving Claude real symbol resolution instead of grep.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/typescript-lsp

49. pyright-lsp — Pyright integration for Python.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/pyright-lsp

50. rust-analyzer-lsp — rust-analyzer integration.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/rust-analyzer-lsp

51. gopls-lsp — gopls integration for Go. Eight more LSP plugins ship in the same directory: clangd-lsp, csharp-lsp, jdtls-lsp, kotlin-lsp, lua-lsp, php-lsp, ruby-lsp, and swift-lsp.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/gopls-lsp

52. cwc-makers — Includes a curl and tar fallback for environments where git is missing, which is a small detail that saves a container build.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/cwc-makers

53. math-olympiad — Competition mathematics. Included here because it is a clean demonstration that a skill can encode a reasoning discipline rather than a tool invocation.
Source: https://github.com/anthropics/claude-plugins-official/tree/main/plugins/math-olympiad

---

Part 8: Superpowers (community methodology)

obra/superpowers by Jesse Vincent and Prime Radiant is a full development methodology built from composable skills that trigger automatically. MIT licensed. It is available through Anthropic's official marketplace:

/plugin install superpowers@claude-plugins-official

Or through its own marketplace:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

One thing to know before installing: the optional visual companion in brainstorming loads a logo from Prime Radiant's website by default, which reports the Superpowers version in use. The README states it sends no project, prompt, or agent details. Disable it with SUPERPOWERS_DISABLE_TELEMETRY, and note that it also honors DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC.

54. using-superpowers — Bootstrap skill that introduces the system and routes work to the right skill. Injected at session start and again after compaction.
Source: https://github.com/obra/superpowers/tree/main/skills/using-superpowers

55. brainstorming — Socratic design refinement. Fires before code gets written, asks what you are actually trying to do, and presents the resulting design in sections short enough to read.
Source: https://github.com/obra/superpowers/tree/main/skills/brainstorming

56. writing-plans — Breaks approved work into tasks of two to five minutes each, with exact file paths, complete code, and verification steps. The stated target audience for a plan is an enthusiastic junior engineer with no project context and an aversion to testing, which is a useful specification for how much can be left implicit.
Source: https://github.com/obra/superpowers/tree/main/skills/writing-plans

57. executing-plans — Batch execution with human checkpoints.
Source: https://github.com/obra/superpowers/tree/main/skills/executing-plans

58. subagent-driven-development — Dispatches a fresh subagent per task with two-stage review: spec compliance first, then code quality. Restructured in July 2026 with a resume-based fix loop.
Source: https://github.com/obra/superpowers/tree/main/skills/subagent-driven-development

59. dispatching-parallel-agents — Concurrent subagent workflows, for work that decomposes cleanly.
Source: https://github.com/obra/superpowers/tree/main/skills/dispatching-parallel-agents

60. test-driven-development — Enforces red-green-refactor: write the failing test, watch it fail, write minimal code, watch it pass, commit. It deletes code written before its test, which is the part that makes it stick.
Source: https://github.com/obra/superpowers/tree/main/skills/test-driven-development

61. systematic-debugging — Four-phase root cause process, with root-cause-tracing, defense-in-depth, and condition-based-waiting techniques bundled as references.
Source: https://github.com/obra/superpowers/tree/main/skills/systematic-debugging

62. verification-before-completion — Confirms a fix is actually a fix before the agent claims it is.
Source: https://github.com/obra/superpowers/tree/main/skills/verification-before-completion

63. requesting-code-review — Pre-review checklist, run between tasks. Critical issues block progress.
Source: https://github.com/obra/superpowers/tree/main/skills/requesting-code-review

64. receiving-code-review — Responding to review feedback with technical rigor rather than agreement. Written for the case where the feedback is unclear or wrong.
Source: https://github.com/obra/superpowers/tree/main/skills/receiving-code-review

65. using-git-worktrees — Creates an isolated workspace on a new branch, runs project setup, and verifies a clean test baseline before work starts.
Source: https://github.com/obra/superpowers/tree/main/skills/using-git-worktrees

66. finishing-a-development-branch — Verifies tests, presents merge/PR/keep/discard options, cleans up the worktree.
Source: https://github.com/obra/superpowers/tree/main/skills/finishing-a-development-branch

67. writing-skills — How to author skills in this style, including the testing methodology. Superpowers uses a drill eval harness from superpowers-evals for skill-behavior tests, cloned into evals/.
Source: https://github.com/obra/superpowers/tree/main/skills/writing-skills

---

Part 9: The lifecycle pack (Addy Osmani, community)

addyosmani/agent-skills is 24 skills mapped to the software development lifecycle, MIT licensed, maintained by Addy Osmani with Federico Bartoli and Joan León. The engineering principles are drawn from Google's published practices: Hyrum's Law in API design, the Beyoncé Rule and test pyramid in testing, change sizing in review, Chesterton's Fence in simplification.

/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills

If the marketplace add fails with git@github.com: Permission denied (publickey), the documented workaround is git config --global url."https://github.com/".insteadOf git@github.com:. Or install cross-agent with npx skills add addyosmani/agent-skills, with the caveat that a per-skill install copies only skills/<name>/ and not the repo-level references/ directory.

Every skill in this pack carries an anti-rationalization table: the excuses an agent uses to skip a step ("I'll add tests later") paired with documented counter-arguments.

68. using-agent-skills — Meta-skill that maps incoming work to the right workflow and defines shared operating rules.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/using-agent-skills/SKILL.md

69. interview-me — One question at a time until roughly 95% confidence, extracting what you actually want rather than what you think you should want.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/interview-me/SKILL.md

70. idea-refine — Divergent then convergent thinking, turning a vague concept into a concrete proposal.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/idea-refine/SKILL.md

71. spec-driven-development — Writes a PRD covering objectives, commands, structure, code style, testing, and boundaries before any code exists.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/spec-driven-development/SKILL.md

72. planning-and-task-breakdown — Decomposes specs into small verifiable tasks with acceptance criteria and dependency ordering.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/planning-and-task-breakdown/SKILL.md

73. incremental-implementation — Thin vertical slices: implement, test, verify, commit. Feature flags, safe defaults, rollback-friendly changes. Triggers on any change touching more than one file.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/incremental-implementation/SKILL.md

74. context-engineering — Feeding agents the right information at the right time: rules files, context packing, MCP integrations. Activates when output quality drops.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/context-engineering/SKILL.md

75. source-driven-development — Grounds every framework decision in official documentation, cites sources, and flags what is unverified. The antidote to a confidently hallucinated API.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/source-driven-development/SKILL.md

76. doubt-driven-development — Adversarial fresh-context review of every non-trivial in-flight decision, structured as CLAIM, EXTRACT, DOUBT, RECONCILE, STOP, with optional user-authorized cross-model escalation. Built for production, security, and irreversible changes.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/doubt-driven-development/SKILL.md

77. api-and-interface-design — Contract-first design, Hyrum's Law, the One-Version Rule, error semantics, boundary validation.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/api-and-interface-design/SKILL.md

78. frontend-ui-engineering — Component architecture, design systems, state management, responsive design, WCAG 2.1 AA accessibility.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/frontend-ui-engineering/SKILL.md

79. browser-testing-with-devtools — Chrome DevTools MCP for live runtime data: DOM inspection, console logs, network traces, performance profiling. This is the skill-plus-MCP combination in its clearest form, where the MCP server supplies the data and the skill supplies the procedure.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/browser-testing-with-devtools/SKILL.md

80. security-and-hardening — OWASP Top 10 prevention, auth patterns, secrets management, dependency auditing, a three-tier boundary system.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/security-and-hardening/SKILL.md

81. observability-and-instrumentation — Structured logging, RED metrics, OpenTelemetry tracing, symptom-based alerting, instrumented as you build rather than after the incident.
Source: https://github.com/addyosmani/agent-skills/blob/main/skills/observability-and-instrumentation/SKILL.md

The pack also contains test-driven-development, debugging-and-error-recovery, code-review-and-quality, code-simplification, performance-optimization, git-workflow-and-versioning, ci-cd-and-automation, deprecation-and-migration, documentation-and-adrs, and shipping-and-launch, plus four specialist personas in agents/ and seven reference checklists in references/.

---

Part 10: Skills for real engineers (Matt Pocock, community)

mattpocock/skills, MIT licensed, deliberately small and composable rather than process-owning. Two install paths with different philosophies: the Claude Code plugin gives you a managed read-only bundle that updates when he ships, and npx skills@latest add mattpocock/skills copies editable files into your repo. Installing both leaves every skill duplicated.

claude plugins install mattpocock-skills

Run /setup-matt-pocock-skills once per repo. It asks which issue tracker you use (GitHub, Linear, or local files), what labels you apply during triage, and where docs should be written.

The skills split on invocation: user-invoked skills orchestrate and are reachable only when you type them; model-invoked skills hold reusable discipline and can be reached automatically. A user-invoked skill may call model-invoked ones, never another user-invoked one.

82. grill-me — Relentless interview about a plan or design until every branch of the design tree resolves. User-invoked.
Source: https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md

83. grill-with-docs — The same interview, plus it builds the project's domain model, sharpens terminology, and updates CONTEXT.md and ADRs inline. The shared-vocabulary effect is concrete: "there's a problem when a lesson inside a section of a course is made real" becomes "there's a problem with the materialization cascade", and the agent then names variables and files consistently against that vocabulary.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/grill-with-docs/SKILL.md

84. to-spec — Turns the current conversation into a spec and publishes it to the issue tracker. No interview; it synthesizes what you already discussed.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/to-spec/SKILL.md

85. to-tickets — Breaks a plan or spec into tracer-bullet tickets, each declaring its blocking edges, as local text or native blocking links on a real tracker.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/to-tickets/SKILL.md

86. implement — Builds the work described by a spec or tickets, driving /tdd at pre-agreed seams and closing with /code-review before committing.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/implement/SKILL.md

87. tdd — Red-green-refactor, one vertical slice at a time, with guidance on what separates a good test from a bad one.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/tdd/SKILL.md

88. diagnosing-bugs — Gated phase-by-phase loop for hard bugs and performance regressions: build a feedback loop that goes red on this bug, minimize, hypothesize, instrument, fix, regression-test.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/diagnosing-bugs/SKILL.md

89. codebase-design — Shared discipline and vocabulary for deep modules: a lot of behavior behind a small interface, placed at a clean seam, testable through that interface.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/codebase-design/SKILL.md

90. improve-codebase-architecture — Surveys a codebase for deepening opportunities and presents them as a visual HTML report, then grills you through whichever one you pick. The README is honest about the limit: it is a survey, not a rescue, and it will not untangle an old codebase for you.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/improve-codebase-architecture/SKILL.md

91. resolving-merge-conflicts — Works through an in-progress merge or rebase hunk by hunk, resolving by intent traced to each side's primary source, and finishes the operation. It never runs --abort.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/resolving-merge-conflicts/SKILL.md

92. handoff — Compacts the current conversation into a handoff document another agent can pick up.
Source: https://github.com/mattpocock/skills/blob/main/skills/productivity/handoff/SKILL.md

93. wizard — Generates an interactive bash wizard that walks a human through steps only a human can do: provisioning infrastructure, setting CI secrets, navigating an unfamiliar third-party dashboard, running a one-off cutover.
Source: https://github.com/mattpocock/skills/blob/main/skills/engineering/wizard/SKILL.md

94. writing-for-agents — How to write documents agents read: skills, AGENTS.md, CLAUDE.md, and anything an agent reaches by a pointer. Read this before you write your first skill.
Source: https://github.com/mattpocock/skills/blob/main/skills/productivity/writing-for-agents/SKILL.md

Also in the repo: research, prototype, domain-modeling, code-review, triage, wayfinder, teach, to-questionnaire, wait-what, grilling, and ask-matt, which routes you to whichever user-invoked skill fits your situation.

---

Part 11: Framework, writing, product, and research

95. react-best-practices (Vercel, community) — React and Next.js performance rules from Vercel Engineering: 40-plus rules across eight categories, prioritized by impact. Eliminating waterfalls and bundle size are marked Critical; server-side performance High; re-render and rendering optimization Medium.
Source: https://github.com/vercel-labs/agent-skills#react-best-practices
Install: npx skills add vercel-labs/agent-skills --skill react-best-practices

96. web-design-guidelines (Vercel, community) — Audits UI code against 100-plus rules covering aria-labels and semantic HTML, visible focus states, form autocomplete and validation, prefers-reduced-motion and compositor-friendly transforms, typography including tabular numerals, image dimensions and lazy loading, virtualization and layout thrashing, URL-reflected state and deep-linking, color-scheme and theme-color, touch-action, and Intl formatting for locale.
Source: https://github.com/vercel-labs/agent-skills#web-design-guidelines

97. writing-guidelines (Vercel, community) — 80-plus rules from Vercel's writing handbook: active voice, direct address, banned words including easy, simple, and quick, tone by content type, sentence-case headings, TypeScript-first code samples with 80-column and 25-line limits, no em dashes as punctuation, and a section on disclosing AI use. Useful even outside Vercel's house style, because it is one of the few published rule sets specific enough for an agent to check against.
Source: https://github.com/vercel-labs/agent-skills#writing-guidelines

98. humanizer (community) — Detects 33 patterns of AI-generated prose, derived from Wikipedia's "Signs of AI writing" guide maintained by WikiProject AI Cleanup. The patterns are grouped into content (significance inflation, notability name-dropping, vague attributions), language (copula avoidance, negative parallelisms, rule of three, synonym cycling, false ranges), style (em dash overuse, boldface overuse, inline-header lists, Title Case headings, manufactured punchlines, aphorism formulas), communication (chatbot artifacts, cutoff disclaimers, sycophancy), and filler. Version 2.9.0 added a no-fabrication rule: a rewrite may not add facts, names, dates, or citations absent from the source. Version 2.9.1 removed nonportable frontmatter so it installs cleanly across harnesses.
Source: https://github.com/blader/humanizer/blob/main/SKILL.md
Install: npx skills add blader/humanizer --global, or /plugin marketplace add blader/humanizer then /plugin install humanizer@humanizer, invoked as /humanizer:humanizer.

99. strategy-red-team (phuryn/pm-skills, community) — Adversarially stress-tests a plan: surfaces load-bearing assumptions, names what would make each one fail, and ranks them by cheapest test. Part of the pm-execution plugin, one of nine plugins in a marketplace of 68 PM skills and 42 chained workflows, MIT licensed, curated by Paweł Huryn. The same plugin carries create-prd, pre-mortem, stakeholder-map, prioritization-frameworks, and outcome-roadmap; the pm-ai-shipping plugin carries intended-vs-implemented, which finds the gap between what a system is documented to do and what its code actually does, with cited evidence on both sides.
Source: https://github.com/phuryn/pm-skills/tree/main/pm-execution
Install: claude plugin marketplace add phuryn/pm-skills then claude plugin install pm-execution@pm-skills

100. database-lookup (K-Dense-AI/scientific-agent-skills, community) — One skill covering dozens of scientific databases behind a single lookup interface. It sits in a 161-skill MIT-licensed collection spanning bioinformatics, cheminformatics, proteomics, clinical research, medical imaging, materials science, and scientific communication. Neighboring skills include scanpy for single-cell analysis, pyopenms for mass spectrometry, exa-search for scientific search, rowan for computational chemistry, and optimize-for-gpu. The repo publishes a security report and runs a security-scan workflow, which is more diligence than most community collections offer.
Source: https://github.com/K-Dense-AI/scientific-agent-skills/blob/main/skills/database-lookup
Install: npx skills add K-Dense-AI/scientific-agent-skills, or gh skill install K-Dense-AI/scientific-agent-skills scanpy with a --pin tag or SHA.

---

Install paths: where a skill lives determines who gets it

Four locations, with a defined precedence order.

Location	Path	Applies to
Enterprise	See managed settings	All users in the organization
Personal	~/.claude/skills/<name>/SKILL.md	All your projects
Project	.claude/skills/<name>/SKILL.md	This project only
Plugin	<plugin>/skills/<name>/SKILL.md	Wherever the plugin is enabled

When names collide, enterprise overrides personal, and personal overrides project. A skill at any of those levels overrides a bundled skill of the same name, so a code-review skill in your project's .claude/skills/ replaces the bundled /code-review. Plugin skills use a plugin-name:skill-name namespace and cannot collide.

Project skills load from .claude/skills/ in your starting directory and every parent up to the repository root, so starting Claude in a subdirectory still picks up root skills. Nested .claude/skills/ directories below your starting point do not load at startup; they load the first time Claude reads or edits a file in that subdirectory. If a nested skill's name clashes with another, both stay available and the nested one appears under a directory-qualified name such as /apps/web:deploy. Requires v2.1.203 or later.

--add-dir and /add-dir are the one exception to the rule that additional directories grant file access rather than configuration discovery: .claude/skills/ inside an added directory loads automatically. The permissions.additionalDirectories setting does not do this.

Claude Code watches skill directories and picks up added, edited, or removed skills within the session, no restart needed. Live detection covers SKILL.md text only; changes to a skill folder's hooks/, .mcp.json, agents/, or output-styles/ need /reload-plugins. If you create a top-level skills directory that did not exist when the session started, restart so it can be watched. /reload-skills re-scans on demand, added in v2.1.152.

One gap that surprises people: Cowork and cloud sessions, including routines, do not read ~/.claude/skills/ on your machine. Both load the skills enabled for your claude.ai account, synced at session start. If a skill exists only in your local personal directory, a routine invoking it reports the skill was not found. Fix it by enabling the skill for your claude.ai account, committing it to the repository's .claude/skills/, or shipping it in a plugin declared in the repo's .claude/settings.json. Plugins enabled only in user settings do not transfer. Desktop scheduled tasks run locally and load skills like any other local session.

Installing cross-agent

The skills CLI from Vercel Labs installs SKILL.md folders into more than 70 agents, including Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Copilot, Droid, Goose, and Windsurf.

npx skills add owner/repo                       # interactive
npx skills add owner/repo --list                # browse first
npx skills add owner/repo --skill name -g -a claude-code -y
npx skills find react --owner vercel            # search
npx skills update                               # update installed skills
npx skills remove name --agent '*'              # remove everywhere

Project scope writes to ./.claude/skills/ and is committed with your repo. Global scope (-g) writes to ~/.claude/skills/. The default install method is symlinks from each agent to a single canonical copy; --copy makes independent copies when symlinks are unavailable. Downloads from direct URLs are capped at 10 MiB, extracted content at 25 MiB, and archives at 1000 files, overridable through SKILLS_DOWNLOAD_MAX_BYTES, SKILLS_EXTRACT_MAX_BYTES, and SKILLS_EXTRACT_MAX_FILES when you trust the source.

GitHub's CLI has its own path, per the April 2026 changelog:

gh skill install owner/repo
gh skill install owner/repo skill-name --agent claude-code
gh skill install owner/repo --pin v2.62.0
gh skill update --all

Pinning to a tag or SHA is the underrated flag there. A skill is executable instruction text; pinning it is the same reasoning as pinning a dependency.

---

Security review before you install third-party instructions

A skill is not passive documentation. It can pre-approve tools, run shell commands before Claude ever sees the content, and register hooks that fire on session lifecycle events. Treat installing one the way you treat adding a dependency with a postinstall script.

Read the frontmatter first, specifically allowed-tools. This field grants permission for the listed tools during the turn that invokes the skill, so Claude uses them without prompting you. The grant clears when you send your next message, and invoking the skill again reapplies it. For skills checked into a project's .claude/skills/, allowed-tools takes effect once you accept the workspace trust dialog, the same as permission rules in .claude/settings.json. The documentation states the risk directly: review project skills before trusting a repository, since a skill can grant itself broad tool access.

Look for ! shell injection in the body. The !`<command>` syntax runs a shell command before the skill content reaches Claude, and the output replaces the placeholder. This is preprocessing, not something Claude decides to execute. Fenced ```! blocks do the same for multi-line commands. In a managed environment, "disableSkillShellExecution": true replaces every such command with [shell command execution disabled by policy] for user, project, plugin, and additional-directory skills. Bundled and managed skills are unaffected. That setting is most useful in managed settings, where users cannot override it.

Check context: fork and background. A forked skill runs in a subagent with the skill content as its prompt and no access to your conversation. A backgrounded fork applies its edits outside your session's checkpoints, so /rewind will not undo them. You need git to revert.

Check for bundled scripts and hooks. Look in scripts/ and at the hooks frontmatter field. A skill folder containing .claude-plugin/plugin.json loads as a plugin and can bundle agents, hooks, and MCP servers, which is a much larger surface than a Markdown file.

Scan it. Cisco's AI Defense group publishes an open scanner used by at least one large skill collection:

uv pip install cisco-ai-skill-scanner
skill-scanner scan /path/to/skill --use-behavioral

Source: https://github.com/cisco-ai-defense/skill-scanner

Constrain what Claude can reach for. Three levers, from the permissions documentation. Deny the Skill tool entirely in /permissions to turn off model invocation of all skills. Use permission rules for specific ones: Skill(commit) for an exact match, Skill(review-pr *) for a prefix match with any arguments, and deny rules in the same syntax. Or set disable-model-invocation: true in a skill's frontmatter, which removes it from Claude's context entirely. Note that user-invocable: false controls menu visibility only, not Skill tool access.

Use skillOverrides for skills you did not write. It sets visibility from settings rather than by editing a shared repo's SKILL.md. Four states: "on" (name and description listed), "name-only", "user-invocable-only" (hidden from Claude, visible in the menu), and "off" (hidden from both, and as of v2.1.199 also hidden from Remote Control clients and Agent SDK callers). The /skills menu writes it for you: highlight a skill, press Space to cycle, Enter to save to .claude/settings.local.json. Plugin skills are not affected; manage those through /plugin.

Read Anthropic's own disclaimer as the baseline standard. The plugins directory README states that Anthropic does not control what MCP servers, files, or other software are included in plugins, and cannot verify that they work as intended or that they will not change. If that is true of a curated official marketplace, it is more true of a repository you found through a topic page.

---

Starter packs

Three sets, each small enough to install in one sitting and evaluate honestly.

The minimum viable pack

For someone who has never installed a skill.

1. Nothing. Run /doctor first. It reports unused skills and MCP servers against their context cost, flags slow hooks, and offers to trim CLAUDE.md. Fix what it finds before adding anything.
2. /run-skill-generator once per project, so /run and /verify stop guessing how to launch your app.
3. /fewer-permission-prompts, which derives an allowlist from calls you already approved.
4. document-skills@anthropic-agent-skills if you touch PDFs, spreadsheets, or decks.

Total install cost: one plugin. Everything else already shipped with the binary.

The disciplined-delivery pack

For a team that wants the agent to follow a process rather than the shortest path.

1. superpowers@claude-plugins-official for the full loop: brainstorming, plans, subagent execution with two-stage review, TDD, systematic debugging, worktrees.
2. skill-creator@claude-plugins-official so you can measure whether the above actually helps. The benchmark.json output comparing with-skill versus without-skill pass rate, tokens, and time is the only honest answer to "is this worth the context".
3. pr-review-toolkit@claude-plugins-official and the LSP plugin for your primary language.
4. security-guidance@claude-plugins-official, plus /security-review in your pre-merge routine.

A note on skill stacking: from v2.1.199 you can chain up to six skills at the start of one message. /write-tests /fix-issue 123 loads both and passes 123 as $ARGUMENTS to each. Expansion stops at the first token that is not an inline user-invocable skill, so a forked skill such as /code-review ends the run there and becomes argument text.

The front-end and content pack

1. frontend-design from the Anthropic skills repo.
2. web-design-guidelines and react-best-practices from Vercel Labs.
3. browser-testing-with-devtools from the Addy Osmani pack, paired with the Chrome DevTools MCP server.
4. writing-guidelines from Vercel and humanizer for anything customer-facing.
5. /dataviz for charts, which is already bundled.

---

Writing your own, in about four minutes

The docs' first example is worth typing out because it demonstrates dynamic context injection, which is the feature that separates a skill from a saved prompt.

mkdir -p ~/.claude/skills/summarize-changes

~/.claude/skills/summarize-changes/SKILL.md:

---
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then list any risks
you notice such as missing error handling, hardcoded values, or tests that need
updating. If the diff is empty, say there are no uncommitted changes.

The !`git diff HEAD` line runs before Claude sees anything, and its output replaces the placeholder. Claude receives the actual diff, not an instruction to fetch one. Substitution runs once over the original file, and command output is inserted as plain text without rescanning, so a command cannot emit a placeholder for a later pass.

Directory name becomes the command name, so this is /summarize-changes. The description is what Claude matches against for automatic invocation, and it is the field most often written badly. Put the key use case first: the combined description and when_to_use text is truncated at 1,536 characters in the skill listing.

Three rules that save rework:

Keep the body under 500 lines. Once a skill loads, its content stays in context for the rest of the session, so every line is a recurring cost. Move detailed reference material into separate files and point at them from SKILL.md so Claude knows what each contains and when to load it.

Write standing instructions, not one-time steps. Claude Code does not re-read the skill file on later turns. When a skill is re-invoked with identical rendered content, Claude Code adds a short note that it is already loaded rather than a second copy; when the content differs because arguments or injected output changed, it appends the full content again.

Know how compaction treats it. Auto-compaction re-attaches the most recent invocation of each skill after the summary, keeping the first 5,000 tokens of each, with a combined budget of 25,000 tokens filled from the most recently invoked. If you invoked many skills in one session, older ones can be dropped entirely. Re-invoke the important one after compaction.

---

FAQ

Are skills the same thing as slash commands now?
Effectively yes. Custom commands have merged into skills. A file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create /deploy and work the same way, and existing command files keep working. Skills add a directory for supporting files, frontmatter that controls who can invoke them, and automatic loading when relevant. Anthropic's own plugin-dev plugin deprecated commands/ in favor of skills/<name>/SKILL.md in March 2026.

Skills or MCP servers?
Different layers. An MCP server connects Claude to a system and exposes tools. A skill teaches Claude a procedure, which may include how to use those tools. browser-testing-with-devtools is the clean example: the Chrome DevTools MCP server supplies live runtime data, the skill supplies the method. If your problem is "Claude cannot reach X", you want a server. If it is "Claude reaches X but does the wrong thing with it", you want a skill. The MCP server list covers the first case.

Will a skill I write for Claude Code run in Cursor or Codex?
If you restrict frontmatter to the six spec fields (name, description, license, compatibility, metadata, allowed-tools), yes, across the growing set of clients listed at agentskills.io. If you use Claude Code extensions such as argument-hint, context: fork, paths, or hooks, the skill still runs in Claude Code but fails validation on upload to claude.ai or the Skills API with an unexpected-key error, and the body-level features such as dynamic shell injection do not function in claude.ai chat or through the API. Support also varies per client: allowed-tools is widely supported, context: fork is currently Claude Code only, and hooks work in a handful.

My skill exists but Claude never uses it.
Four checks in order. Confirm it appears when you ask "What skills are available?". Check the description contains words a user would naturally say. Try rephrasing your request to match the description. Invoke it directly with /skill-name. If the frontmatter YAML is malformed, Claude Code loads the body with empty metadata, so /skill-name works but Claude has nothing to match against. Run with --debug to see the parse error.

My skill descriptions look truncated.
Claude Code loads a listing of names and descriptions into context, budgeted at 1% of the model's context window. The listing always contains every name, but when it overflows, descriptions get dropped starting with the skills you invoke least. Run /doctor for an estimate of the listing's context cost and its biggest contributors. Raise the budget with skillListingBudgetFraction (0.02 for 2%) or SLASH_COMMAND_TOOL_CHAR_BUDGET, or free space by setting low-priority entries to "name-only" in skillOverrides.

The skill triggers when I do not want it to.
Make the description more specific, or add disable-model-invocation: true so only you can invoke it. That is the right setting for anything with side effects: /commit, /deploy, /send-slack-message. If Claude tries anyway, Claude Code blocks the call and instructs it not to reproduce the steps another way, so expect a suggestion that you run it yourself.

Does a skill stop working after the first response?
Usually the content is still in context and the model is choosing other tools. Strengthen the description and instructions, or move the requirement into hooks, which enforce deterministically rather than persuading. If the skill is large or you invoked several others after it, re-invoke it after compaction.

How do I know a skill is actually helping?
Baseline comparison. Collect a few realistic prompts, run each in a fresh session with the skill available and again with it disabled, and compare. A fresh session matters, because leftover context from authoring the skill masks gaps in the written instructions. skill-creator automates this loop and writes the numbers to benchmark.json.

Can I run a skill without polluting my conversation?
Set context: fork in the frontmatter. The skill content becomes the prompt for a subagent with no access to your conversation history, and the result arrives when it finishes. Set background: false to wait for it in the invoking turn instead. Pick the agent type with agent:; Explore and Plan skip CLAUDE.md and git status to keep context small. This only makes sense for skills with explicit instructions. A skill containing guidelines and no task hands the subagent a briefing with nothing to do.

Can I stop a skill from calling a specific tool?
disallowed-tools removes tools from Claude's pool while the skill is active, clearing when you send your next message. It is built for autonomous skills that should never call something, such as AskUserQuestion in a background loop. Like deny rules, it cannot remove EndConversation while any other tool remains.

Is there a registry I can browse?
skills.sh indexes published skill repositories, and npx skills find <query> searches it from the terminal. GitHub's agent-skills topic is the other discovery path, and gh skill install handles installation with version pinning.

What about skills that came from another agent?
/import codex and /import gemini bring instruction files, MCP servers, commands, subagents, and skills from OpenAI Codex and Google Gemini CLI into Claude Code. Add --dry-run to preview or --yes to skip the picker. Requires v2.1.213 or later. /init also offers to run it when it detects a supported agent's configuration.

Use these skills in AGNT

AGNT supports reusable skills alongside agents, workflows, goals, tools, memory, and execution traces. That means a good instruction set can become part of a durable system instead of living in one chat. Download AGNT or inspect the repository.

---

What to do next

Run /doctor before you install anything from this list. It will tell you what you are already carrying and what it costs. Then pick one skill that maps to a procedure you have pasted into chat more than twice this month, install it, and run the baseline comparison with skill-creator before you install a second.

The format itself is the durable part. A SKILL.md you write today runs in Claude Code, and in the growing set of clients that read the same spec. For the format-agnostic view, see the 100 best AI agent skills. For getting Claude Code connected in the first place, start here.

Verified against Anthropic documentation and public repositories as of 11 August 2026. Version-gated behavior is noted where the documentation specifies a minimum Claude Code version. Community skills change; check the source URL before installing.