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

URL: https://developertoolkit.ai/en/ecosystem/skills/top-practice-skills/
Description: The 25 most-installed practice skills for Claude Code, Codex and Cursor, a starter trio for a new repo, and how to chain them into a verified loop.

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

- 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?

**Popularity, as of 2026-09-26:** all-time installs on [skills.sh](https://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](/en/ecosystem/mcp/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](/en/ecosystem/skills/top-skills-frontend/). 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 do                                                        | All-time installs         |
| -- | -------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------- |
| 1  | `find-skills` (vercel-labs/skills)                             | Searches the skills.sh index and offers the install command                       | 3,568,681                 |
| 2  | `grill-me` + `grilling` (mattpocock/skills)                    | Interviews you one question at a time until the plan is unambiguous               | 1,225,243 (`grilling` 776,905) |
| 3  | `grill-with-docs` (mattpocock/skills)                          | Grills you and writes agreed terms to `CONTEXT.md` and decisions to ADRs          | 1,046,834                 |
| 4  | `improve-codebase-architecture` (mattpocock/skills)            | Surveys recently changed code for refactoring opportunities, then grills you      | 994,519                   |
| 5  | `tdd` (mattpocock/skills)                                      | Red-green loop, one vertical slice at a time, at seams you agree first            | 966,524                   |
| 6  | `frontend-design` (anthropics/skills)                          | Commits to a visual direction before writing UI code                              | 923,303                   |
| 7  | `handoff` (mattpocock/skills)                                  | Compacts the session into a handoff document for a fresh session                  | 869,575                   |
| 8  | `triage` (mattpocock/skills)                                   | Moves issues and pull requests through triage states and writes agent-ready briefs | 842,438                  |
| 9  | `prototype` (mattpocock/skills)                                | Builds a throwaway prototype to answer one design question                        | 840,310                   |
| 10 | `web-design-guidelines` (vercel-labs/agent-skills)             | Reviews UI code against Vercel's interface and accessibility rules                | 667,369                   |
| 11 | `diagnosing-bugs` (mattpocock/skills, was `diagnose`)          | Builds a tight pass/fail feedback loop before it proposes a fix                   | 665,090                   |
| 12 | `code-review` (mattpocock/skills)                              | Reviews a diff on two axes, repo standards and the spec, in parallel subagents    | 617,608                   |
| 13 | `implement` (mattpocock/skills)                                | Implements a spec or tickets with `tdd`, then runs `code-review`                  | 615,466                   |
| 14 | `to-spec` + `to-tickets` (mattpocock/skills, were `to-prd`, `to-issues`) | Turns the grilled conversation into a spec in your tracker, then tickets | 564,128 / 553,947         |
| 15 | `caveman` (JuliusBrussee/caveman)                              | Answers in compressed fragments to save output tokens                             | 539,286                   |
| 16 | `design-taste-frontend` (Leonxlnx/taste-skill)                 | Applies anti-generic layout, type and spacing constraints to UI                   | 520,147                   |
| 17 | `skill-creator` (anthropics/skills)                            | Drafts a skill and evaluates whether it triggers                                  | 391,071                   |
| 18 | `brainstorming` (obra/superpowers)                             | Design-first gate: questions, approaches, an approved design doc before code      | 376,352                   |
| 19 | `ui-ux-pro-max` (nextlevelbuilder/ui-ux-pro-max-skill)         | Generates a design system from bundled style data before UI code                  | 371,037                   |
| 20 | `impeccable` (pbakaus/impeccable)                              | Shared design vocabulary plus a deterministic design detector                     | 293,766                   |
| 21 | `systematic-debugging` (obra/superpowers)                      | Root cause before fix, in four phases                                             | 271,653                   |
| 22 | `writing-plans` / `executing-plans` / `subagent-driven-development` (obra/superpowers) | Small planned tasks, then one fresh subagent per task with review between | 259,438 / 221,666 / 214,541 |
| 23 | `requesting-code-review` / `receiving-code-review` (obra/superpowers) | Asks for review between tasks; checks feedback before acting on it       | 238,401 / 202,093         |
| 24 | `test-driven-development` (obra/superpowers)                   | Strict red-green-refactor, test before any implementation code                    | 236,900                   |
| 25 | `verification-before-completion` (obra/superpowers)            | Runs the proving command and reads its output before any "done" claim             | 221,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](/en/ecosystem/skills/grill-me/), the [Superpowers workflow](/en/ecosystem/frameworks/superpowers/), and the frontend set in [best skills for frontend development](/en/ecosystem/skills/top-skills-frontend/).

