All cardsPocock Skills

Pocock Skills

25 skills for real engineering, not vibe coding. Small, composable, any model. You keep the process.

Original source

github.com/mattpocock/skills github.com

Seven signals

The whole method in short boxes. Each links to the part of this page that shows it.

01
Grill before every change
The agent interviews you about what you want before it builds. Pocock says to do it every time you make a change. Misunderstanding is the most common failure.
How
02
Write the project's words down
grill-with-docs keeps a glossary of your project's terms and records hard decisions. The agent then uses one word where it used twenty.
How
03
Spec and tickets come after agreement
to-spec writes up what you already agreed, with no second interview. to-tickets slices it into small tickets that say what blocks what.
How
04
Tests are the feedback loop
Without feedback the agent flies blind. tdd writes a failing test first, one thin slice at a time, and implement drives it.
How
05
Care about the design of the code
Agents speed up the mess too. improve-codebase-architecture looks for places to simplify; codebase-design aims for deep modules with small interfaces.
How
06
You type it, or the agent reaches for it
Some skills only run when you type them; they run the process. Others the agent can pick up mid-task; they hold the discipline.
How
07
Not only for code
grill-me, handoff and teach work on plans, long conversations and learning, not just software.
How

Words on this page

Twelve terms, in plain words. Skip this if you already work with coding agents.

Skill: A short instruction file the agent reads to do one job a set way. Each name in the catalog below is one skill.
User-invoked: A skill that only runs when you type its name, like /grill-me. These start and run a process.
Model-invoked: A skill the agent can also pick up by itself when the task fits, like tdd. These hold reusable habits.
Grilling: The agent asks you question after question about a plan until every open choice is settled.
Glossary (GLOSSARY.md): A file of your project's own words and what they mean, so you and the agent use the same short names.
ADR: Architecture decision record. A short note on a hard decision: what was chosen and why.
Spec: The written description of a change: what it should do and why.
Issue tracker: Where tickets live: GitHub, GitLab, local files or anything else. You pick it once in setup.
Tracer-bullet ticket: A thin ticket that goes through every layer end to end, so something works early and you can see it.
TDD (red, green, refactor): Test-driven development. Write a failing test (red), make it pass (green), then tidy up (refactor).
Deep module: A piece of code that does a lot behind a small, simple interface. Easier to use, test and change.
Vibe coding: Letting the agent write code from loose prompts without a plan, tests or review. What these skills are meant to replace.

Setup → grill → spec → tickets → implement

Setup once per repo. Every change starts with a grill. Spec and tickets only after you agree. Implement drives tdd and code-review. Deprecated and in-progress skills stay off this page.

01
setup-matt-pocock-skills
This repo has not been configured yet. Once per repo.
Picks the issue tracker, triage labels, and where docs land.
02
grill-with-docs
You are about to change the product. Align first.
Interviews you, then writes the domain language into GLOSSARY.md and ADRs.
03
to-spec
The grill is done. Capture what you already agreed.
Turns this conversation into a spec on the tracker. No second interview.
04
to-tickets
The spec exists. Slice the work.
Tracer-bullet tickets with blocking edges, files or native tracker links.
05
implement
The tickets are ready. Build.
Drives tdd at the seams you named, then code-review before the commit.

Then back to grill. The next change starts with questions. Spec and tickets follow only after you agree.

Every skill

25 skills. Engineering and productivity. One line each. IDs are what you type.

The path

Setup once. Then grill, spec, tickets, implement.

setup-matt-pocock-skills
Picks the issue tracker, triage labels, and where docs land.
grill-with-docs
Interviews you, then writes the domain language into GLOSSARY.md and ADRs.
to-spec
Turns this conversation into a spec on the tracker. No second interview.
to-tickets
Tracer-bullet tickets with blocking edges, files or native tracker links.
implement
Drives tdd at the seams you named, then code-review before the commit.

Engineering, you type

User-invoked. Orchestrators you start on purpose.

ask-matt
Router over the user-invoked skills in this set.
triage
State machine of triage roles, using the labels from setup.
improve-codebase-architecture
Surveys deepening opportunities, shows an HTML report, grills the one you pick.
wayfinder
A map of decision tickets. Resolve them one at a time until the path is clear.

