Matt Pocock’s skills repository was #2 on GitHub’s daily trending list when checked on September 3, 2026. GitHub’s page showed 1,166 stars gained that day; the public repository API reported 246,120 stars, 20,898 forks, and Shell as its primary language at the same check. Those numbers are a snapshot, not a permanent measure of quality.

The project is a collection of small instructions for AI coding agents. Instead of asking an agent to improvise a process for every task, you can give it a repeatable workflow for interviewing you, writing tests, diagnosing a bug, reviewing a change, or improving a codebase’s design. The README describes the skills as composable, adaptable, and usable with different models.

1. What problem does the repository solve?

AI coding agents are fast at producing text and code, but speed does not remove the normal engineering problems: an unclear request, a missing feedback loop, a vocabulary mismatch, or a design that becomes difficult to change. Pocock’s collection packages responses to those problems as ordinary skill files that an agent can load and follow.

The README’s four main failure modes are useful as a map:

• Misalignment: grill-me and grill-with-docs ask detailed questions before implementation. The latter also builds a shared domain vocabulary and records architectural decisions.
• Verbose conversations: the workflow encourages a concise project language in documents such as CONTEXT.md, so the agent does not have to rediscover the same terminology every session.
• Broken code: tdd promotes a red-green-refactor loop, while diagnosing-bugs turns debugging into a sequence of reproduction, hypotheses, instrumentation, fixes, and regression tests.
• Growing complexity: to-spec, codebase-design, and improve-codebase-architecture focus attention on module boundaries and design quality before a codebase becomes harder to change.

This is not a framework that takes ownership of your entire development process. The repository explicitly presents the skills as small building blocks that you can adapt. That makes them easier to inspect than a large, opaque orchestration layer, but it also means you must decide which workflow fits your project.

2. Managed plugin or editable files?

The repository documents two different installation philosophies. Pick one rather than installing both.

Managed Claude Code plugin. The README documents:

claude plugins install mattpocock-skills

This installs the complete set as a managed, read-only bundle. The README says it is available through Claude Code’s official marketplace and updates when new versions are shipped. This route is convenient when you want the upstream collection without maintaining a local copy.

Editable installation for Codex and other agents. The README documents:

npx skills@latest add mattpocock/skills

The installer lets you select individual skills and the coding agents that should receive them. The files are written into your repository as normal files that you own and can edit. The README recommends including setup-matt-pocock-skills in the selection, then running this command in the agent:

/setup-matt-pocock-skills

That setup skill asks which issue tracker you use, which labels belong to triage, and where generated documents should be saved. Run it once per repository, not once per conversation. If you need a durable home for those project terms and decisions, our personal knowledge base guide covers the capture-and-retrieval side. When you want to pull later upstream changes into an editable installation, the README points to npx skills update.

The practical difference is important. A managed plugin favours convenience and upstream updates. Editable files favour local conventions, reviewable changes, and the ability to remove or modify a workflow. Do not assume that a skill installed in one agent is automatically available in another; follow the installer prompts and inspect the resulting files.

3. How invocation works

The README divides the collection along one axis: who can invoke a skill.

User-invoked skills run when you type a command such as /grill-me, /triage, /to-spec, or /implement. They are orchestration tools: they ask questions, create a plan, or move a task through a defined process.

Model-invoked skills can also be reached automatically when the agent decides that the task matches their description. Examples include tdd, code-review, research, domain-modeling, codebase-design, and diagnosing-bugs. The repository says a user-invoked skill may call a model-invoked skill, but not another user-invoked skill. That separation keeps a large workflow from silently triggering another interactive workflow.

For a first trial, use one explicit skill on one small change. A sensible sequence is to run grill-with-docs while shaping the change, use tdd at the implementation seam, and finish with code-review. Read each SKILL.md first, keep the change small, and check the actual diff, test output, and browser behaviour yourself. That last part is practical guidance, not a guarantee made by the repository: instructions can improve a workflow, but they cannot validate your codebase for you.

4. A low-risk way to try it

1. Choose one host and one installation mode. Use the managed plugin if you want upstream updates without local editing. Use the installer if you want repository-owned files.
2. Install only a small group. Start with setup-matt-pocock-skills, grill-me or grill-with-docs, and tdd. Avoid loading every workflow before you understand the invocation model.
3. Run setup in a test repository. Confirm where issue-tracker information, labels, CONTEXT.md, and ADRs will live.
4. Use a bounded task. Give the agent a small bug or feature with a clear acceptance test. Observe whether the skill asks useful questions and whether the resulting artifacts are readable.
5. Review permissions and instructions. A skill is executable guidance for an agent. Inspect scripts, commands, file-writing behaviour, and any integration instructions before granting access to sensitive repositories or credentials.
6. Keep the parts that help. Because the editable installation is ordinary repository content, you can adapt the wording to your team’s terminology or remove a workflow that does not fit.

The MIT license is documented in the repository’s LICENSE file. It permits broad reuse subject to the included notice and disclaimer, but licensing the files does not make an agent’s output correct, secure, or suitable for production without review.

5. What changed recently?

The latest listed release is v1.2.3, published on August 6, 2026. Its release notes include a redaction section for diagnosing-bugs, changes that remove Claude Code-specific tool and agent names from several dispatch instructions, and a wizard update that removes time estimates. The public commit history then shows the latest commit, 6654f6b, on August 24, adding an “Information access” category to the retrospective skill for improved agent insights.

That maintenance pattern is worth noting. The project is not only a catalogue of prompts; it is also revising invocation metadata, portability, debugging hygiene, and the documentation around the workflows. Still, the repository’s current instructions are the source of truth. Re-check them before copying commands into a production setup.

Bottom line

mattpocock/skills is best understood as a toolbox for disciplined agent-assisted engineering. Its strongest idea is not a single command. It is the insistence that alignment, shared language, tests, debugging, and design remain part of development even when an AI agent writes much of the code.

Start with one skill, one repository, and one reversible task. Choose the managed or editable path deliberately, run setup once, inspect what the agent is told to do, and keep normal engineering review in the loop. If you want a separate example of running an AI assistant locally rather than using a web chat, see our Hermes Agent guide.

Sources

• GitHub daily trending repositories
• mattpocock/skills repository
• Repository README
• Release v1.2.3
• Latest listed commit, 6654f6b
• MIT license

Hero image: Cbaile19, CC0, via Wikimedia Commons.

Frequently Asked Questions

What is mattpocock/skills?

It is Matt Pocock's public collection of small, composable skills for software engineering and general productivity with AI agents. The README groups them into Engineering and Productivity and separates user-invoked skills from model-invoked skills.

How do I install Matt Pocock's skills?

For Claude Code, the README documents claude plugins install mattpocock-skills. For Codex and other agents, it documents npx skills@latest add mattpocock/skills, where you choose the skills and agents to install.

Should I install both the Claude plugin and the editable files?

No. The repository documents the plugin as a managed, read-only bundle and the skills.sh installer as editable files in your project. Installing both leaves duplicate copies of the skills.

Is the repository free for commercial use?

The repository is marked MIT licensed, and its LICENSE file grants broad permission to use, copy, modify, merge, publish, distribute, sublicense, and sell copies, subject to the license notice and warranty disclaimer. Check the repository before redistributing any future additions.