Matt Pocock's skills: which ones to install

Matt Pocock's skills: the short answer

Matt Pocock's skills are 27 agent skills in one public GitHub repo. A solo developer running a coding agent on a VPS needs about eight of them. Install grill-me with its helper grilling, then tdd, diagnosing-bugs and handoff. Leave the tracker-driven skills (triage, wayfinder, implement-spec, to-questionnaire) until a second person works in the repo, because they exist to move work between people.

The README lists every skill and gives a one-line description of each. It does not tell you which ones fit your situation, or what each one costs you in context. This guide does that. Everything below was checked against commit d81f3a1 of mattpocock/skills, merged on 29 September 2026. If you are new to the format itself, start with what agent skills are and how an agent loads them.

What the repo is, and what it is not

The repo is one developer's personal toolkit. Matt Pocock is an independent TypeScript teacher. He wrote these skills for his own work with Claude Code and Codex, and he publishes them under the MIT license. They are not made by Anthropic, and they are not a standard. They use the common SKILL.md format, so any agent that reads that format can load them.

Each skill is a folder with a SKILL.md file. The file holds a short YAML header (a name and a description) and then plain instructions for the agent. Some skills are very small. The whole body of grill-me is one line that tells the agent to call another skill.

The repo has version tags, but both install paths follow whatever is current, not a commit you choose. So write down the commit you read. As of 2 October 2026 the newest commit on the default branch is d81f3a183412e71a5b1e84ca21bc1a35eea03a60. You can read every skill file at that exact state at the pinned tree on GitHub. Skills change between releases. A skill named in this guide may be renamed or removed later. The v1.3 release, for example, removed resolving-merge-conflicts.

Two splits that decide what a skill costs you

The README sorts the skills in two ways. You need both to choose well.

Engineering versus productivity. Engineering skills work on code, specs and issues. Productivity skills are general: interviews, handoff notes, teaching. At the pinned commit there are 20 engineering skills and 7 productivity skills.

User-invoked versus model-invoked. This split matters more, because it decides the context cost.

• A user-invoked skill runs only when you type it, for example /grill-me. Its header sets disable-model-invocation: true. In Claude Code that means its description is not shown to the model at all. It costs nothing until you call it.
• A model-invoked skill can be called by you, or by the agent on its own when a task matches the description. To make that possible, its description sits in the skill listing that the model reads on every turn.

The repo has 16 user-invoked skills and 11 model-invoked skills. The model-invoked ones are prototype, diagnosing-bugs, research, tdd, domain-modeling, codebase-design, code-review, pr, wizard, grilling and writing-for-agents. Install all 11 and their descriptions ride along on every request, whether the task is a refactor or a typo fix. Each description is short. The cost is still real on a long session, and how Claude Code fills and compacts its context window explains where that space goes.

There is a second cost. A model-invoked skill can start when you did not ask for it. The research description says it runs "as a background agent". If the agent decides your question needs research, it can start that agent without a slash command from you.

Which skills a solo developer should install

You work alone, on one VPS, probably inside tmux so the session survives a dropped SSH connection. If that is not set up yet, follow running Claude Code on a VPS inside tmux first. For that setup, these skills earn their place:

• grill-me and grilling. The agent interviews you about a plan before it writes code. This is the skill most people come for. You need both, because grill-me only calls grilling.
• tdd. A red-green-refactor loop: the agent writes a failing test, then makes it pass. It gives the agent real feedback instead of guesses.
• diagnosing-bugs. A gated loop for hard bugs: reproduce, minimise, hypothesise, instrument, fix, then add a regression test.
• handoff. It compacts the conversation into a document that a fresh session can read. On a VPS you will start new sessions often, so this is useful.
• wait-what. You type it when a reply does not make sense, and the agent explains it again in plain words.
• codebase-design. Optional. It teaches the agent to design deep modules: a lot of behaviour behind a small interface.
• research. Optional. It writes a cited Markdown file into the repo. Useful if you often ask the agent to read documentation for you.

Notice that prototype is not on the list. Its UI branch builds several page variations that you compare in a browser. On a headless VPS you must copy the files back to your own machine or forward a port to see them. If you do UI work, that cost is worth it. If you only write backend code, skip it.

Which skills only pay off on a team