Engineering, the agent can reach

Model-invoked. Discipline the agent can pick up mid-task.

prototype
One HTML file, or several UI variants on one route.
diagnosing-bugs
Red on this bug, minimise, hypothesise, instrument, fix, regression-test.
research
Background agent. Cited markdown in the repo.
tdd
Red-green-refactor. One vertical slice at a time.
domain-modeling
Stress-tests the glossary, updates GLOSSARY.md and ADRs.
codebase-design
Deep modules: a lot of behavior behind a small interface, at a clean seam.
code-review
Standards and spec, in parallel, so neither pollutes the other.
resolving-merge-conflicts
Resolve by intent from each side’s source. Finishes the operation. Never --abort.
wizard
Interactive bash wizard for the steps only a person can do.

Productivity, you type

Not code-specific. You start these.

grill-me
Relentless interview until every branch of the tree is resolved.
handoff
Compacts the thread into a handoff another agent can pick up.
teach
Stateful teaching workspace in the current directory.
to-questionnaire
Markdown questionnaire. Grills you about the send, not the subject.
wait-what
Re-pitches in plain English, using your GLOSSARY.md words.

Productivity, the agent can reach

Reusable primitives behind the user-invoked skills.

grilling
The interview engine behind grill-me, grill-with-docs, triage, wayfinder.
writing-for-agents
How to write skills, AGENTS.md, CLAUDE.md, and pointer docs.

Try it, smallest version first

Five steps, from the repo's README. Install one way only: the plugin and the installer together leave you with every skill twice. The starter prompt at the end is FakeNerd's.

01
Get the skills
In Claude Code, this installs the whole set from the official marketplace. For Codex and other agents, or to get editable copies in your repo, use npx skills@latest add mattpocock/skills instead and make sure you pick setup-matt-pocock-skills.
Command
```
claude plugins install mattpocock-skills
```
Install options
02
Run setup once in your repo
It asks which issue tracker you use, which labels you put on tickets, and where to save docs.
Command
```
/setup-matt-pocock-skills
```
03
Grill your next change
Describe the change. Answer the questions. It writes the project's words into the glossary as you go.
Command
```
/grill-with-docs
```
The path
04
Turn it into a spec, then tickets
Only after you agree. to-spec writes up what you said; to-tickets slices it.
Command
```
/to-spec
/to-tickets
```
05
Build it
implement works the tickets with tests first, then runs code-review before it commits.
Command
```
/implement
```

FakeNerd starter: your first grill

/grill-with-docs I want to [one small change, e.g. add a search box to the notes page].

Keep it small enough to finish in one session. Ask one question at a time.

FakeNerd's take

You steer, it helps

Nothing runs the whole loop for you: you type grill, spec, tickets, implement. Its sibling Superpowers fires skills on its own. Pick this one if you want to keep the process in your hands.

Same floor as Superpowers

Both question you before code and both run tests first. Superpowers adds worktrees and a fresh agent per task. Pocock adds the tracker, the glossary and architecture surveys.

The glossary is the sleeper

Pocock calls the shared language maybe the coolest technique in the repo. We agree it's the easiest one to steal: a file of your project's words helps any agent, with or without these skills.

More names to remember

Small pieces mean more to learn. If you're lost, ask-matt picks the skill for you. Our advice: start with just the grill, then add the rest.

Related on this site: Superpowers, the sibling set: one plugin that runs the whole loop for you. Compound Engineering, another skills plugin with its own loop.

Attribution

mattpocock/skills by Matt Pocock, MIT license. The skill names, the path, the install commands and the reasons behind each skill are from the repo and its README, summarized in our words.
The README links to his newsletter. Deprecated and in-progress skills are left off this page.
The one-line skill summaries, the signals, the glossary, the starter prompt and the takes are FakeNerd's. Not sponsored by anyone on this page.

Seven signals

Grill before every change

Write the project's words down

Spec and tickets come after agreement

Tests are the feedback loop

Care about the design of the code

You type it, or the agent reaches for it

Not only for code

Words on this page

Setup → grill → spec → tickets → implement

setup-matt-pocock-skills

grill-with-docs

to-spec

to-tickets

implement