How to Build a Real‑Project AI Coding Environment with Matt Pocock’s Skills

Why a proper engineering environment matters

Many developers start using AI to write code with the illusion that faster generation instantly doubles productivity, but real projects quickly reveal problems: misunderstood requirements, missing edge cases, regression when adding features, and loss of context across sessions. These failures are often not due to model limitations but to the absence of a structured feedback mechanism.

Matt Pocock’s answer

In March 2026 Matt Pocock open‑sourced the .claude/skills directory he uses with Claude Code under the repository mattpocock/skills. The repo is a collection of Markdown files; each skill encodes a concrete engineering practice rather than an all‑automatic AI development framework.

Skills for Real Engineers. Straight from my .claude directory.

The core idea is to turn the usual engineering steps—requirement clarification, testing, diagnosis, and code organization—into repeatable, AI‑driven commands.

Problems the skills address

1. Agent doesn’t truly understand the request

/grill-me

: for non‑code decisions, lets the agent ask clarifying questions. /grill-with-docs: for code‑related work, the agent both asks for details and records terminology in a CONTEXT.md document.

These steps may seem to slow the flow, but they calibrate the direction of all subsequent code generation. A wrong requirement early on makes later fast coding expensive to rework.

2. Agent is verbose and terminology diverges

When the team uses a term like “materialization cascade,” the agent might expand it into a long explanation, wasting tokens. By persisting the clarified terms in CONTEXT.md, the agent can reuse the shared language in later sessions, reducing token consumption and communication overhead.

3. Generated code looks correct but doesn’t work

Matt uses two skills to close this gap: /tdd: enforces a strict red‑green‑refactor loop, preferring vertical slices (one behavior → failing test → minimal implementation) over writing all tests up front. /diagnose: a debugging workflow that reproduces the bug, narrows the scope, forms hypotheses, validates them with instrumentation, and finally fixes the issue while adding regression tests.

Without a feedback loop, AI coding is like driving blindfolded.

4. Project turns into a “big mudball”

AI accelerates code writing, which also speeds up architectural decay. Matt embeds architectural awareness in several skills: /to-prd: before implementation, the agent lists affected modules. /to-issues: splits work into end‑to‑end vertical slices rather than file‑based tasks. /zoom-out: when entering an unfamiliar module, the agent first explains the code from a system‑level view. /improve-codebase-architecture: periodically scans the project to prune, deepen, or converge modules, adding ADRs where needed.

These skills keep the codebase tidy without hijacking developer control.

Installation and initial setup

Install the skills with a single command: npx skills@latest add mattpocock/skills The CLI asks which skills to install and which Agent (Claude Code, Cursor, etc.) to attach them to. For a first‑time user, the recommended core set includes: setup-matt-pocock-skills – project initialization grill-with-docs – demand clarification & documentation to-prd – turn conversation into a PRD to-issues – break PRD into vertical, testable issues tdd – red‑green‑refactor implementation diagnose – structured debugging improve-codebase-architecture – periodic architecture cleanup zoom-out – system‑level explanation of new modules git-guardrails-claude-code – Git safety guardrails

After initialization the project contains files such as CONTEXT.md, ADR documents, label dictionaries, and issue‑workflow instructions, giving the AI a persistent context similar to a well‑onboarded teammate.

Standard usage flow

The skills are meant to be chained into a realistic development pipeline rather than used as isolated prompts:

/grill-with-docs
↓
/to-prd
↓
/to-issues
↓
/tdd  or  /diagnose
↓
/zoom-out  or  /improve-codebase-architecture

This sequence embodies the classic engineering mantra: align requirements, plan, implement in small steps, verify, and then organize.

How it compares with other AI‑coding workflows

Other popular approaches include GSD, BMAD, Superpowers, and Spec‑Kit. None is universally superior; the choice depends on project stage and team needs:

GSD – focuses on long‑term task management and context continuity; good for multi‑day, multi‑file changes but adds overhead.

BMAD – emphasizes role division and formal R&D processes; suited for 0‑to‑1 product development with heavier process requirements.

Superpowers – centers on strict TDD; ideal for teams that demand high test discipline.

Spec‑Kit – drives development from specifications and requirements; fits enterprise projects with upfront design and review.

Matt Pocock Skills – flexible, lightweight, and emphasizes demand clarification, documentation, vertical slicing, testing, diagnosis, and architecture upkeep; best for ongoing, iterative projects.

Final takeaways

The real difficulty in AI‑assisted development is not the model’s ability to write code but the surrounding collaboration process: clear requirements, timely feedback, thorough testing, and recorded decisions. Matt Pocock’s Skills standardize these often‑overlooked steps, reducing chaos while still leaving critical judgment to developers.

To try the workflow, start with the installation command above, then run the core trio grill-with-docs, tdd, and diagnose on a small feature.