How to Tame AI Agents with Matt Pocock's Skills Toolkit

When developers start working closely with Claude Code or Codex, they quickly hit the same problem. The agent cheerfully agrees to the task, goes off to write code for five minutes, and returns five hundred lines of broken spaghetti. Sound familiar? Matt Pocock, the author of Total TypeScript, decided to tackle this problem with engineering discipline and put together a repository of practical instructions (skills) for AI agents. And the vinvcn/mattpocock-skills-zh-CN project adapted this entire toolkit for working with Chinese language models and mixed contexts.

This isn't about abstract discussions on the future of development. It's a set of concrete commands and scenarios that make the language model act like a tidy mid-level or senior developer, rather than a random function generator.

Four scenarios where agents typically fail

Matt identified typical pitfalls developers stumble on when handing off tasks to AI, and wrote a separate work protocol for each case.

The agent does something completely different from what was requested

The most common development headache is called expectation misalignment. A person thinks of one architecture, the model fills in details to its own taste. To close this gap, the author came up with the /grill-me command (and its engineering variant /grill-with-docs).

Before touching any code, the agent conducts a formal interrogation. It asks a series of targeted questions about edge cases, data structure, and interface requirements. The model won't write a single line until the decision tree converges. This saves hours of rewriting code.

The model wastes context on unnecessary chatter

When an agent enters an unfamiliar project, it starts inventing its own terminology and spending dozens of tokens explaining obvious things. The solution lies in creating a document with a unified domain vocabulary (in the project it's called CONTEXT.md).

The /grill-with-docs command doesn't just survey you, but immediately records project terminology and architectural decisions (ADRs). Once you and the agent share a common language, the dialogue shrinks dramatically, and variables in code start being named the same across all modules.

Generated code doesn't run

When a model writes code without feedback, it works blind. It needs tests. The /tdd skill forces the agent to strictly follow the red-green-refactor cycle. First the model writes a failing unit test, then implements exactly as much code as needed to pass the test, and only then cleans up.

For complex bugs there's a separate /diagnosing-bugs scenario. It guides the model through a strict protocol: reproduce the error with a test, narrow the search area, formulate a hypothesis, add logging, fix the code, and run a regression test.

Architecture turns into a mess

The speed of code generation fuels entropy growth. To prevent the project from becoming one tangled ball of spaghetti, the /improve-codebase-architecture command is used.

It scans the project, looks for candidates for deep modules (with simple public interfaces and hidden complex logic) and generates a report. Essentially, it's a regular code quality audit right in the terminal.

Why localize to Chinese

The original repository is written in English, but vinvcn's localization has an interesting technical purpose. It's not just about convenience for Chinese developers.

When working with Asian LLMs like Qwen or DeepSeek, Chinese system prompts and instructions reduce context loss. The model gets less confused by formulation nuances. Meanwhile, all identifiers, command names, file paths, and configuration keys are left in English. Nothing breaks when running scripts.

How the skills architecture works

All skills in the repository fall into two categories:

1. User-invoked commands. Only humans trigger these manually via slash. For example, /ask-matt helps select the right skill for the current task, /to-spec compiles discussion into a ticket, and /wayfinder plans a major feature several sessions ahead.
2. Model-invoked skills. Both the user and the agent can trigger these on their own initiative when it sees a suitable subtask. These include the TDD cycle, git conflict resolution without hard aborts, code review, and drafting.

Skills are written as simple Markdown files with instructions. They're easy to read and can be edited to match your team's rules.

Setup in a couple of minutes

You can add skills to your project using the skills.sh installer:

npx skills@latest add vinvcn/mattpocock-skills-zh-CN

The utility will ask which skills you want to copy and which agent directories to register them in. Make sure to select /setup-matt-pocock-skills.

After installation, run the initial setup right in the agent dialogue:

/setup-matt-pocock-skills

The agent will clarify where you track tasks (GitHub Issues, Linear, or local files), what labels you use for triage, and which folder to store architectural documentation in.

If you're working in Claude Code and don't want to store file copies in every repository, you can connect skills as a plugin:

claude plugin marketplace add vinvcn/mattpocock-skills-zh-CN
claude plugin install mattpocock-skills@mattpocock

In this mode, skills will update centrally when new versions are released.

Who is this for

Two categories of engineers should look into this repository.

First, those who actively use Claude Code, Codex, or OpenCodeInterpreter and are tired of fighting model hallucinations. Matt Pocock's approach brings predictability back to development through strict constraints and short feedback loops.

Second, it's an excellent example of how to write system instructions for AI assistants. Even if you don't need the Chinese translation, the file structure in this repository provides a clear lesson in designing skills for agents. Try incorporating a couple of commands like /grill-me into your daily workflow, and you'll notice the difference by evening.