Skip to content
AI Developer Toolkit

The 25 Most-Installed Development-Practice Skills (September 2026)

The most-installed development-practice skills in September 2026 are find-skills, Matt Pocock’s alignment and engineering skills (grill-me, grill-with-docs, tdd, to-spec, code-review), Anthropic’s frontend-design and the Superpowers methodology skills. Install counts rank attention, not quality. Most value comes from three skills chained into one verified loop, not from installing all 25.

You searched skills.sh for “superpowers”, installed the top result, and got skills for AI video generation. A teammate copied npx skills add mattpocock/skills --skill=grill-me from a blog post and installed every skill in the repo. Someone else installed only grill-me, and it does nothing, because the skill is a one-line pointer to another skill. This page is for developers who want the few skills that change how the agent works, and for tech leads who have to make that set repeatable for a whole team.

What you get from this ranking of practice skills

Section titled “What you get from this ranking of practice skills”
  • The 25 most-installed practice skills under stated inclusion rules, with what each one makes the agent do and a dated install count
  • The skills that ship inside Claude Code and Codex already, so you do not install a duplicate
  • A starter trio for a new repository (find-skills, grill-me, tdd) with install commands for Claude Code, Codex and Cursor
  • A five-stage loop built from single skills, with no framework: grill, spec, test-first, verify, review
  • The ranking traps: copycat repos, renamed skills that still rank, and skills that break when installed alone

Which development-practice skills are most installed in September 2026?

Section titled “Which development-practice skills are most installed in September 2026?”

Popularity, as of 2026-09-26: all-time installs on skills.sh, taken from the third-party LinklyAI/best-skills scrape dated 2026-09-26. skills.sh counts are a third-party snapshot; re-read the skill’s skills.sh page before you quote a number. A skills.sh install counts each CLI install of one skill for each agent and project. Plugin installs and GitHub stars are separate metrics, so compare numbers only within one column.

A practice skill here changes how the agent itself works on code, whatever the stack: how it plans, builds, tests, debugs and reviews, or how it spends the session. The table holds the 25 most-installed skills left after the rules below, and every skill above row 25 (221,579) that is missing from it falls under one of them:

  • Outside this page’s scope. Browser automation such as agent-browser (944,783), covered in browser automation. Framework-specific skills such as vercel-react-best-practices (744,240) and Pocock’s migrate-to-shoehorn (380,312), with the frontend ones in best skills for frontend development. Vendor, product, document-format and media-generation skills (Lark, Azure, Prisma, Supabase, the RigorPilot deep-learning suite, video and image generators, pptx 226,882).
  • Folded into a row. Helper skills that only other skills call (setup-matt-pocock-skills 892,911, domain-modeling 700,766, codebase-design 678,419) count with the skill that needs them, and Superpowers’ using-superpowers (253,058), which only tells the agent to load the other Superpowers skills, counts with those. In the single-purpose repositories the row is the most-installed skill and the rest are its variants: the other caveman-* skills such as caveman-commit (378,782), and taste-skill’s style presets such as high-end-visual-design (380,958).
  • Retired names. Rankings still list names whose folder is gone from main: to-prd, to-issues, diagnose, write-a-skill (230,669), zoom-out (230,145), writing-great-skills (324,259) and Pocock’s own caveman (224,563). They are not counted.
  • Beta skills. Pocock’s in-progress/ folder is beta: he keeps it out of the plugin and says its skills can change or disappear. That covers loop-me (339,337), claude-handoff (315,856, a background-agent take on row 7 handoff), setup-ts-deep-modules (270,938) and the writing-beats, writing-shape and writing-fragments trio (384,495, 384,019 and 383,815).
  • Skills for your understanding. teach (712,278) teaches you a concept, ask-matt (614,785) tells you which Pocock skill fits, and wait-what (304,458) re-explains the last message. None of them changes the agent’s own work.
  • Run once per repository. git-guardrails-claude-code (399,307) and setup-pre-commit (390,884) install hooks, and then their job is done.
  • Steps only a human can do. wizard (413,623) is a per-task skill: it writes an interactive bash script that walks a person through provisioning, credentials, CI secrets, a third-party dashboard or a one-off cutover.
  • Output for people outside the coding loop. scaffold-exercises (384,053) builds course exercises and to-questionnaire (362,929) writes a questionnaire for a colleague to fill in. Handoff documents and specs stay in the table because the next agent, or implement, works from them.
  • A second skill-authoring skill. writing-for-agents (318,126) is a style reference for wording skills and AGENTS.md files. Skill authoring already has its row in skill-creator, which also tests whether a skill triggers.
  • Caps. Three narrow Pocock engineering skills (wayfinder 567,931, research 563,441, resolving-merge-conflicts 541,100) sit in the list below the table, so one repository does not fill half of it. The table also stops at five UI design skills, so emil-design-eng (298,480) sits there too.
