What is mattpocock/skills?

It is an open-source collection of agent skills by Matt Pocock (Total TypeScript) for real engineering with AI coding agents. The skills fix four common failure modes: misalignment, verbosity, broken code and architectural decay, and they work with Claude Code, Codex, GitHub Copilot, Gemini CLI, Cursor and other agents.

Is mattpocock/skills free?

Yes. The repo is MIT licensed and free to use. You install the skills as a plugin or as editable files, and they work with whatever model your agent already uses.

What is the difference between user-invoked and model-invoked skills?

User-invoked skills are triggered when you type them (like /grill-me) and orchestrate a workflow. Model-invoked skills can be invoked by you or reached for automatically by the agent when the task fits; they hold the reusable discipline, like the TDD loop or the code review checklist.

Which agents support these skills?

Claude Code, Codex, GitHub Copilot (CLI and VS Code), Gemini CLI, Cursor, OpenCode, Devin, Windsurf, Amp and Pi. Claude Code, Codex and Copilot install it as a self-updating plugin; other agents use npx skills add with editable files.

It is the repo's most popular skill. It makes your agent relentlessly interview you about a plan or design until every branch of the design tree is resolved, fixing the most common failure mode: the agent building something you did not want.

Do these skills work with any model?

Yes. The skills are model-agnostic prompt workflows, not model-specific integrations. They work with whatever model your agent uses.

How is this different from GSD, BMAD or Spec-Kit?

Those frameworks own the whole development process, which takes away your control and makes process bugs hard to resolve. These skills are small, easy to adapt and composable: you combine them yourself and adapt them to your workflow.

How do I update the skills?

Plugin installs update themselves (Claude Code by default, Codex at startup, Copilot daily in VS Code). For the editable-files route, run npx skills@latest update, then re-run the add command to pick up new skills.

Matt Pocock Skills: Open-Source AI Agent Skills for Real Engineering

What Matt Pocock's Skills Are: Agent Skills for Real Engineers

Matt Pocock, the educator behind Total TypeScript, open-sourced the agent skills he uses every day. The repo's pitch is blunt: "Skills for Real Engineers. Straight from my .agents directory." These are not demos or vibe-coding toys. They are small, composable workflows designed to fix the failure modes he keeps seeing in Claude Code, Codex and other coding agents.

The philosophy matters as much as the content. Approaches like GSD, BMAD and Spec-Kit try to help by owning the whole process, but in doing so they take away your control and make bugs in the process hard to resolve. These skills do the opposite: they are small, easy to adapt and composable, based on decades of engineering experience. You hack around with them and make them your own.

The project is MIT licensed, works with any model, and had 283,427 stars at the time of writing, making it one of the most-starred repositories on GitHub.

The Four Failure Modes These Skills Fix

The README frames the whole collection around four ways coding agents fail, each with a matching skill.

