Matt Pocock's Engineering Skills
Complete workflow system for shipping code, from idea through deployment
What You Can Do
This is a comprehensive engineering workflow system designed to guide you from an initial idea all the way to shipped code. It includes a main flow (idea → grill → spec → tickets → implement → review → ship), specialized skills for handling bugs, triage, and large architectural challenges, and foundational vocabulary skills for domain modeling and codebase design. Each skill works independently or as part of the larger workflow, giving you flexibility to adapt to your project's needs.
Features
Guided path from initial concept through grilling, spec writing, ticketing, implementation with TDD, and code review
Entry point that identifies which skill fits your current situation and when to branch or merge flows
Structured approach to intermittent bugs and regressions using tight feedback loops and minimal reproduction cases
Parallel review of Standards (project conventions) and Spec (requirements) to catch issues one axis might miss
Vocabulary and principles for designing modules with large behavior behind small interfaces and clean seams
Process for moving incoming bugs and feature requests through triage roles into agent-ready work
Clear decision tree for when to continue, clear context, handoff, spawn subagents, or compact context
Design-question answering through throwaway code that feeds into real implementations and architecture
Example Output
Routing to the right skill
Which skill should I use? I have an intermittent bug that fails every few hours.
The ask-matt skill identifies that diagnosing-bugs is the right tool, explains why, and guides you to build a tight feedback loop (failing test, curl script, or minimal harness) that reliably reproduces the bug before investigation begins.
Code review on two axes
Review my changes since main. I implemented the search feature from issue #42.
The code-review skill runs Standards and Spec reviews in parallel, then reports both findings side-by-side so you see exactly where code follows project conventions and where it matches (or diverges from) the original requirement.
Starting large architectural work
I need to redesign the data layer. It's become a bottleneck and I'm not sure where to start.
You begin with grill-with-docs to sharpen the problem, explore alternatives using codebase-design or improve-codebase-architecture, prototype solutions with diagrams and throwaway code, then hand back to the main flow to spec and ticket the work.
What's Included
- ask-matt: Entry point router that helps you identify which skill fits any situation
- Complete idea-to-ship workflow: grill-with-docs, to-spec, to-tickets, implement (with TDD), code-review, and handoff tools
- Bug diagnosis system: diagnosing-bugs skill with structured approach to hard bugs, regressions, and performance issues
- Design vocabulary and principles: codebase-design and domain-modeling skills for shared language around modules, interfaces, seams, and domains
- Triage and issue management: Process for moving incoming bugs and feature requests into agent-ready work items
- Supporting skills: Prototype, research, teach, resolving-merge-conflicts, to-questionnaire, and phase-boundary decision trees
Who It's For
- Software engineers and architects
- Engineering leads managing complex projects
- Teams building multi-session features with Claude
- Developers focused on code quality and standards
- Engineers diagnosing hard bugs and regressions
Best For
- Feature development workflows
- Debugging intermittent or hard-to-reproduce bugs
- Code review and standards enforcement
- Architecture and module design
- Managing large, multi-phase projects
