Code Review & Git · Blog Post

Matt Pocock's Skills: grill-me, TDD, and two-axis code review for coding agents

Most agent failures start before a line of code is written: the agent never understood what you wanted. Matt Pocock's skills repo starts there, with an interview that does not stop until the plan has no open questions, then carries the result through specs, tickets, test-first builds, and a review that checks the diff against both your standards and your spec.

By Mehadi Hasan 8 min read

What it is

mattpocock/skills is the personal skill collection of Matt Pocock, who publishes it under his AI Hero brand (aihero.dev). The repo describes itself as "Skills for Real Engineers. Straight from my .agents directory." The README is more direct: these are the skills he uses every day "to do real engineering - not vibe coding."

It positions itself against heavier frameworks. The README names GSD, BMAD, and Spec-Kit as approaches that "own the process" and, in doing so, take away your control. Pocock's pitch is the opposite: small skills that compose, work with any model, and are meant to be edited. The repo was created on February 3, 2026 and was last pushed on November 17, 2026. As of that date it has 326,591 GitHub stars and 27,437 forks.

Each skill is built to fix one failure mode he sees in Claude Code, Codex, and other agents. The README lists four: the agent didn't do what you wanted, the agent is too verbose, the code doesn't work, and the codebase turned into a ball of mud.

What's inside

326k+ GitHub stars (Nov 17, 2026)
27 Skills in the plugin
20 / 7 Engineering / productivity
MIT License

The plugin manifest (version 1.3.2 at the time of writing) ships 27 skills in two buckets. Engineering has 20: ask-matt, grill-with-docs, triage, improve-codebase-architecture, setup-matt-pocock-skills, to-spec, to-tickets, implement, implement-spec, wayfinder, retro, prototype, diagnosing-bugs, research, tdd, domain-modeling, codebase-design, code-review, pr, and wizard. Productivity has 7: grill-me, grilling, handoff, teach, to-questionnaire, wait-what, and writing-for-agents.

Two more folders sit outside the plugin. skills/misc/ holds four tools he "rarely" uses, including git-guardrails-claude-code (hooks that block git push, reset --hard, and similar) and setup-pre-commit. skills/in-progress/ holds seven beta skills, such as claude-handoff and three writing skills, that "can change or disappear without warning."

The README splits skills by who can call them. User-invoked skills (like /grill-me) only run when you type them; their job is to orchestrate. Model-invoked skills (like tdd or code-review) can also be picked up by the agent when the task fits. A user-invoked skill may call model-invoked ones, never another user-invoked one.

How it works: grilling first, then idea → ship

The skill people know is grill-me, which the README calls his most popular. Its SKILL.md is one line: it calls the model-invoked grilling skill. That skill does the real work. It maps your plan as a design tree, where every decision branches into the decisions that depend on it, and works the tree in rounds.

Each round asks the whole "frontier": every question whose prerequisites are already settled. Questions are numbered, each comes with the agent's recommended answer, and each is worded so "yes" accepts the recommendation. Facts the agent can look up itself (files, tools) go to a sub-agent instead of to you. Decisions stay with you. The session ends when the frontier is empty, and the agent is told not to act until you confirm you share an understanding.

Round format from the grilling skill

Q1 - <question title>: <question body, choices>
  → <recommended answer>
---
Q2 - <question title>: <question body, choices>
  → <recommended answer>

grill-with-docs runs the same interview plus domain-modeling, so the terms you settle on land in a GLOSSARY.md and hard decisions land in ADRs. The README argues this shared vocabulary is "the single coolest technique in this repo": an agent that knows your jargon uses one word where it would have used twenty. The ask-matt router lays out the full main flow:

  1. /grill-with-docs: Interviews you about the idea and records what it learns in GLOSSARY.md and ADRs as it goes. Use /grill-me instead when there is no repo to write into.
  2. /to-spec: Turns the conversation into a spec and publishes it to your issue tracker. No new interview, it synthesizes what you already discussed.
  3. /to-tickets: Splits the spec into tracer-bullet tickets, each one declaring which tickets block it.
  4. /implement or /implement-spec: Builds one ticket at a time (clearing context between them), or the whole spec on one integration branch with parallel implementer subagents. Both drive /tdd and close with /code-review.
  5. /retro: Looks back over the session and suggests changes to the agent's environment: checks, coding standards, steering files, tooling.

The code-review skill is worth a closer look. It reviews the diff since a fixed point you name (a commit, branch, or tag) on two axes, each in its own sub-agent with a fresh context. Standards checks the diff against the repo's documented coding rules plus a baseline of twelve Fowler code smells, such as Feature Envy and Shotgun Surgery, always reported as judgement calls. Spec checks it against the originating issue: what is missing, what was added without being asked for, and what looks wrong. The two reports are shown side by side and deliberately not merged or reranked.

Installation

There are two routes. A plugin updates itself. skills.sh copies editable files into your project, which you update by hand. The README says to pick one per agent, because installing both gives you every skill twice. For Claude Code:

Claude Code: official plugin marketplace

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

Codex and GitHub Copilot install from the repo's own marketplace:

Codex and GitHub Copilot

# Codex
codex plugin marketplace add mattpocock/skills
codex plugin add mattpocock-skills@mattpocock

# GitHub Copilot CLI
copilot plugin marketplace add mattpocock/skills
copilot plugin install mattpocock-skills@mattpocock

Copilot also needs a one-time extraKnownMarketplaces entry in ~/.copilot/settings.json for auto-updates (the README has the JSON). In VS Code, run Chat: Install Plugin From Source with the repo URL. Gemini CLI installs each bucket with gemini skills install and --path skills/engineering or --path skills/productivity. For Cursor, OpenCode, Windsurf, and other agents, use the skills.sh installer:

Any other agent (editable files)

npx skills@latest add mattpocock/skills -a cursor

Swap cursor for your agent, or drop -a to choose interactively. When it asks which skills to take, include setup-matt-pocock-skills. The in-progress skills are not in the plugin; install one directly with --skill=<name>.

Then run /setup-matt-pocock-skills once per repo. It asks which issue tracker you use (GitHub, GitLab, local Markdown files, or something you describe), what triage labels you apply, and where docs should be saved. The engineering skills that touch tickets, such as to-spec, to-tickets, triage, and code-review, depend on this.

Using it day to day

The README's advice is to use a grilling skill "every time you want to make a change." In practice that means starting a change with /grill-with-docs in a repo, or /grill-me for anything that isn't code: a client proposal, a migration plan, a pricing decision. Answer the rounds, accept the recommendations you agree with, and only then let the agent build.

For small work, /implement runs in the same context window. For multi-session work, ask-matt says to keep grilling, spec, and tickets in one unbroken context, then start each ticket fresh. It also names a practical ceiling, the "smart zone" of roughly 150k tokens on current models, past which it says to compact at the nearest phase boundary rather than push on.

A few standalone skills are useful on their own. /code-review reviews any branch or PR against a fixed point. diagnosing-bugs runs a gated loop: build a check that goes red on this bug, minimise, hypothesise, instrument, fix, regression-test. /handoff compacts a conversation into a document another agent can pick up. /wait-what makes the agent re-explain a message that didn't land, in plain English. improve-codebase-architecture scans for "deepening" opportunities and presents them as an HTML report; the README suggests running it every few days and is clear that it is "a survey, not a rescue."

Pricing

Free. The repo and plugin are MIT-licensed, with no paid tier or account in the install path. The only cost is the model usage of whatever agent runs the skills. Grilling rounds and parallel review sub-agents add tokens compared with just asking for code. The README links to an optional newsletter (it says about 60,000 developers subscribe) for updates on new skills.

My take

The strongest idea here is also the smallest file. The grilling skill is a few paragraphs, and it targets the most expensive mistake in agent work: building the wrong thing confidently. Asking the whole frontier at once, with a recommended answer for each question, keeps the interview fast. Sending fact-finding to a sub-agent means you only answer questions that need a human. None of this is code-specific, which is why grill-me lives in the productivity bucket. It works as well for scoping a monday.com board or an n8n workflow as for a TypeScript feature.

The engineering half asks more of you. It assumes a real issue tracker, a repo where GLOSSARY.md and ADRs can live, and a willingness to work in specs and tickets. That suits developers and small teams shipping real applications. It is heavier than a solo builder needs for quick scripts. The two-axis code-review is a careful design: keeping "does it follow our rules" separate from "does it do what we asked" stops one kind of finding from burying the other.

Compared with Superpowers, which triggers its workflow automatically, most of the orchestration here is user-invoked: you type the slash command when you want it. That is a real trade. You get more control and less surprise, but the discipline only happens if you remember to start it. If you install one thing from this repo, start with /grill-me. Add the rest when you want the full flow from idea to merged PR.

Frequently asked questions

What does grill-me actually do?

It calls the grilling skill, which maps your plan as a tree of decisions and asks every currently answerable question in one numbered round, each with a recommended answer. It looks up facts itself through a sub-agent, leaves decisions to you, and stops only when no branch is left unresolved. It works for non-code plans too.

What is the difference between grill-me and grill-with-docs?

Both run the same grilling interview. grill-with-docs also runs the domain-modeling skill, so the terms you agree on are written to a GLOSSARY.md and hard-to-explain decisions are recorded as ADRs in your repo. Use grill-me when there is no repo to write into.

Do I need to configure anything after installing?

Run /setup-matt-pocock-skills once per repo. It asks which issue tracker you use (GitHub, GitLab, local Markdown files, or another you describe), your triage labels, and where docs should live. Skills like to-spec, to-tickets, triage, and code-review rely on that setup.

Which agents does it support?

The README gives plugin installs for Claude Code, Codex, and GitHub Copilot (CLI and VS Code), a gemini skills install path for Gemini CLI, and npx skills@latest add for Cursor, OpenCode, Windsurf, and other agents. Pick one install method per agent, or every skill appears twice.