### 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](/en/ecosystem/skills/unslop/).
- `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?

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

**Claude Code**

Claude Code 2.1.283 bundles these practice skills (the [commands reference](https://code.claude.com/docs/en/commands) 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`.

**Codex**

The codex-cli 0.157.1 binary includes three system skills: `$skill-installer`, `$skill-creator` and `$plugin-creator`; OpenAI removed `$plugin-creator` from the bundled skills in 0.159.0 (2026-09-29), and the bundled skills in 0.162.1 are `imagegen`, `openai-docs`, `review-agent`, `skill-creator` and `skill-installer`. `$skill-installer` installs from the `openai/skills` catalogue, which is now marked deprecated in favour of `openai/plugins` (marketplace `openai-curated`). Codex also has `/review` and `codex review` as built-in commands. Everything else in the table comes from `npx skills add` or a plugin.

**Cursor**

Cursor bundles a `/loop` skill (Cursor 3.5, 2026-05-20), which repeats a task rather than enforcing a practice. Cursor loads skills from `.agents/skills/`, `.cursor/skills/` and their home-directory variants (`~/.agents/skills/`, `~/.cursor/skills/`), and for compatibility also from the `.claude/skills/` and `.codex/skills/` directories (Cursor's skills docs, checked 2026-10-12). Treat every practice skill in the table as something you install, into `.agents/skills/` through the skills CLI, or as a plugin with `/add-plugin` where the skill's own README documents that route.

## 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](/en/ecosystem/skills/skill-security/) explains.

## 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.

    **Claude Code**

    ```bash
    # 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.

    **Codex**

    ```bash
    npx skills add vercel-labs/skills --skill find-skills -a codex -y
    npx skills add mattpocock/skills --skill grill-me grilling tdd codebase-design -a codex -y
    ```

    Both commands write to `.agents/skills/`. Codex invokes a skill with the `$` sigil: `$grill-me`.

    **Cursor**

    ```bash
    npx skills add vercel-labs/skills --skill find-skills -a cursor -y
    npx skills add mattpocock/skills --skill grill-me grilling tdd codebase-design -a cursor -y
    ```

    Both commands write to `.agents/skills/`. Cursor's skills docs (not re-checked on 2026-09-26) describe invoking a skill as `/grill-me` in Agent chat; if it does not appear, ask the agent to use the grill-me skill by name.

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.

**Copy-paste prompt: find a skill before you write one**

```text
Use the find-skills skill. I want a skill that makes you reproduce a bug with a failing
test before you change any code. Search for candidates, show each one's owner, install
count and what its SKILL.md instructs, and recommend one. Prefer repositories owned by
mattpocock, obra, anthropics or vercel-labs. Show me the npx skills add command with
--skill <name> (not --skill=<name>) and do not run it until I approve.
```

**Copy-paste prompt: grill a feature before any code**

```text
/grill-me We need per-seat billing on the team plan: adding a seat mid-cycle is prorated,
removing one takes effect at renewal. Interview me one question at a time until every
branch of this is decided: who owns the seat count, what happens on failed payment, what
the invoice shows. Write no code. At the end, list the decisions we made.
```

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?

A framework such as Superpowers or [a discipline pack](/en/ecosystem/frameworks/discipline-packs/) 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:

```bash
# 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.

**Copy-paste prompt: turn the grilling into a spec**

```text
/to-spec Use the decisions from this conversation. Propose the fewest test seams that
cover them, preferring existing public interfaces, and wait for me to confirm the seams
before you publish. Every user story must map to at least one seam.
```

**Copy-paste prompt: implement against the spec, test-first**

```text
Implement the spec we just published, test-first, one seam at a time. For each slice:
write one failing test, run it and show me the failure, write the minimum code, run it
green. Run the type check after every slice. Before you tell me anything is done, run
the full test suite, the type check and the linter, and paste the exit codes.
```

**Copy-paste prompt: two-axis review before the pull request**

```text
Use the code-review skill against main. Check the diff against our documented coding
standards and against the spec issue we published. Report findings side by side, with
severity. Do not fix anything yet; list what would change and why.
```

**Claude Code**

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.

**Codex**

The stages are `$grill-me`, `$to-spec`, then a plain request for test-first work (`tdd` is model-invoked), then `$code-review`. Add a second, independent pass with Codex's built-in `/review` before you open the pull request.

**Cursor**

The stages are `/grill-me`, `/to-spec`, a test-first request, then `/code-review`. Keep one Agent chat for stages 1 and 2, because `to-spec` synthesises the conversation it runs in.

## 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](/en/workflows/ship/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

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

**Claude Code**

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.

**Codex**

Create `.agents/skills/team-conventions/SKILL.md` with the same frontmatter and body. That is the project directory the skills CLI uses for Codex.

**Cursor**

Create `.agents/skills/team-conventions/SKILL.md` with the same frontmatter and body, so Codex and Cursor share one copy.

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](/en/ecosystem/skills/building-custom-skills/) covers the frontmatter and evaluation in depth.

