Overview
Matt Pocock walks through the five Claude Code skills he uses daily to turn vague ideas into shipped features. The core insight: AI coding agents have no memory between sessions, so you need strict, repeatable processes encoded as small markdown skill files. These five skills form a chain — /grill-me → /write-a-prd → /vertical-slice → /tdd → /improve — that takes you from fuzzy concept to production code with test coverage and continuous refinement.
1 Why Process Matters More Than Ever
Matt opens with the fundamental problem: AI engineers have no memory. Every time you start a new Claude Code session, the agent knows nothing about your project's history, decisions, or conventions. This means you can't rely on tribal knowledge or verbal agreements — you need strict processes.
The solution? Skills — small markdown files that encode process. They're not just prompts or tips; they're structured instructions that tell the AI exactly how to approach a task, what questions to ask, and what output to produce. Skills are the bridge between human intent and AI execution.
Why Markdown Files?
- Portable — skills live in your repo, travel with your code
- Versionable — track changes, iterate, improve over time
- Shareable — team members get the same process instantly
- Composable — skills can reference and chain into each other
2 Skill 1: /grill-me
The first skill in Matt's pipeline is /grill-me — and it's deceptively simple. The entire skill file is roughly three sentences long, but it transforms Claude Code into a relentless interviewer that forces you to clarify your thinking before any code is written.
How It Works
When you invoke /grill-me, Claude Code enters an interview mode. Instead of jumping to code, it asks probing questions about your feature idea — edge cases, user flows, error handling, scope boundaries, and design tradeoffs. It builds what Matt calls a design tree, inspired by Fred Brooks' The Design of Design.
The Design Tree
Brooks' concept is that every design decision branches into alternatives, and the best designs come from explicitly exploring those branches rather than grabbing the first solution. /grill-me forces this exploration through conversation.
- Forces shared understanding — both you and the AI agree on scope
- Prevents premature coding — no wasted effort on wrong approaches
- Surfaces edge cases early — cheaper to handle in design than in debug
- Documents decisions — the grilling output becomes a record of why
3 Skill 2: /write-a-prd
After the grilling session produces a rich understanding, the next skill — /write-a-prd — converts that output into a durable PRD (Product Requirements Document). This is where fuzzy conversation becomes structured specification.
The PRD Process
- Explores the repo — Claude Code scans your codebase to understand existing patterns, architecture, and conventions
- Interviews further — asks targeted follow-up questions based on what it found in the code
- Creates a structured spec — outputs a formatted document with clear sections: goals, non-goals, technical approach, dependencies, and acceptance criteria
Why PRDs Matter for AI
- Session independence — any new agent session can pick up where the last left off by reading the PRD
- Scope anchor — prevents feature creep when the AI suggests "improvements"
- Review artifact — teammates can review the plan before a line of code is written
4 Skill 3: /vertical-slice
With a solid PRD in hand, /vertical-slice breaks it down into thin, end-to-end deliverable slices. Each slice cuts vertically through the entire stack — from UI to database — delivering one complete piece of user-visible functionality.
What Makes a Good Vertical Slice?
- End-to-end — touches every layer needed, not just backend or just frontend
- Independently valuable — delivers something a user could actually use or test
- Small enough for one session — fits within a single Claude Code context window
- Testable — has clear acceptance criteria from the PRD
This approach is borrowed from agile methodology but becomes even more critical with AI agents. Human developers can hold large tasks in their heads and make incremental progress across sessions. AI agents cannot — they need discrete, completable units of work.
5 Skill 4: /tdd
Once you have a vertical slice defined, /tdd enforces Test-Driven Development — write failing tests first, then implement the code to make them pass. This is the skill that provides the safety net for non-deterministic AI coding.
Why TDD Is Essential for AI Agents
AI agents are non-deterministic — the same prompt can produce different code each time. Without tests, you have no way to know if the agent's output actually works. TDD flips this: you define correctness first, then let the agent figure out how to achieve it.
- Tests as specification — failing tests precisely define what "done" means
- Verification loop — the agent can run tests itself to check its own work
- Regression protection — future changes (by AI or human) can't silently break things
- Confidence to refactor — enables the /improve skill to work safely
The TDD Cycle with AI
- Red — write a failing test that describes the desired behavior
- Green — let the AI implement just enough code to pass the test
- Refactor — clean up the implementation while tests stay green
6 Skill 5: /improve
The fifth and final skill — /improve — is about continuous codebase improvement. It's the maintenance skill that prevents entropy from accumulating in your codebase over time.
What /improve Does
- Refactoring — identifies duplicated logic, overly complex functions, and code smell
- Architecture cleanup — suggests and implements structural improvements
- Convention enforcement — aligns code with your project's established patterns
- Dependency updates — modernizes outdated patterns and APIs
Matt emphasizes running /improve regularly — not just at the end of a project. Entropy in AI-generated code accumulates faster than in human-written code because each session starts fresh without awareness of the broader codebase's evolution.
7 The Complete Pipeline
Matt ties all five skills together into a single, coherent development pipeline:
/grill-me → /write-a-prd → /vertical-slice → /tdd → /improve
- /grill-me — Extract and clarify your intent through relentless questioning (16–50 questions)
- /write-a-prd — Convert the shared understanding into a durable specification document
- /vertical-slice — Break the PRD into thin, end-to-end slices that fit one AI session
- /tdd — For each slice: write failing tests, then implement to green
- /improve — Regularly refactor and clean up, protected by the test suite
Why the Order Matters
Each skill's output feeds directly into the next. Skip the grilling and your PRD will have gaps. Skip the PRD and your slices won't have clear acceptance criteria. Skip slicing and you'll overwhelm the AI. Skip TDD and you can't safely improve. The pipeline is designed so that each step de-risks the next.
The Bigger Picture
Matt argues this isn't just about productivity — it's about changing how we think about software development in the age of AI. The skills encode the meta-process: how to think about building, not just how to build. They work because they respect the fundamental constraints of AI agents (no memory, non-deterministic, context-limited) while leveraging their strengths (tireless, fast, breadth of knowledge).
🎯 Key Takeaways
- AI agents have no memory — skills (small markdown files) are the solution for encoding repeatable processes that survive across sessions.
- /grill-me forces clarity — a 3-sentence skill that generates 16–50 probing questions, building a shared design tree before any code is written.
- PRDs are AI-native contracts — the /write-a-prd skill creates durable specifications that any future agent session can consume as context.
- Vertical slicing prevents AI overload — thin, end-to-end slices keep agents focused and prevent the tangled mess that comes from broad, unfocused tasks.
- TDD is non-negotiable with AI agents — non-deterministic systems need deterministic verification; tests define correctness before implementation.
- /improve fights entropy — regular refactoring keeps AI-generated codebases healthy, but only works safely with a TDD foundation.
- The 5-skill pipeline is sequential — each step de-risks the next: grill → PRD → slice → TDD → improve.
- Skills encode the meta-process — they teach AI agents how to think about building, respecting their constraints (no memory, non-deterministic) while leveraging their strengths (speed, breadth).