Matt Pocock's skills

Matt Pocock's skills are the intent pack from What it takes to trust an agent, the one that guards against misalignment before a line of code exists. The goal is simple: agree on what to build, then build it.

Pocock describes them as the skills from his own agents directory, used every day for real engineering. The README owns the current skill list.

What it is

A public repo of agent skills, split by who can invoke them. User-invoked skills run only when typed, and their job is to orchestrate. Model-invoked skills can also be picked up by the agent when the task fits, and they hold the reusable discipline. A user-invoked skill may call model-invoked ones, but never another user-invoked one. The skills are grouped into engineering and productivity sets.

The design stance is explicit. The README names approaches that own the whole process as the thing it avoids, because they take control away and make bugs in the process hard to fix. These skills are meant to be small, easy to adapt and composable, to work with any model, and to be edited freely.

The failure point it guards

The agent builds the wrong thing. The README's first failure mode is misalignment, with a quote from The Pragmatic Programmer: nobody knows exactly what they want. The fix is a grilling session, where the agent interviews the human about the change until every branch of the design is resolved. Pocock calls these his most popular skills and recommends them for every change.

The second idea comes from domain-driven design. Agents dropped into a project guess at its jargon and use many words where one would do. A shared glossary of the project's terms fixes that. Variables, functions and files get named consistently, the codebase is easier for the agent to navigate, and the agent spends fewer tokens thinking. Hard-to-explain decisions go into ADRs as they come up.

When to use it

Reach for it when:

• The problem is fuzzy and the real risk is building the wrong thing.
• The codebase is one to live with for years, and design quality and consistent naming matter.
• A preference for small, hackable building blocks over a framework that owns the process.
• A domain has jargon that agents keep getting wrong or over-explaining.

Skip it when:

• The task is already fully specified and small. A grilling session on a one-line fix costs more than it saves.
• The main risk is an agent claiming success it hasn't earned. pstack guards that point more directly.
• A team needs a recognizable lifecycle that runs through CI, launch and deprecation. Addy Osmani's agent-skills cover more of that ground.

At a glance

Main skills

• grill-me — the agent interviews the human about a plan or design until every branch is resolved. For non-code use as well as code.
• grill-with-docs — the same grilling, plus it sharpens terminology in GLOSSARY.md and writes ADRs inline.
• domain-modeling — challenges terms against the glossary and stress-tests the model with edge-case scenarios.
• to-spec and to-tickets — turn a conversation into a spec, then into tracer-bullet tickets with their blocking edges.
• implement — builds from a spec or tickets, drives tdd at agreed seams, and closes with a code review.
• tdd — red-green-refactor, one vertical slice at a time.
• diagnosing-bugs — a gated loop for hard bugs: make it go red, minimise, hypothesise, instrument, fix, regression-test.
• improve-codebase-architecture — surveys a codebase for opportunities to deepen modules, then grills through the chosen one.
• wayfinder — plans work too big for one agent session as a map of decision tickets, resolved one at a time.

Lineage

The README cites its sources openly: The Pragmatic Programmer, Eric Evans' Domain-Driven Design, Kent Beck's Extreme Programming Explained and John Ousterhout's A Philosophy of Software Design. The deep-module idea from Ousterhout runs through the design skills.

How to install

In Claude Code, as a plugin that updates itself:

claude plugin install mattpocock-skills@claude-plugins-official

For other agents, or for editable copies in the project:

npx skills@latest add mattpocock/skills

Then run /setup-matt-pocock-skills once per repo. It asks which issue tracker to use, which triage labels apply, and where to save the docs it creates. The README warns against using both install paths for the same agent, because the agent then sees every skill twice.

Related

• What it takes to trust an agent — the essay that frames all three packs as theories of where agent work breaks.
• pstack — the evidence pack: a passing build is not proof.
• Addy Osmani's agent-skills — the process pack: the full lifecycle, plus a table of the agent's excuses.
• Claude Code — one of the harnesses it installs into.