Matt Pocock's agent skills for real engineers: TDD, planning, and production-grade workflows
Matt Pocock's mattpocock/skills has 135,000+ GitHub stars and v1.0.1 (June 2026). User-invoked orchestrators (/grill-me, /ask-matt) and model-invoked discipline (/tdd, /codebase-design, /domain-modeling) for production engineering—not vibe coding.
mattpocock/skills is Matt Pocock's public agent skills library—workflows he uses daily for real engineering, not vibe coding. The repository has attracted 135,000+ GitHub stars and 11,700+ forks (June 2026), making it the most visible skill collection in the agent ecosystem. Matt Pocock built Total TypeScript, is a former Vercel and Stately engineer, and runs a newsletter with ~60,000 subscribers.
Version 1.0.1 shipped June 17, 2026 with progressive disclosure, shared design skills, and a formal user-invoked vs model-invoked taxonomy. See our v1.0 deep dive for token economics and spec debates.
This explainx.ai article is a map, not a replacement for upstream docs. github.com/mattpocock/skills is canonical. MIT license, no paywall.
explainx.ai also hosts a discoverable skills registry at /skills—ranked listings from many authors with copy-ready install commands. Use Matt's repo for engineering discipline; browse /skills for domain-specific skills (SEO, MCP, analytics, and more).
Skills for real engineers. Straight from my .claude directory.
Pocock built these to fix failure modes in Claude Code, Codex, and Cursor—not to replace your judgment with a heavyweight process framework. He explicitly contrasts his approach with GSD, BMAD, and Spec-Kit: those tools own the process, which can hide bugs in the process itself and take control away from you.
These skills are small, easy to adapt, and composable. They work with any model. Hack around with them; make them your own.
Four failure modes (and the skill that fixes each)
The README organizes the entire library around four problems every AI-assisted team hits:
#1: The agent didn't do what I want
Problem: Misalignment—the same gap between "what I meant" and "what got built" that The Pragmatic Programmer calls the core software failure mode.
Fix: A grilling session—force the agent to ask detailed questions before work starts.
Skill
Invocation
Role
/grill-me
User
Relentless interview until every decision branch is resolved
/grill-with-docs
User
Same loop + builds domain model, updates CONTEXT.md and ADRs inline
grilling
Model
Reusable interview loop behind the two grill skills
Use /grill-me or /grill-with-docs every time you make a change.
#2: The agent is way too verbose
Problem: Agents drop into projects cold and use 20 words where one domain term would do—Eric Evans' ubiquitous language problem applied to LLMs.
Fix: A shared language document. Example from Pocock's course-video-manager repo:
Before: "There's a problem when a lesson inside a section of a course is made 'real' (i.e. given a spot in the file system)"
After: "There's a problem with the materialization cascade"
/grill-with-docs and the model-invoked domain-modeling skill build and maintain this vocabulary in CONTEXT.md. Side effects: consistent naming, easier agent navigation, fewer tokens spent thinking.
#3: The code doesn't work
Problem: Alignment without feedback loops = flying blind.
Fix: Static types, browser access, automated tests. For tests, red-green-refactor is non-negotiable.
Deep modules + domain language — /codebase-design and /domain-modeling keep architecture and vocabulary aligned
This stands in contrast to "generate a feature and hope it works" workflows common in demo-focused agent usage.
How /tdd works (red-green-refactor)
The /tdd skill is the most referenced in Matt Pocock's public posts. The pattern:
Red — Write a failing test that describes the desired behavior.
Green — Write the minimum code to make the test pass.
Refactor — Clean up the implementation while keeping tests green.
Repeat — Build the feature one vertical slice at a time.
Per the skill description: "Builds features or fixes bugs one vertical slice at a time." This prevents over-engineering and ensures every line of code is verified.
Example workflow:
User: "Add validation to the login form"
Agent with /tdd: "I'll write a test for invalid email first, then implement validation to make it pass."
Install:
bash
npx skills@latest add mattpocock/skills/tdd
How /to-prd and /to-issues chain together
A common pattern in the repository is chaining skills:
Conversation — Discuss a feature or problem with the agent.
/to-prd — Synthesize the conversation into a Product Requirements Document and file as a GitHub issue. No interview needed—it just summarizes what you already discussed.
/to-issues — Break the PRD into independently-grabbable GitHub issues using vertical slices (end-to-end functionality, not layers).
Matt Pocock's architecture workflow in v1.0 is layered:
/grill-with-docs or domain-modeling — build ubiquitous language in CONTEXT.md and ADRs
codebase-design — deep modules, seams, adapters (Ousterhout vocabulary)
/improve-codebase-architecture — scan codebase, HTML report, pick one deepening to grill through
Example: If your codebase has processOrder() but the business talks about "fulfillment workflows," domain-modeling flags the mismatch and suggests refactoring toward business language—then codebase-design guides where to put the new interface.
The /prototype skill (v1.0, replaces design-an-interface) builds throwaway prototypes to flesh out a design:
Terminal app — when the question is state or business logic
Multiple UI variations — radically different approaches toggleable from one route
Use it before committing to an implementation path—same "compare alternatives early" goal as the old design skill, with less sub-agent overhead.
bash
npx skills@latest add mattpocock/skills/prototype
Writing skills: /writing-great-skills
Meta-skill for skill authors. Replaced write-a-skill in v1.0 with writing-great-skills plus a GLOSSARY.md—vocabulary and principles for predictable skills, hunting no-ops down to the sentence level.
25,500+ → 135,000+ GitHub stars on mattpocock/skills (June 2026).
His expertise centers on TypeScript, developer education, and production engineering practices. The skills repository is a public release of the workflows he uses to ship code and teach at scale.
How this fits the explainx.ai view of agent skills
The mattpocock/skills repository is a monorepo of opinionated workflows from a single author. explainx.ai hosts discoverable skills at /skills—a ranked directory from many authors, tagged by domain, with install commands you can copy without hunting GitHub READMEs.
The underlying pattern is the same: structured, reusable agent instructions. Many teams use both:
mattpocock/skills for TDD, planning, and git safety
/skills for domain skills—marketing, security, MCP builders, analytics integrations, and more
All three are complementary: use mattpocock/skills for engineering rigor, gstack for sprint cadence, and /skills to discover domain-specific skills from the broader community.
Privacy and open source
Per the repository:
MIT license — Fully open source.
No telemetry — Skills are local instruction files, not SaaS.
No paywall — All skills free to use and modify.
This contrasts with some agent skill marketplaces that require accounts or usage fees.
mattpocock/skills is Matt Pocock's MIT-licensed library for real engineering: four failure modes, user-invoked orchestrators and model-invoked discipline, 135K+ GitHub stars, v1.0.1 with progressive disclosure.
Start with /setup-matt-pocock-skills, then /grill-me, /tdd, and /git-guardrails-claude-code. Scale with /improve-codebase-architecture, domain-modeling, and codebase-design.
