Matt Pocock Skills: The Engineering Framework That Turns AI Coding Agents Into Professional Developers

Why AI Coding Agents Need Engineering Discipline

The rise of AI coding agents like Claude Code, Codex, and Cursor has transformed how developers write code. But there's a problem: most developers treat these agents like magic wands, expecting perfect code from vague instructions. The result? Misaligned features, bloated codebases, and frustrated teams.

Matt Pocock—renowned TypeScript educator and developer advocate—has released his personal engineering skills repository that takes a fundamentally different approach. Instead of letting AI agents "vibe code" their way through your project, these skills enforce decades of software engineering wisdom in a format that AI agents can actually follow.

The repository has quickly gained traction on GitHub, resonating with developers who've experienced the chaos of unstructured AI-generated code. With over 10,000 stars and growing, it's becoming the gold standard for professional AI-assisted development.

Core Philosophy: Small, Composable Skills Over Rigid Frameworks

Unlike monolithic frameworks like GSD (Get Stuff Done) or BMAD that try to own your entire development process, Matt's skills follow Unix philosophy: do one thing well and compose together. Each skill is a standalone markdown file that teaches your AI agent a specific discipline.

This composability matters because every project is different. You might need test-driven development for a critical API but not for a quick prototype. With composable skills, you pick and choose what applies to your situation.

The Installation Process

Getting started takes less than a minute:

npx skills@latest add mattpocock/skills

The installer asks which skills you want and which coding agents to configure. After installation, you run /setup-matt-pocock-skills to configure:

• Your issue tracker (GitHub, Linear, or local files)
• Triage labels for ticket management
• Documentation storage location

The skills work with Claude Code, Codex, and any agent that supports the Agent Skills standard. For Claude Code specifically, there's also a plugin option that keeps skills automatically updated:

/plugin marketplace add mattpocock/skills
/plugin install mattpocock-skills@mattpocock

The Four Pillars of AI-Assisted Engineering

Matt's skills address four fundamental challenges in AI-assisted development:

1. Alignment: The Grill Sessions

The most common failure mode in software development is misalignment. You think you've communicated what you want, but the agent builds something completely different. Matt's solution: grill sessions.

The /grill-me and /grill-with-docs skills force the agent to ask detailed questions before writing any code. Think of it as a requirements interview where the agent won't proceed until every decision branch is resolved.

User: Build a user authentication system
Agent: Let me grill you on this:
- What authentication method? (JWT, sessions, OAuth?)
- Should we support 2FA?
- What's the password policy?
- How should we handle failed attempts?
- Do we need rate limiting?
[... continues until fully specified]

This upfront alignment prevents the classic scenario where you ask for "a simple login" and get back a 2,000-line authentication framework with features you never wanted.

2. Shared Language: Domain Modeling

In domain-driven design, a ubiquitous language ensures developers and domain experts speak the same terminology. Matt applies this to AI agents through the CONTEXT.md file—a living glossary that helps agents decode project-specific jargon.

Consider this example from Matt's course video manager:

• 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"

This concision compounds over time. Your agent spends fewer tokens thinking, produces more consistent code, and navigates your codebase more effectively.

3. Feedback Loops: Test-Driven Development

Even with perfect alignment, agents produce mediocre code without feedback. The /tdd skill enforces red-green-refactor: write a failing test, make it pass, then refactor.

This isn't just about code quality—it's about giving your agent consistent feedback. When the agent can run tests and see failures, it self-corrects instead of confidently producing bugs.

// The agent writes the test first
describe('UserService', () => {
  it('should reject duplicate emails', async () => {
    await userService.create({ email: 'test@example.com' });
    
    await expect(
      userService.create({ email: 'test@example.com' })
    ).rejects.toThrow('Email already exists');
  });
});

// Test fails (red), agent implements the feature, test passes (green)
// Then agent refactors while keeping tests green

The skill also includes guidance on what makes good tests—no testing implementation details, focus on behavior, keep tests fast and independent.

4. Architecture: Fighting Entropy

AI agents accelerate coding, which means they also accelerate software entropy. Codebases become complex at unprecedented rates. Matt's /improve-codebase-architecture skill runs periodic architecture reviews, scanning for opportunities to simplify and deepen your modules.

The skill generates an HTML report highlighting areas where you can:

• Extract reusable abstractions
• Reduce coupling between components
• Improve naming and organization
• Simplify complex conditionals

