▶ YouTube Summaries

• YT :: https://www.youtube.com/watch?v=EJyuu6zlQCg
• Original title :: 5 Claude Code skills I use every single day

Matt Pocock walks through five agent skills from his skills repo that encode a strict process for memoryless agents: /grill-me, /write-a-prd, /prd-to-issues, /tdd and /improve-codebase-architecture. Chained together they take an idea from interview to PRD to vertical-slice issues to test-driven implementation, with periodic architecture cleanup keeping the codebase friendly to agents.

Why process matters

Agents are a fleet of middling-to-good engineers with no memory, so they need extremely strict, well-defined processes. Skills let him encode his process as a path the AI walks every time, and code quality has shot up as a result. Treating agents like humans with weird constraints is, for him, the most successful way to raise code quality.

/grill-me

Three sentences: interview me relentlessly about every aspect of the plan until we reach a shared understanding, walk down each branch of the design tree resolving dependencies between decisions one by one, and explore the codebase instead of asking when a question can be answered that way. The design tree idea comes (he thinks) from Fred Brooks' The Design of Design. He uses it because plan mode tends to emit a plan too early; grilling forces the conversation. One session asked 16 questions; long ones run 30-50 questions over 30-45 minutes. Lesson: skills do not need to be long to be impactful.

/write-a-prd

Once a shared understanding is reached, this skill asks for a detailed description, explores the repo to verify claims, interviews the user (a copy of grill-me), sketches the major modules to build or modify, and writes the PRD from a template as a GitHub issue. Steps can be skipped if already done. The PRD has a problem statement, solution, many user stories (format not settled, Cucumber-style would work), and deliberately non-prescriptive implementation decisions so the document stays durable. It describes the destination, not the journey.

/prd-to-issues

Turns the PRD into a Kanban board of independently grabbable GitHub issues, each referencing the parent PRD. The key is vertical slices, tracer-bullet style: each issue cuts through all integration layers, and the slices that flush out unknown unknowns (new integrations) come first. Blocking relationships are set explicitly, so unblocked issues can be picked up by parallel agents, and QA issues can be added later. In the example a complex PRD became four slices, starting with an editing engine with 28 tests. His Ralph loop then picks each issue, implements it, comments, closes it and unblocks the next.

/tdd

Forces or encourages a red-green-refactor loop; this has been the most consistent improvement to agent output. It first confirms interface changes and which behaviors to test, designs interfaces for testability, then writes one failing test at a time followed by the code to pass it. Refactoring has been the weak part: LLMs are reluctant to change code still in their own context. The skill is what he prompts his Ralph loops with. Good TDD depends on a codebase with deep modules - larger modules behind thin interfaces - because test boundaries are then clear and agents navigate it more easily than a swarm of tiny undifferentiated modules.

/improve-codebase-architecture

Explore the codebase as an agent would, surfacing what is confusing (concepts spread over many small files, pure functions extracted only for testability, tightly coupled seams). Present a numbered list of deepening opportunities for shallow modules; the user picks one, then three or more subagents in parallel each design a radically different interface. The agent compares, recommends, and may propose a hybrid. Output is a refactor RFC as a GitHub issue, which then goes through /prd-to-issues. Do one candidate at a time, with a human in the loop because the decisions need taste; run it about weekly or after a surge of development. Garbage codebase in, garbage AI output out.

Course plug

Claude Code for Real Engineers, a 2-week cohort starting March 30th (40 percent off for the 7 days after the video). He notes it teaches mostly LLM constraints rather than Claude Code itself: smart zone vs dumb zone of the context window, steering, tackling massive tasks, tracer bullets, feedback loops, and hooking them to an autonomous agent.