Matt Pocock Skills: Make AI programming work like a real engineer

Matt Pocock's Skills project is an engineering skill library designed for AI coding assistants (e.g., Claude Code). By modularizing standard software development workflows, it addresses the core pain point of unstable AI-generated code quality. This project, built with just a few Markdown files, has earned 23,000 stars on GitHub, becoming a pivotal practice in AI-assisted development.

Project Background: The Four Failure Modes of AI Programming

Traditional AI development tools tend to rely on "a single intelligent Agent handling everything," but Matt Pocock adopted an entirely opposite approach: first identifying the patterns of AI's actual failures, then designing corresponding skills for each failure mode. The project defines four typical failure scenarios:

1. Agent didn't do what I want (AI didn't understand your intent): A cognitive gap between developers and AI leads to outputs deviating from expectations

2. Agent is way too verbose (Output is overly verbose): AI generates excessive irrelevant code or documentation

3. The code doesn't work (Code fails to execute): Lack of test feedback results in unstable code quality

4. We built a ball of mud (Architecture becomes a "spaghetti code" mess): Long-term iteration causes loss of clear structure in the codebase

This design philosophy rejects the optimistic assumption that "a sufficiently intelligent AI can solve everything," instead compensating for AI's uncertainty through structured workflows.

Core Philosophy: Standardized Processes and Modular Skills

The value of the Skills project lies in decomposing the experience of "using AI for requirement analysis, design, and coding" into reusable skill plugins. This ensures AI works according to reliable, fixed workflows rather than relying on luck. Each skill is a complete "work script," containing YAML-formatted metadata (name, description, trigger conditions) and specific execution steps.

The project's composability is another key feature: the output of one skill can serve as the input for another. For example, write-a-prd generates a PRD document in a GitHub issue, which prd-to-issues then breaks down into implementation plans. This enables teams to create custom workflows by chaining skills.

Five Core Skills Form a Complete Workflow Chain

1. grill-me: Requirement Clarification Phase

This 11-line skill makes AI act like an interviewer, asking questions one at a time to ensure consensus on requirements. Key features include:

• Asking only one question at a time to avoid information overload

• Providing suggested answers for confirmation rather than just asking questions

• Skipping questions that can be answered automatically from the codebase

Developers report being asked 16 questions using this skill, with complex features requiring 30–50 questions in deep interviews. This skill addresses Claude Code's tendency to generate solutions prematurely, enforcing thorough pre-communication.

2. to-prd: Generate Product Requirements Document (PRD)

Creates a formal PRD based on conversation history, including problem description, solution, user stories, implementation decisions, testing decisions, and what not to do. The document is automatically saved as a GitHub issue using the gh command.

3. to-issues: Task Decomposition via Vertical Slicing

Breaks down the PRD into independent executable tasks using the "tracer-bullet" methodology (vertical slicing) rather than traditional front-end/back-end or module division. Each slice spans from the database to the interface to testing, clearly marking whether human intervention is needed. Tasks are ordered by dependencies, with subsequent tasks waiting for prior tasks to complete.

4. tdd: Test-Driven Development

Enforces strict test-driven development workflows, disallowing implementation code until failing tests exist. This ensures stable code quality, suitable for projects with existing testing cultures.

5. improve-codebase-architecture: Architecture Optimization

Identifies "deepening opportunities" in the codebase based on domain language in CONTEXT.md and architecture decision records (ADR) in docs/adr/. Applies John Ousterhout's "deep module" principle (small interfaces hiding large implementations), improving testability and AI navigability. The skill identifies shallow modules, tightly coupled components, and untested boundaries, proposing refactoring suggestions.

Installation and Usage

The command format for installing a single skill is:

npx skills add mattpocock/skills skill=grill-me -y -g

Skills uses a standardized structure, supporting scoped package names (mattpocock/skills) and version tags. After installation, it can be called by AI assistants that support the skills protocol.

Other Useful Skills

Beyond the core workflow, the project includes several auxiliary skills:

• triage: Issue state machine management, suitable for tag and priority allocation in team collaboration scenarios

• zoom-out: When stuck in local details, helps reassess the code's position within the overall architecture

• write-a-skill: Guides users through the complete process of creating custom skills, including trigger conditions, execution steps, and output specifications

• diagnose: Diagnoses unrunnable code, used in conjunction with TDD skills

Limitations and Development

The current version's main limitation is its deep integration with GitHub: skills involving issue operations are hard-coded with the gh command. Teams using Linear, Jira, or other project management tools need to fork and modify the code, though official support for other platforms is under development (as of April 2026).

Matt Pocock updated the skill set in April 2026, replacing /grill-me with /domain-model and integrating Domain-Driven Design (DDD) concepts, generating documentation and ADRs during discussions. This demonstrates the project's continuous evolution, gradually incorporating more software engineering best practices.

Applicable Scenarios

This skill library is particularly suitable for developers who:

• Are already using AI coding tools like Claude Code or Cursor but feel "AI can write code but not do engineering"

• Want to establish stable AI-assisted development workflows rather than relying on luck

• Need to elevate AI-generated code quality to production level

• Require standardized AI usage practices in team collaboration

As one developer noted after removing most bloated skills: Matt Pocock's skill set embodies minimalism—small, precise primitives with clear naming, less surface area but greater leverage effect.

Conclusion

Matt Pocock Skills is not simply about "letting AI generate code randomly," but about aligning AI programming with real engineers' workflows through requirement clarification, TDD, diagnostics, task decomposition, and architecture optimization. It emphasizes: structured processes, feedback loops, decomposition, and retrospectives in engineering development, not just "Vibe Coding" based on intuition. This is exactly what the AI-assisted development field most needs—not smarter AI, but better workflows.