Overview
In February 2026, Matt Pocock pushed his .claude directory to GitHub with a one-line README: "My agent skills that I use every day to do real engineering — not vibe coding." Three months later, the repository — roughly twenty Markdown files containing no executable code — had earned nearly 20,000 stars, and 60,000 developers subscribed to his newsletter.
Who Is Matt Pocock?
- Holds a master's in voice and performance from the Guildford School of Acting; worked six years as a vocal coach teaching singing, public speaking, and accent training.
- Started JavaScript in 2017, became a full-time developer in 2018, rose from Junior to Lead, joined the XState core team at Stately, then worked as a Developer Advocate at Vercel.
- Left in 2022 to teach full-time: Total TypeScript sold to tens of thousands of students; his AI Hero newsletter reaches 60,000 readers.
- 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"*
- Tests describe behavior, not implementation
- Tests use only public interfaces
- Tests survive internal refactoring
- Code is the minimal implementation for this test
- No speculative features
- Timing: Early 2026, developers hit the vibe-coding backlash — code runs, but commit history and architecture are a mess. They needed a map "from demo to engineering."
- Authority: A working engineer (Vercel, Stately, XState core), not an influencer theorist.
- Philosophy (deepest layer): The skills don't teach AI to write better code — they teach human engineers to preserve engineering discipline while using AI:
/grill-me: decision authority stays with humans/tdd: humans confirm test design/to-issues: humans adjust task prioritiesgit-guardrails: dangerous operations require human approval- GitHub: https://github.com/mattpocock/skills
- Personal site: https://www.mattpocock.com/
- Total TypeScript: https://www.totaltypescript.com/
- AI Hero: https://www.aihero.dev/
- Reactiflux interview: https://www.reactiflux.com/transcripts/matt-pocock_mapleleaf
- Dev.to analysis: https://dev.to/wonderlab/one-open-source-project-a-day-no50-the-typescript-wizard-pushed-his-claude-directory-to-github-41jj
- ExplainX guide: https://explainx.ai/blog/matt-pocock-agent-skills-real-engineers
- Tosea.ai guide: https://tosea.ai/blog/matt-pocock-skills-claude-code-guide
He credits vocal coaching for two things: the ability to explain clearly, and sensitivity to *method* — his preferred Estill approach emphasizes anatomy and muscle control over vague metaphors.
How Claude Code Skills Work
Claude Code, Anthropic's command-line agent, starts each conversation from zero — unaware of team conventions, testing habits, or git safety rules. The skills mechanism fixes this: place SKILL.md files in a .claude/ folder at the project root, each describing a scenario's goals, steps, constraints, and output format. Trigger them with a slash command (e.g. /tdd).
Four Keys Against Four Failure Modes
1. /grill-me — AI didn't build what you wanted
Ambiguous requirements are the top cause of engineering failure. /grill-me makes Claude act like a senior product manager, asking 30–50 questions until every branch of the design decision tree is walked through. In one real session, Claude asked sixteen questions over thirty minutes — clarifying requirements before any code was written. "This isn't prompt engineering, it's automated requirements engineering."
2. /grill-with-docs — AI is too verbose
Builds a ubiquitous domain language recorded in CONTEXT.md. Example compression:
Twenty-eight words to six. The shared vocabulary unifies variable names, function names, and file names, improving navigation and cutting token consumption.
3. /tdd — Code doesn't work
Forces a red-green-refactor loop with a vertical slice discipline (one behavior end-to-end at a time, never ten tests then ten implementations). Each cycle follows a five-item checklist:
> "Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't."
The goal isn't a smarter AI — it's an AI that doesn't dare run wild: humans confirm interface design and test priorities before generation begins.
4. /improve-codebase-architecture — Code becomes a mud ball
Weekly, Claude scans the codebase, identifies tightly coupled modules, proposes extract/hide/deepen refactors, and outputs an Architecture Decision Record (ADR). It directly maps John Ousterhout's *A Philosophy of Software Design*: deep modules with small interfaces that hide complexity — countering AI's tendency to leak implementation details into APIs.
The Controversies
1. "Isn't this just prompt engineering?" Pocock's answer: these are encodings of *process*, each corresponding to a real engineering phase and backed by four classic books. 2. "Is Anthropic quietly promoting this?" Unverifiable — but his 60k newsletter subscribers, ~100k Twitter followers, and ~100k YouTube subscribers explain most of the spread. 3. "Is vibe coding really wrong?" Pocock's stance never wavered: "real engineering, not vibe coding." His implicit boundary: once code must be maintained beyond three days, discipline must enter.
Why Seven Lines of Markdown Won
Unlike frameworks such as GSD, BMAD, or Spec-Kit that hand the whole process to AI, Pocock's choice is the opposite: AI is the tool; the engineer is the protagonist.
The Four Books Behind the Skills
| Classic | Core Idea | Skills |
|---|---|---|
| The Pragmatic Programmer | No broken windows, small steps, feedback loops | /tdd, /diagnose, /to-issues |
| Domain-Driven Design | Ubiquitous language, bounded contexts | /grill-with-docs, CONTEXT.md |
| Extreme Programming Explained | Invest in system design daily | /improve-codebase-architecture |
| A Philosophy of Software Design | Deep modules (small interface, deep implementation) | /improve-codebase-architecture |
Pocock invented no new philosophy — he encoded twenty years of engineering consensus into processes an AI can execute.
Epilogue
The skills are an old-methods container for a new tool. Developers voted with stars not for novelty, but for a long-missed sense of engineering discipline. In an era when AI can write code, the hard part is no longer writing code — it's upholding the rules that make code sustainable.