1. The agent did not do what you want. The most common failure mode in software development is misalignment: you think the dev knows what you want, then you see what was built and realize it never understood you. The fix is a grilling session, getting the agent to ask you detailed questions about what you are building. The /grill-me skill (for non-code uses) and /grill-with-docs (same idea, plus it builds your project's domain model) handle this. These are the repo's most popular skills: use them every time you want to make a change.

2. The agent is way too verbose. Agents dropped into a project use 20 words where 1 will do, because they never learned the project's jargon. The fix is a shared language: a glossary document that helps the agent decode domain terms. This is built into /grill-with-docs, which sharpens terminology and updates GLOSSARY.md and ADRs inline. The README gives a vivid example: "There's a problem when a lesson inside a section of a course is made 'real'" becomes "There's a problem with the materialization cascade." That concision pays off session after session, and it even saves tokens because the agent thinks in a more compact language.

3. The code does not work. Once you are aligned, the agent still needs feedback loops: static types, browser access and automated tests. The /tdd skill slots a red-green-refactor loop into any project, encouraging the agent to write a failing test first and fix it. For debugging, /diagnosing-bugs wraps best debugging practices into a disciplined loop: build a feedback loop that goes red on the bug, minimize, hypothesize, instrument, fix, regression-test, gated phase by phase.

4. We built a ball of mud. Agents speed up coding, which also accelerates software entropy: codebases get more complex at an unprecedented rate. The fix is caring about design every day. /to-spec quizzes you about which modules you are touching before creating a spec, and /improve-codebase-architecture surveys the codebase for deepening opportunities, presents them as a visual HTML report, then grills through whichever one you pick. The README is honest about the limit: it is a survey, not a rescue. It will not untangle a genuinely old codebase for you.

The Skills Catalog: Engineering and Productivity

The skills split on two axes. Engineering skills are for code work; productivity skills are general workflow tools. And each skill is either user-invoked (you type it, like /grill-me, and its job is to orchestrate) or model-invoked (the agent reaches for it automatically when the task fits, holding the reusable discipline).

Engineering highlights:

`/grill-with-docs`: grilling session that also builds the project's domain model, updating GLOSSARY.md and ADRs inline
`/triage`: moves issues through a state machine of triage roles
`/improve-codebase-architecture`: scans for deepening opportunities and presents a visual HTML report
`/to-spec` and `/to-tickets`: turn conversations into specs and break plans into tracer-bullet tickets with blocking edges
`/implement` and `/implement-spec`: build the work, driving /tdd at pre-agreed seams and closing with /code-review before committing
`/wayfinder`: plans work bigger than one agent session as a shared map of decision tickets
`/tdd`: red-green-refactor, one vertical slice at a time
`/diagnosing-bugs`: disciplined diagnosis loop for hard bugs and performance regressions
`/code-review`: two-axis review (standards and spec fidelity) run as parallel sub-agents
`/pr`: the shape a PR body should take, with before/after evidence and a merge-danger call

Productivity highlights:

`/grill-me`: relentlessly interviewed about a plan until every branch of the design tree is resolved
`/handoff`: compacts the current conversation into a handoff document so another agent can continue
`/teach`: teaches a new skill or concept over multiple sessions
`/wait-what`: fires the moment a message does not land; the agent re-pitches it in plain English using your glossary vocabulary
`/writing-for-agents`: guidance for writing documents agents actually use, like skills and AGENTS.md files

How to Install the Skills (30-Second Setup)

Installation takes about 30 seconds and differs per agent. A plugin updates itself; the skills.sh route copies editable files into your project that you update by hand. Pick one per agent, because installing both gives you every skill twice.

Claude Code:

bash

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

Codex:

bash

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

GitHub Copilot (CLI and VS Code):

bash

copilot plugin marketplace add mattpocock/skills
copilot plugin install mattpocock-skills@mattpocock

Then add the marketplace to ~/.copilot/settings.json once. In VS Code, run Chat: Install Plugin From Source and enter the repo URL.

Gemini CLI (manual updates):

bash

gemini skills install https://github.com/mattpocock/skills.git --path skills/engineering
gemini skills install https://github.com/mattpocock/skills.git --path skills/productivity

Any other agent, or editable files:

bash

npx skills@latest add mattpocock/skills -a <agent>

This supports Cursor, OpenCode, Devin, Windsurf, Amp and Pi; omit -a to choose interactively. When the installer asks which skills to take, include setup-matt-pocock-skills. To update, run npx skills@latest update, and re-run add to pick up new skills.

After installing, run `/setup-matt-pocock-skills` once per repo in your agent. It asks which issue tracker you use, what labels you apply when triaging, and where to save docs. Then you are ready.

Why Skills Beat Frameworks: Small, Adaptable, Composable

The design philosophy is the part most worth stealing. Heavyweight agent frameworks own your process: they decide the workflow, and when the workflow has a bug, you are stuck debugging someone else's process. These skills are the opposite bet: small units you compose yourself.

That shows up in the architecture. User-invoked skills orchestrate; model-invoked skills hold reusable discipline. A user-invoked skill may invoke model-invoked skills, but never another user-invoked one, which keeps the composition graph clean. The /ask-matt skill even acts as a router, asking which skill or flow fits your situation.

It also shows up in the tone. The README reads like advice from a senior engineer, not a product manual: "Hack around with them. Make them your own." The skills encode practices from The Pragmatic Programmer, Domain-Driven Design, Extreme Programming and A Philosophy of Software Design, but they never lecture. They just make the agent do the disciplined thing by default.

If you want to keep up with changes and new skills, about 60,000 developers follow the author's newsletter. The repo itself moves fast: it was pushed as recently as 9 October 2026.

Good Fit, Poor Fit

Good fit if you use Claude Code, Codex, Copilot or Gemini CLI daily and your agent keeps building the wrong thing, rambling, shipping broken code or growing your codebase into mud. It is also a great fit if you want to learn the underlying engineering practices, since each skill is a readable Markdown file you can adapt.

Poor fit if you want a fully automated pipeline that owns the process end to end. These skills deliberately keep you in control, which means they ask more of you than a framework would. If you prefer the agent to just go, the grilling sessions will feel like friction.

Fuller write-up aside, the repo README itself is the best documentation: every skill links to its own SKILL.md with the full workflow. Start with /grill-me on your next real task and see how the alignment changes the output.