**Copy-paste prompt: extract conventions into a skill**

```text
Read the last 50 commit messages, the last 20 merged pull request descriptions and the
README files in this repository. Identify the recurring conventions: commit message
format, pull request structure, branch naming, and who reviews which paths. Draft a
SKILL.md named team-conventions whose description says it applies when creating a
branch, commit or pull request. Quote the evidence for each rule. Show me the draft
before you write the file.
```

**Traps when installing practice skills**

- **`--skill=<name>` is silently ignored** by the skills CLI 1.7.0. Without `-y` you get the interactive picker; with `-y` you install every skill in the repository. Write `--skill grill-me` or `mattpocock/skills@grill-me`.
- **`--skill` matches the frontmatter `name`, not the folder.** The folder `react-best-practices` holds the skill `vercel-react-best-practices`.
- **A delegate installed alone does nothing.** Install `grilling` with `grill-me`, and `codebase-design` with `tdd`.
- **`npx skills add obra/superpowers` is not the Superpowers plugin.** The portable copy has no session-start bootstrap, so the methodology does not fire on its own. Use `/plugin install superpowers@claude-plugins-official` for the full workflow.
- **`/code-review` names two different things in Claude Code.** The bundled skill owns the bare name; Anthropic's `code-review` plugin runs as `/code-review:code-review`; Pocock's plugin skill runs as `/mattpocock-skills:code-review`. A portable copy of Pocock's `code-review` shares the bare name with the bundled skill, so use the plugin or rename the copy.
- **Two TDD skills fight.** Pocock's `tdd` confirms seams first and leaves refactoring to review; Superpowers' `test-driven-development` is a strict red-green-refactor loop. Install one.

## 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](/en/ecosystem/skills/top-skills-official/).

## Where to go next with practice skills

- [Installing and managing skills](/en/ecosystem/skills/installing-managing/) — Scopes, updates and removal with the skills CLI, per agent.
- [Grill Me and Grill With Docs](/en/ecosystem/skills/grill-me/) — The alignment stage of the loop, in depth.
- [Superpowers](/en/ecosystem/frameworks/superpowers/) — When you want the whole process as one plugin instead of five skills.
- [Skill supply-chain security](/en/ecosystem/skills/skill-security/) — What to read before any third-party skill runs in your repo.
