5 Agent Skills I Use Every Day to Encode My Development Process
Matt Pocock, a seasoned engineer, shares 5 agent skills he uses daily to encode rigorous, repeatable processes for LLM agents, addressing their lack of memory and tendency to drift. Key skills include: grill-me (exhaustive questioning before coding), to-prd (turning discussions into PRDs), to-issues (slicing PRDs into vertical issues), tdd (forcing red-green-refactor cycles for quality), and improve-codebase-architecture (identifying shallow modules for deepening). The core insight: short, well-crafted skills can dramatically boost agent output quality.
I've been an engineer for nearly a decade. Right now, process has never been more important.
You have access to a fleet of middling to good engineers that you can deploy at any time. But these engineers have a critical flaw: they have no memory. They don't remember things they've done before.
This means you need extremely strict and well-defined processes to get them to do useful work. As a developer, you're constantly steering your agents, keeping them on the right track.
My way of fixing this has been to create a LOT of agent skills. Each skill I've designed helps me encode my process so that AI has a strict path to follow every single time:
The result? The code quality that AI produces has shot up dramatically.
The kit: grill-me · to-prd · to-issues · tdd · improve-codebase-architecture · see all skills →
Read the guide · GitHub
npx skills@latest add mattpocock/skills
我做了将近十年的工程师。如今，流程从未如此重要。
你拥有一支中等到优秀水平的工程师编队，随时可以部署。但这些工程师有一个致命缺陷：他们没有记忆。他们不记得自己以前做过的事。
这意味着你需要极其严格、定义清晰的流程，才能让他们产生有用的成果。作为开发者，你不断引导这些代理，确保他们走在正确的轨道上。
我的解决方法是创建大量代理技能。我设计的每个技能都能帮我编码流程，让 AI 每次都有严格的路径可循：
效果如何？AI 产出的代码质量大幅提升。
技能工具包：grill-me · to-prd · to-issues · tdd · improve-codebase-architecture · 查看所有技能 →
阅读指南 · GitHub
npx skills@latest add mattpocock/skills
This is my favorite skill. It's only three sentences long, but it's incredibly impactful.
The Grill Me Skill:
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one by one. And finally, if a question can be answered by exploring the code base, explore the code base instead.
The concept of a "design tree" comes from The Design of Design by Frederick P. Brooks. It's the idea that as you're designing something, you need to walk down all of the branches of a design tree.
For example, you might be designing a search page and need to decide between an advanced search interface or a simple text box. If you choose advanced search, you need to figure out all the filters and sorting methods. You keep walking down the tree until you've fully understood your design before committing to code.
这是我最喜欢的技能。只有三句话，但影响力惊人。
Grill Me 技能：
无休止地质问我计划的每一个方面，直到我们达成共识。沿着设计树的每个分支走下去，逐个解决决策之间的依赖关系。最后，如果某个问题可以通过探索代码库来回答，那就去探索代码库。
“设计树”的概念来自 Frederick P. Brooks 的《设计的设计》。意思是，在设计时，你需要遍历设计树的所有分支。
举个例子，你正在设计一个搜索页面，需要在高级搜索界面和简单文本框之间做选择。如果选择了高级搜索，就必须弄清楚所有的过滤器和排序方式。你会不断往下走，直到在开始写代码之前完全理解了自己的设计。
When I invoke this skill, I want to reach a shared understanding with the LLM. Claude Code tends to spit out a plan really early when in plan mode, creating a document before we've truly understood each other. But the grill me skill forces that conversation.
In one conversation about adding a feature to my course video editor, Claude asked me 16 questions. And that was a relatively short grilling session. I've had sessions lasting nearly half an hour with 30, 40, or even 50 questions on really complex features.
The key takeaway: Skills don't have to be long to be impactful. You just need to choose the right words at the right time.
Read the guide · GitHub
npx skills@latest add mattpocock/skills
当我调用这个技能时，我想要与 LLM 达成共享理解。Claude Code 在计划模式下往往会过早地抛出方案，在我们真正理解彼此之前就生成文档。但 Grill Me 技能强制我们进行对话。
有一次，在讨论给课程视频编辑器添加新功能的对话中，Claude 问了我 16 个问题。这还算比较短的盘问。我经历过长达近半小时、包含 30、40 甚至 50 个问题的盘问，针对的真是非常复杂的功能。
关键点：技能不需要长到惊人，只需在合适的时机选用恰当的措辞。
阅读指南 · GitHub
npx skills@latest add mattpocock/skills
Once I've reached a shared understanding with the LLM, I invoke my next skill: /write-a-prd.
This skill asks the LLM to create a Product Requirements Document. It may skip steps if they're not necessary. For example, if you've already done a deep interview, it moves straight to step four.
The workflow includes:
Ask the user for a detailed description
Explore the repo to verify assertions
Interview the user relentlessly (using the grill me skill)
Sketch out major modules needed
Write the PRD using a template and submit as a GitHub issue
The important part of any PRD is the user stories. These describe the desired behavior of your system in language, drawing from Agile methodology.
Read the guide · GitHub
npx skills@latest add mattpocock/skills
一旦我与 LLM 达成了共享理解，我就会启动下一个技能：/write-a-prd。
这个技能让 LLM 创建产品需求文档。如果某些步骤没有必要，它可以跳过。例如，如果你已经进行了深入的面谈，它就直接跳到第四步。
工作流程包括：
向用户索要详细描述
探索仓库以验证断言
无休止地盘问用户（使用 Grill Me 技能）
勾勒出所需的主要模块
使用模板编写 PRD 并提交为 GitHub Issue
PRD 中最重要的部分是用户故事。这些故事用语言描述了系统的期望行为，借鉴了敏捷方法。
阅读指南 · GitHub
npx skills@latest add mattpocock/skills
The PRD describes your destination. But what you really need is the journey to get there.
That's what the PRD to Issues skill does. It takes a PRD and turns it into a Kanban board of independently grabbable issues.
The process:
Locate the PRD (fetch it if needed)
Explore the code base
Draft vertical slices - break the PRD into tasks that flush out unknown unknowns quickly
The tracer bullet analogy applies here. Each issue is a thin vertical slice cutting through all integration layers, not a horizontal slice of one layer.
The skill also establishes blocking relationships between tasks. For instance, one issue might not be blocked by anything, so it can be picked up independently. This is useful if you have parallel agent setups where multiple agents can work simultaneously.
AI Hero · Skill System
There are more where these came from
grill-with-docs, domain-model, and triage round out the kit — plus a changelog of updates as it evolves.
See the skill set
Read the guide · GitHub
npx skills@latest add mattpocock/skills
PRD 描述了你的目的地。但你真正需要的是到达那里的路径。
这正是 PRD to Issues 技能的作用。它把 PRD 转换成一个看板，上面有可以独立抓取的任务。
流程：
定位 PRD（如果需要则拉取）
探索代码库
起草垂直切片——将 PRD 拆分为能快速暴露未知未知的任务
这里用了“曳光弹”的类比。每个 Issue 是一个薄的垂直切片，贯穿所有集成层，而不是单个层的水平切片。
该技能还会建立任务间的阻塞关系。例如，某个 Issue 不被任何东西阻塞，因此可以独立启动。这在你有并行代理设置、多个代理可以同时工作时非常有用。
AI Hero · 技能系统
还有更多技能
grill-with-docs、domain-model 和 triage 进一步完善了这个工具包——以及随着演进而更新的变更日志。
查看技能集
阅读指南 · GitHub
npx skills@latest add mattpocock/skills
How do you execute on a skill? How do you make the implementation rock solid and increase code quality?
You use a TDD skill. TDD stands for Test-Driven Development, and it forces (or rather, encourages) the agent to follow a red-green-refactor loop.
This skill is substantial. It includes philosophy on refactoring, mocking, and what deep modules are. Doing really good TDD has been the most consistent way to improve agent outputs.
The workflow starts with confirming what interface changes are needed. When an AI looks at a bad codebase, it sees many tiny, undifferentiated modules. But if you restructure it into larger modules with thin interfaces on top, the AI can navigate it much more easily.
The skill then:
Confirm which behaviors to test
Design interfaces for testability
Write one test at a time (test first)
Implement code to make the test pass
Look for refactoring candidates
Red-green-refactor with agents is incredible. It creates a loop that continues until complete.
View on GitHub
npx skills@latest add mattpocock/skills
如何执行一个技能？如何让实现变得坚如磐石并提高代码质量？
答案是使用 TDD 技能。TDD 代表测试驱动开发，它强制（或者说鼓励）代理遵循红-绿-重构循环。
这个技能内容很扎实。它包含关于重构、模拟以及什么是深度模块的理念。做好 TDD 是提升代理输出最一致的方法。
工作流从确认需要哪些接口变更开始。当 AI 查看一个糟糕的代码库时，它看到的是许多微小且无差别的模块。但如果你将它重构为更大的模块，并在上层提供薄的接口，AI 就能更轻松地导航。
然后该技能会：
确认要测试哪些行为
为可测试性设计接口
一次只写一个测试（测试先行）
实现代码让测试通过
寻找重构候选
与代理一起进行红-绿-重构非常棒。它会创建一个循环，一直持续到完成。
在 GitHub 上查看
npx skills@latest add mattpocock/skills
TDD demands a lot of your codebase. In a badly structured code base, test boundaries are unclear. Where should you test? At which layer?
When your code base has clear module boundaries, testing becomes much easier.
The /improve-codebase-architecture skill explores your codebase naturally, looking for confusions:
Where does understanding one concept require bouncing between many small files?
Where have pure functions been extracted just for testability, but real bugs hide in how they're called?
Where do tightly coupled modules create integration risk?
Then it presents candidates for deepening opportunities - chances to deepen shallow modules into deeper ones.
Do this once a week or after a surge of development. As you keep refining your codebase, you'll notice the quality of the agent's output goes up.
If you have a garbage code base, the AI will produce garbage within that code base.
That's five of seven. The rest — grill-with-docs, domain-model, triage — and a changelog of updates live at /skills.
The most successful way to get code quality up from agents is to treat them like humans. Humans with weird constraints, sure - humans with no memory who are cloned and go right to work. But humans nonetheless.
Check out the skills repository to get started.
TDD 对代码库要求很高。在结构糟糕的代码库中，测试边界不清晰。你应该在哪里测试？在哪个层次测试？
当你的代码库有清晰的模块边界时，测试就变得容易得多。
/improve-codebase-architecture 技能会自然地探索你的代码库，寻找混乱之处：
理解某个概念需要在多个小文件之间跳转吗？
纯函数只是为了可测试性而提取出来的，但真正的 bug 却隐藏在其调用方式中吗？
紧密耦合的模块是否带来了集成风险？
然后它会提出深化的候选方案——将浅模块深化为更深模块的机会。
每周做一次，或者在开发高峰期之后做。随着你不断优化代码库，你会发现代理的输出质量也随之提升。
如果你的代码库是垃圾，AI 在那个代码库里产出的也会是垃圾。
以上就是七个技能中的五个。其余技能——grill-with-docs、domain-model、triage——以及更新日志都在 /skills 上。
从代理那里获得更好代码质量的最成功方法是像对待人类一样对待它们。当然，是带有奇怪限制的人类——没有记忆、被克隆后直接进入工作状态的人类。但仍然是人类。
查看技能仓库开始使用。