These skills assume a shared issue tracker and other people reading what the agent writes:

• triage moves issues through labelled states. One person does not need a state machine for their own issues.
• to-tickets and wayfinder break large work into tickets with blocking links on a tracker. They pay off when several people or several agents pick up tickets in parallel.
• implement-spec runs implementer subagents across every ready ticket at once, on one integration branch. That is a lot of parallel token spend for a solo repo.
• to-questionnaire turns a decision into a questionnaire for "the one person who can" answer it. Alone, that person is you.
• pr shapes a pull request body for reviewers. Without reviewers it is ceremony.

A middle group works for both. to-spec, implement and code-review publish to or read from the issue tracker, but the setup step offers local Markdown files as a tracker, so they run fine on a solo repo. grill-with-docs and domain-modeling build a GLOSSARY.md of project terms and write ADRs (architecture decision records). That shared vocabulary pays off most when several people and agents must use the same words, but a long-lived solo project benefits too.

Install path 1: the Claude Code plugin

The README gives two install paths and warns you to pick one: "installing both leaves you with every skill twice." The plugin path installs all 27 skills as a read-only bundle that updates when a new release ships. From your shell:

claude plugins install mattpocock-skills

Or from inside a running session:

/plugin install mattpocock-skills

The plugin is listed in Claude Code's official marketplace, so you do not add a marketplace first. Claude Code should print a Successfully installed plugin: line that names the plugin and its scope, which is user by default. A plugin's skills are namespaced under the plugin name, so in /skills they appear with the mattpocock-skills: prefix. For how plugins differ from loose skill files, read what a Claude Code plugin bundles and how it loads.

The trade-off is control. You get all 27 skills, and all 11 model-invoked descriptions, whether you want them or not. You cannot usefully edit the files, because the next update replaces them.

Install path 2: npx skills for Codex and other agents

The second path uses the skills command-line installer from skills.sh. It copies editable skill files into your project. It needs Node.js on the VPS, because npx comes with npm.

npx skills@latest add mattpocock/skills

The installer asks which skills you want and which agents to install them for. This is where you choose. The README adds one warning in bold: make sure setup-matt-pocock-skills is one of the skills you pick. For Claude Code the files land in .claude/skills/ in the project. For Codex and most other agents they land in .agents/skills/.

To install only some skills without the skill menu, name them with --skill:

npx skills@latest add mattpocock/skills --skill grill-me grilling tdd diagnosing-bugs handoff
npx skills list

npx skills list should show the skills you picked and nothing else. The files are now ordinary files in your repo. Commit them, and that commit is your pin. Nothing changes until you run npx skills update. Committing skills into the repo is also how you share agent skills across several repositories without copying them by hand.

Run /setup-matt-pocock-skills once per repository

The engineering skills need to know where your issues live. Run this once in each repository, inside your agent:

/setup-matt-pocock-skills

It looks at the repo first, then asks you some questions. It asks which issue tracker to use: GitHub, Linear or local files. It asks which labels you use when you triage. It asks where to save the documents the skills create. On a solo VPS, choose local files unless you already use GitHub issues. The skill then writes its settings under docs/agents/ and adds an "Agent skills" section to CLAUDE.md or AGENTS.md. Commit those files. If you skip this step, the engineering skills have no tracker and no doc location, so they must stop and ask, or guess.

The productivity skills, including grill-me, do not need this step.

How to see which skills are loaded into context

Two different things count as "loaded", and Claude Code shows them in different places.

Listed. A model-invoked skill's description is in the listing on every turn. Type /skills to see every skill in the session, grouped by source. Type /context to see how much of the context window skills use. /doctor also estimates the cost of the skill listing and names the biggest contributors.

Invoked. When a skill actually runs, its full body loads into the conversation, and the transcript shows a Skill tool call with that skill's name. If you did not type a slash command but see a skill name there, the model chose it from the description.

Claude Code keeps the listing to about 1% of the model's context window. When you have more skills than fit, it drops the descriptions of the skills you use least. So a large set of skills does not fill the window. The catch is that a rarely used skill can lose its description and stop triggering on its own. If your Claude Code is v2.1.252 or later, /skill-doctor shows each skill's context cost and how often it ran, which tells you what to turn off.