#Skill (repository)What it makes the agent doAll-time installs
1find-skills (vercel-labs/skills)Searches the skills.sh index and offers the install command3,568,681
2grill-me + grilling (mattpocock/skills)Interviews you one question at a time until the plan is unambiguous1,225,243 (grilling 776,905)
3grill-with-docs (mattpocock/skills)Grills you and writes agreed terms to CONTEXT.md and decisions to ADRs1,046,834
4improve-codebase-architecture (mattpocock/skills)Surveys recently changed code for refactoring opportunities, then grills you994,519
5tdd (mattpocock/skills)Red-green loop, one vertical slice at a time, at seams you agree first966,524
6frontend-design (anthropics/skills)Commits to a visual direction before writing UI code923,303
7handoff (mattpocock/skills)Compacts the session into a handoff document for a fresh session869,575
8triage (mattpocock/skills)Moves issues and pull requests through triage states and writes agent-ready briefs842,438
9prototype (mattpocock/skills)Builds a throwaway prototype to answer one design question840,310
10web-design-guidelines (vercel-labs/agent-skills)Reviews UI code against Vercel’s interface and accessibility rules667,369
11diagnosing-bugs (mattpocock/skills, was diagnose)Builds a tight pass/fail feedback loop before it proposes a fix665,090
12code-review (mattpocock/skills)Reviews a diff on two axes, repo standards and the spec, in parallel subagents617,608
13implement (mattpocock/skills)Implements a spec or tickets with tdd, then runs code-review615,466
14to-spec + to-tickets (mattpocock/skills, were to-prd, to-issues)Turns the grilled conversation into a spec in your tracker, then tickets564,128 / 553,947
15caveman (JuliusBrussee/caveman)Answers in compressed fragments to save output tokens539,286
16design-taste-frontend (Leonxlnx/taste-skill)Applies anti-generic layout, type and spacing constraints to UI520,147
17skill-creator (anthropics/skills)Drafts a skill and evaluates whether it triggers391,071
18brainstorming (obra/superpowers)Design-first gate: questions, approaches, an approved design doc before code376,352
19ui-ux-pro-max (nextlevelbuilder/ui-ux-pro-max-skill)Generates a design system from bundled style data before UI code371,037
20impeccable (pbakaus/impeccable)Shared design vocabulary plus a deterministic design detector293,766
21systematic-debugging (obra/superpowers)Root cause before fix, in four phases271,653
22writing-plans / executing-plans / subagent-driven-development (obra/superpowers)Small planned tasks, then one fresh subagent per task with review between259,438 / 221,666 / 214,541
23requesting-code-review / receiving-code-review (obra/superpowers)Asks for review between tasks; checks feedback before acting on it238,401 / 202,093
24test-driven-development (obra/superpowers)Strict red-green-refactor, test before any implementation code236,900
25verification-before-completion (obra/superpowers)Runs the proving command and reads its output before any “done” claim221,579

Two repositories dominate the list. Matt Pocock’s mattpocock/skills (269.8k GitHub stars on 2026-09-26) holds 11 of the 25 rows, and obra/superpowers (291.7k stars) holds six, one of them grouping three skills. The pages that teach each group in depth are Grill Me and Grill With Docs, the Superpowers workflow, and the frontend set in best skills for frontend development.

Which practice skills sit just below the cut?

Section titled “Which practice skills sit just below the cut?”