Matt recommends running this every few days to prevent your codebase from becoming a "big ball of mud."

Real-World Example: Building a Feature with Skills

Let's walk through building a notification system using Matt's skills:

Step 1: Grill Session
Run /grill-with-docs to align on requirements. The agent asks about notification channels (email, push, in-app), delivery guarantees, retry logic, and user preferences. After 20 minutes of questions, you have a clear spec.

Step 2: Domain Modeling
The agent updates CONTEXT.md with terms like "notification dispatch," "delivery receipt," and "preference cascade." Now you both speak the same language.

Step 3: Specification
Run /to-spec to convert the conversation into a formal spec document. This becomes your source of truth.

Step 4: Ticket Breakdown
/to-tickets breaks the spec into tracer-bullet tickets with clear dependencies:

1. Design notification schema (blocks 2, 3)
2. Implement email adapter (blocked by 1)
3. Implement push adapter (blocked by 1)
4. Build preference service (blocked by 1)
5. Integrate adapters with preference service (blocked by 2, 3, 4)

Step 5: Implementation with TDD
Run /implement to start building. The agent follows the ticket order, writing tests first for each component. You review each slice before moving on.

Step 6: Code Review
/code-review runs two parallel reviews: one checks coding standards and code smells, the other verifies the implementation matches the spec. Both must pass before committing.

The result? A well-designed, thoroughly tested notification system built in a fraction of the time—without the usual AI-generated code chaos.

Key Benefits

• Professional-grade output: Enforces engineering disciplines that separate hobby code from production code
• Reduced rework: Grill sessions catch misunderstandings before code is written, not after
• Consistent codebases: Shared language and architecture reviews prevent the "big ball of mud" problem
• Better tests: TDD discipline produces code that's actually testable and well-tested
• Model-agnostic: Works with Claude Code, Codex, Cursor, and any Agent Skills-compatible tool
• Composable: Use only the skills you need; mix and match for different projects
• Continuously updated: Plugin option keeps skills current as best practices evolve
• Battle-tested: Based on Matt Pocock's decades of engineering experience

Advanced Workflows

Beyond the core skills, the repository includes advanced workflows for complex scenarios:

Wayfinder: Multi-Session Planning

Some features are too large for a single agent session. The /wayfinder skill breaks massive work into investigation tickets on your issue tracker. Each session resolves one ticket, gradually clarifying the path to completion.

Triage: Issue State Machine

The /triage skill moves issues through a structured workflow: incoming → investigating → blocked → ready → in-progress → review → done. Each transition has specific criteria, preventing issues from languishing in vague states.

Handoff: Context Preservation

When you need to switch agents or continue work tomorrow, /handoff compacts the conversation into a comprehensive document. The next agent picks up exactly where you left off, with full context preserved.

FAQ

Q: Do these skills work with all AI coding agents?

A: They work with any agent that supports the Agent Skills standard, including Claude Code, Codex, and Cursor. The skills are markdown files, so even agents without native support can read and follow them.

Q: Will these skills slow down my development?

A: Initially, yes—grill sessions and TDD take time. But they prevent rework. Matt reports that disciplined AI development is 3-5x faster overall because you avoid the "rewrite it three times" cycle.

Q: Can I customize the skills for my team?

A: Absolutely. The skills.sh installer copies files into your repo so you can edit them. Add your team's coding standards, preferred libraries, or company-specific practices.

Q: What's the difference between skills.sh and the plugin?

A: skills.sh copies editable files into your repo—you maintain and customize them. The plugin installs a read-only bundle that auto-updates when Matt ships new versions. Choose based on whether you want control or convenience.

Q: Do I need to use all the skills?

A: No. Start with /grill-me and /tdd—these address the two biggest failure modes. Add other skills as needed. The /ask-matt skill helps you find the right skill for your situation.

Q: How do these compare to frameworks like GSD or BMAD?

A: Those frameworks try to own your entire process. Matt's skills are composable—you pick what you need. They also focus on engineering fundamentals rather than project management ceremony.

Q: Will this work for non-TypeScript projects?

A: Yes. While Matt is known for TypeScript expertise, the skills are language-agnostic. They enforce engineering principles that apply to any codebase—Python, Go, Rust, Java, you name it.

Q: How often should I run architecture reviews?

A: Matt recommends every few days for active projects. For slower-moving codebases, weekly or bi-weekly works. The key is preventing entropy from accumulating.