Worked example: grill-me on a small spec

grill-me is the skill people search for, so here is how to use it well. Start a session in the repo and give it a real, small spec:

/grill-me

Spec: add a /healthz endpoint to my Flask app on this VPS.
It returns 200 with JSON {"status": "ok", "disk_free_pct": N}.
It returns 503 if free disk space on / is under 10%.
Uptime Kuma polls it every 60 seconds.

The questions you get depend on your spec and your model, so this guide does not print one transcript as if every run matched it. What does not change is the shape of each round, because the grilling skill fixes it. This is the template from the skill file at the pinned commit:

❓ **Q1** - **<question title>**: <question body, might be multiple paragraphs, including multiple choices>

➡️ <your recommended answer>

Three rules in that skill tell you what a healthy session looks like.

First, the agent asks a whole round of numbered questions at once. The skill calls this the "frontier": every decision whose prerequisites are already settled. A question that depends on an open answer waits for a later round. For the spec above, a question about the exact 503 response body should not arrive in the same round as the question that decides whether 503 is the right status at all.

Second, every question comes with a recommended answer after the arrow. You can accept it with one word, which keeps rounds fast.

Third, the skill says "Finding facts is your job, never the user's." The agent should look up facts itself, such as which Flask version you run or where the app lives, often with a subagent. It should only ask you about decisions.

The session ends when no open questions remain. The skill tells the agent: "Do not act on it until the user confirms you have reached a shared understanding." If the agent starts editing files before you confirm, something is wrong. The usual cause on an npx install is that grilling is missing, so grill-me had nothing to call. Check /skills for both names. For the opposite problem, an agent that skims a plan instead of going deep, the depth-tree method for making agents work through every branch uses a similar tree idea.

How to remove a skill

How you remove a skill depends on the install path.

npx install. Remove it by name, then confirm it is gone:

npx skills remove prototype
npx skills list

Because the skills are plain files, deleting the folder under .claude/skills/ or .agents/skills/ has the same effect. Commit the removal so it stays removed.

Plugin install. You cannot delete one skill from a managed bundle, so you have two options. To hide one skill, open /skills, highlight it, press Space to cycle its state, and press Esc to save. The states are on, name-only, user-invocable-only and off. Setting a model-invoked skill to user-invocable-only removes it from the model's listing but keeps it in your / menu, which is often what you want. Claude Code saves this as skillOverrides in your settings file. To remove all 27 skills, uninstall the plugin:

claude plugin uninstall mattpocock-skills

It should print a Successfully uninstalled plugin: line. If you only want the skills off for a while, claude plugin disable mattpocock-skills keeps the install in place.

If none of these skills fit your workflow, the format is simple enough to write your own agent skill that does exactly one job for your project.

FAQ

Are Matt Pocock's skills official Anthropic skills?

No. They are a personal collection by Matt Pocock, an independent TypeScript teacher, published under the MIT license. They use the common SKILL.md format, so Claude Code, Codex and other agents can load them. The Claude Code plugin is listed in Claude Code's marketplace, but the content is his, not Anthropic's.

Why does /grill-me start writing code instead of asking questions?

The grill-me skill contains one instruction: call the grilling skill. If you installed with npx skills and picked only grill-me, the skill it calls is missing. Run npx skills@latest add mattpocock/skills --skill grilling, then check that /skills lists both names. The plugin install includes both.

Do Matt Pocock's skills use up my agent's context?

The 16 user-invoked skills cost nothing until you type them, because their descriptions are hidden from the model. The 11 model-invoked skills put their descriptions in the listing on every turn. Run /context in Claude Code to see the cost. Set unused ones to user-invocable-only in the /skills menu to hide them from the model.

Do I need to run /setup-matt-pocock-skills in every repository?

Yes, once per repository, before you use the engineering skills. It records your issue tracker and labels in docs/agents/, and adds an "Agent skills" section to CLAUDE.md or AGENTS.md. The productivity skills such as grill-me and handoff work without it.

Should I use the Claude Code plugin or npx skills?

Use the plugin if you only use Claude Code and want all 27 skills kept up to date for you. Use npx skills@latest add mattpocock/skills if you use another agent, or if you want to pick and edit individual skills. Do not use both, or every skill appears twice.