These are verified and useful, but either rank below verification-before-completion, are held back by the rules above, or are measured only by GitHub stars (read 2026-09-26):

  • wayfinder, research and resolving-merge-conflicts (mattpocock/skills, 567,931, 563,441 and 541,100 installs): plan work too large for one session as decision tickets on your issue tracker, research a question against primary sources into a Markdown file, and resolve an in-progress merge or rebase conflict from each side’s original intent.
  • git-guardrails-claude-code and setup-pre-commit (mattpocock/skills, in its misc/ folder, 399,307 and 390,884 installs): a Claude Code PreToolUse hook that blocks destructive git commands such as push and reset --hard, and Husky pre-commit hooks with lint-staged, type checking and tests. Run each once per repository.
  • wizard (mattpocock/skills, 413,623 installs): generates an interactive bash script that walks a human through steps only they can do, such as setting CI secrets or running a one-off cutover. You reach for it per task, not once per repository.
  • emil-design-eng (emilkowalski/skills, 298,480 installs): Emil Kowalski’s design-engineering guide to animation decisions, easing, springs and component polish. It reviews UI code as a before/after table.
  • claude-handoff (mattpocock/skills, beta, 315,856 installs): hands the conversation to a fresh background agent through claude --bg with the handoff summary as its prompt, instead of saving a handoff document.
  • using-git-worktrees and finishing-a-development-branch (obra/superpowers, 199,093 and 195,607 installs): an isolated worktree with a green baseline, then a merge, pull request, keep or discard choice at the end.
  • webapp-testing (anthropics/skills, 164,051 installs): Python Playwright checks against a local web app. It needs Python and Playwright on the machine.
  • mcp-builder (anthropics/skills, 118,601 installs): a guide for building MCP servers in Python or TypeScript.
  • doc-coauthoring (anthropics/skills, 86,463 installs) and writing-guidelines (vercel-labs/agent-skills, 75,985 installs): co-writing and reviewing docs and specs.
  • karpathy-guidelines (forrestchang/andrej-karpathy-skills, now redirected to multica-ai, 215.2k stars): surface assumptions, make surgical edits, define verifiable success criteria.
  • humanizer (blader/humanizer, 52k stars): rewrites AI-sounding prose; see anti-slop writing skills.
  • planning-with-files (OthmanAdi/planning-with-files, 27.1k stars): keeps the plan in files on disk so it survives compaction.
  • Trail of Bits skills (trailofbits/skills, 7.3k stars): a 44-plugin security-review marketplace with differential-review, static-analysis and variant-analysis.
  • Agent Skills for Context Engineering (muratcankoylan, about 18k stars): 17 skills for people building agent systems. The skills CLI sees only a wrapper skill unless you pass --full-depth.

What ships inside Claude Code and Codex already?

Section titled “What ships inside Claude Code and Codex already?”

Check the bundled skills before you install a third-party one that does the same job.

