mattpocock

Plans often fail because hidden assumptions go unchallenged. This skill makes the AI relentlessly interview you about every aspect of your design, surfacing gaps and resolving dependencies one question at a time.

Software projects suffer when teams use inconsistent terminology or lose track of why decisions were made. This skill helps you actively build and sharpen your domain model by challenging terms, inventing edge cases, and capturing decisions in CONTEXT.md and ADRs.

Writing a full article from raw material is overwhelming. This skill breaks the process into discrete beats, letting you collaborate one move at a time until the narrative finds its natural end.

Writers often sit on piles of fragmented notes without knowing how to begin an article. This skill runs a conversational shaping session that drafts candidate openings, grows the piece paragraph by paragraph, and argues about format choices until the article is done.

Writers often know they have material for an article but cannot yet structure it. This skill runs a relentless interview, pulls heterogeneous fragments from both sides of the conversation, and appends them to a single markdown file you control — giving you a growing pile of raw material to mine later.

Navigating unfamiliar codebases is disorienting and time-consuming. This skill helps Claude, Codex, and Claude Code provide a structured overview of code architecture using your project's domain vocabulary, reducing context-switching time.

Creating agent skills from scratch is difficult without proper structure. This skill provides templates, workflows, and best practices so you can build reusable skills with clear descriptions, proper file organization, and progressive disclosure.

Domain discussions often mix synonyms and overloaded terms that cause confusion. This skill scans conversations to identify domain terms, flag ambiguities, and write a canonical glossary to UBIQUITOUS_LANGUAGE.md.

Managing incoming issues without a structured workflow leads to bottlenecks and missed priorities. This skill provides a state machine-driven triage system that categorizes issues as bugs or enhancements and routes them through defined states from needs-triage to ready-for-agent or wontfix.

Writing PRDs manually takes hours of back-and-forth with stakeholders. This skill synthesizes your existing conversation context into a structured, publication-ready PRD and publishes it directly to your issue tracker.

Converting long plans or specs into issues can be time-consuming and inconsistent. This skill breaks any plan into independently-grabbable vertical slice issues that are ready for implementation.

Learning a new topic is hard when knowledge is scattered and progress is invisible. This skill creates a stateful teaching workspace that grounds every lesson in your mission and tracks what you have learned.

Writing tests after code creates fragile systems that break on refactors. This skill guides you through test-driven development where tests define behavior before implementation, resulting in cleaner code and reliable refactoring.

Setting up pre-commit hooks manually involves multiple configuration files and package installations. This skill automates the entire process, giving you Husky, lint-staged, and Prettier working in minutes.

This skill configures your repository with the issue tracker, triage labels, and domain docs settings that Matt Pocock's engineering skills need to work correctly. Run once before using any of the related engineering skills.

Creating exercise directory structures for courses is repetitive and error-prone. This skill automates scaffolding sections, problems, solutions, and explainers that pass linting on the first try.

Reviewing a branch by eye misses half the picture — code can pass the style guide and still implement the wrong thing. This skill runs Standards and Spec reviews in parallel sub-agents and reports them side by side so neither axis can mask the other.

Refactors often fail because they are too large and poorly scoped. This skill drives a structured interview to produce a clear, incremental refactor plan filed as a GitHub issue.

Bug reports get lost or lack context when filed manually. This skill turns conversational QA sessions into durable, well-structured GitHub issues using your project's domain language.

Design decisions made on paper often fail when implemented. This skill helps you build quick throwaway prototypes that answer specific questions about logic or UI before committing to code.

Managing a large Obsidian vault with hundreds of notes becomes hard without consistent structure. This skill teaches Claude and Codex the naming, linking, and search conventions to keep your vault organized and discoverable.

TypeScript tests often use unsafe `as` assertions to fake large objects. This skill migrates them to type-safe shoehorn helpers, keeping autocomplete and type checking working.

Codebases accumulate shallow modules that are hard to test and navigate. This skill finds deepening opportunities by analyzing module depth and seams, then guides you through refactoring decisions to make your architecture more maintainable.

Developers lose valuable context every time they start a new AI coding session. This skill generates a compact handoff document that summarizes the current conversation, key artifacts, and next steps so a fresh agent can pick up the work immediately.