Claude Code 2.1.283 bundles these practice skills (the commands reference marks them Skill):

  • /code-review [low|medium|high|xhigh|max|ultra] [--fix] [--comment] [pr#|branch|path] reviews the diff or a pull request for correctness bugs. /review is an alias.
  • /simplify [target] reviews changed code for reuse, simplification, efficiency and abstraction level, then applies fixes. It does not look for bugs.
  • /verify builds and runs your app to confirm a change works. It runs only when you invoke it.
  • /run launches and drives the app; /run-skill-generator records the launch recipe as .claude/skills/run-<name>/.
  • /batch <instruction> splits a large change into 5 to 30 units, each in its own worktree.

/debug is not a debugging method for your app: it turns on session debug logging. For application bugs use diagnosing-bugs or systematic-debugging. To turn bundled skills off, set disableBundledSkills.

How do you read skill install counts without being misled?

Section titled “How do you read skill install counts without being misled?”

A high count is a reason to read a skill, not a reason to install it. Four patterns distort the ranking:

  1. Copycat “superpowers” repos. The 2026-09-26 snapshot lists 101-skills/superpowers, qu-skills/superpowers, magentosh/superpowers and skills-shell/superpowers with 120K to 480K installs each. Their skills are ai-video-generation, twitter-automation and similar, unrelated to the methodology. Only obra/superpowers is the real one, and a skills.sh search for “superpowers” shows the copies first by count.
  2. Renamed skills keep their counts. mattpocock/skills@to-prd (368,270), to-issues (355,198) and diagnose (239,259) still rank in the top 300, but their folders return 404 on main. The current names are to-spec, to-tickets and diagnosing-bugs.
  3. Delegate skills. Pocock’s grill-me contains one instruction: call the grilling skill. grill-with-docs calls grilling and domain-modeling; tdd consults codebase-design. A count for grill-me says nothing about whether you installed grilling next to it.
  4. Forks re-published under other owners. Install from the canonical owner only (mattpocock, obra, anthropics, vercel-labs), and read the SKILL.md before installing, as skill supply-chain security explains.

Install a starter trio in a new repo: find-skills, grill-me and tdd

Section titled “Install a starter trio in a new repo: find-skills, grill-me and tdd”

Three skills cover the gaps most teams feel first. find-skills stops you guessing names. grill-me stops the agent building the wrong thing. tdd makes every change arrive with a test that failed first. In a codebase, Pocock recommends grill-with-docs (install grilling and domain-modeling with it); grill-me is the lighter, code-agnostic variant. Install them at project scope so they are committed with the repository and every teammate gets the same set.

  1. Install the three skills and their dependencies. Run this in the repository root. The skills CLI is npm skills 1.7.0.

    Terminal window
    # Pocock's skills as a plugin from the official marketplace (updates itself)
    claude plugin install mattpocock-skills --scope project
    # find-skills is not in a plugin; install it as a project skill
    npx skills add vercel-labs/skills --skill find-skills -a claude-code -y

    --scope project records the plugin in .claude/settings.json, which you commit; without it the plugin installs for you alone. The official marketplace is added the first time you start an interactive session; in a script, run claude plugin marketplace add anthropics/claude-plugins-official first. The plugin namespaces its skills: you type /mattpocock-skills:grill-me. Pick the plugin or the portable copy for Pocock’s skills, not both, or every skill appears twice.

  2. Confirm what landed. Run npx skills list and check that grilling and codebase-design appear next to the skills you named. In Claude Code, run /context before and after the install to see what the skill listings cost, and claude plugin details mattpocock-skills to see the plugin’s inventory and projected token cost. Each skill adds its name and description to every session; the body loads only when the skill fires. For scale: on 2026-09-26, claude plugin details in Claude Code 2.1.283 projected about 1,609 always-on tokens for the whole mattpocock-skills plugin (1.2.3, 25 skills), so three portable skills cost a small fraction of that.

  3. Commit the skill folders. Commit .agents/skills/, .claude/skills/ (symlinks into .agents/skills/ when you target several agents), skills-lock.json, and .claude/settings.json for plugin installs. A pull request, not a chat message, then changes the team’s skill set.

  4. Try each skill once on real work. Use the prompts below. grill-me is user-invoked only, so it never fires by itself; tdd and find-skills are model-invoked from their descriptions.

What you should see: the agent asks one question, waits, and follows the branch your answer opens, for example proration rounding after you answer the mid-cycle question. With tdd installed, asking “fix the rounding bug in invoice totals test-first” makes the agent state the seam it will test, write one failing test, run it red, then write the minimum code to turn it green.

How do you chain practice skills into a loop without a framework?

Section titled “How do you chain practice skills into a loop without a framework?”

A framework such as Superpowers or a discipline pack gives you a fixed process. You can get most of the benefit from five single skills, chained by you, with a hard gate at each hand-off. The loop is: grill → to-spec → tdd → verification-before-completion → code-review.

Install the extra skills first. to-spec and Pocock’s code-review need setup-matt-pocock-skills, which records your issue tracker (GitHub by default, or local markdown files) and triage labels:

Terminal window
# Codex shown; for Cursor swap -a codex for -a cursor.
npx skills add mattpocock/skills --skill to-spec code-review setup-matt-pocock-skills -a codex -y
npx skills add obra/superpowers --skill verification-before-completion -a codex -y


# Claude Code with the mattpocock-skills plugin: only the Superpowers skill is missing.
npx skills add obra/superpowers --skill verification-before-completion -a claude-code -y

  1. Grill. Run grill-me (or grill-with-docs in a codebase whose vocabulary the agent keeps getting wrong). The exit criterion is a list of decisions you agreed, not a feeling that the plan is clear.

  2. Spec. Run /setup-matt-pocock-skills once per repository, then /to-spec in the same session. to-spec does not interview again. It proposes the test seams, asks you to confirm them, and publishes a spec with user stories to your tracker with the ready-for-agent label. The confirmed seams are what the next stage tests.

  3. Test first. Ask for the implementation test-first. tdd writes one failing test at an agreed seam, makes it pass, and repeats slice by slice. In the current tdd skill, refactoring is left to the review stage.

  4. Verify before “done”. verification-before-completion fires when the agent is about to claim success. Its rule is that no completion claim is allowed without fresh output from the command that proves it. Expect the agent to run the full test suite, the type check and the linter, and to paste the output.

  5. Review. Run Pocock’s code-review against the branch point. It runs two subagents in parallel, one checking the diff against your documented standards and one against the spec from step 2, and reports both. Fix what it finds, then return to step 4.

With the plugin, the stages are /mattpocock-skills:grill-me, /mattpocock-skills:to-spec and /mattpocock-skills:code-review, and Anthropic’s bundled correctness review stays /code-review, so you can run both. With a portable copy, the two share a name, so install Pocock’s skills as the plugin, or rename the portable copy’s folder and its name: field (for example spec-review). Add /verify after step 4 when the change is visible in a running app.

How do you prove the loop produced working code?

Section titled “How do you prove the loop produced working code?”

The skills change the agent’s behaviour; they do not enforce anything. verification-before-completion makes the agent show evidence, but a skill can be skipped, and the agent can misread output. So the proof sits outside the agent:

  • CI is the gate. The same test, type-check and lint commands the agent pasted run again in CI on the pull request. A red CI run overrides any “done” in the chat.
  • The spec is the oracle. Each user story from to-spec maps to a seam, and each seam has a test that failed before it passed. The reviewer checks that mapping, not every line. The evidence bundle page shows how to attach it to the pull request.
  • A second reviewer with different blind spots. Pocock’s code-review checks spec and standards; Claude Code’s bundled /code-review and Codex’s /review check correctness. Run both on risky changes.
  • Skills are evaluated too. Before you standardise a skill for the team, measure whether it triggers: skill-creator runs test cases with and without the skill, and in Claude Code claude plugin eval runs a plugin’s eval suite against a no-plugin baseline.

The developer who opens the pull request owns the evidence. The tech lead owns the committed skill set and approves changes to it through review, like any other code.

Add your team’s conventions as a project skill

Section titled “Add your team’s conventions as a project skill”

Community skills do not know your branch names or who reviews what. Put those in one project skill, next to the skills you installed:

Create .claude/skills/team-conventions/SKILL.md with a name, a description that says when to use it (for example “Use when creating a branch, commit or pull request”), and the rules as the body.

Typical rules: the branch format (type/TEAM-123-description), which team reviews which path, how a merge reaches production, and where to announce a release. Building custom skills covers the frontmatter and evaluation in depth.

What breaks when you stack practice skills?

Section titled “What breaks when you stack practice skills?”

The agent becomes too methodical for a one-line fix. Grilling and spec stages are overhead on a typo. Say so explicitly: “This is a mechanical one-line fix: skip grilling and the spec, but run the targeted test and paste the output.” A terse request does not switch off a model-invoked skill by itself.

Verification stalls on tests that were already red. Record the failing baseline before you start, then separate an accepted red baseline from a new regression. Do not let the agent retry until green or skip a test file without a written team policy.

Sessions get slow and expensive. Every installed skill costs its listing in every session, and a body costs tokens each time it fires. Remove what did not trigger in a week: npx skills remove <name>, then compare /context in Claude Code before and after.

Parallel sessions collide. Two agents running the same workflow in one checkout share files and state. Give each session its own worktree; using-git-worktrees or your agent’s worktree flag handles the setup.

find-skills returns a long, noisy list. Name the practice and the stack: “a skill for Playwright end-to-end tests in a Next.js app” beats “testing skills”. Then read the proposed SKILL.md before you approve the install.

A renamed skill fails to install. to-prd, to-issues and diagnose still show up in old posts and rankings. Run npx skills add mattpocock/skills --list to see the current names.

For vendor skills for monitoring, data pipelines and platforms, which are outside this ranking, see official skills from technology makers.

Where to go next with practice skills

Section titled “Where to go next with practice skills”
Installing and managing skills Scopes, updates and removal with the skills CLI, per agent.
Grill Me and Grill With Docs The alignment stage of the loop, in depth.
Superpowers When you want the whole process as one plugin instead of five skills.
Skill supply-chain security What to read before any third-party skill runs in your repo.

Written by

See what's new on the platform.

Privacy Policy Terms of Service Cookie settings