@mattpocock

structured methodology for isolating bugs through deterministic feedback loops, hypothesis ranking, and minimal instrumentation. emphasizes loop quality over code staring, with explicit phases for reproduction, testing, and cleanup.

writing-great-skills teaches skill metadata design, invocation strategies, and description patterns to maximize agent determinism while minimizing context load.

caveman activates on explicit trigger to compress responses ~75% by stripping filler and conjunctions while preserving technical accuracy and security clarity. mode persists across turns until user requests revert.

setup-pre-commit configures husky hooks with lint-staged (prettier), type checking, and tests. detects package manager, installs dependencies, initializes husky, and creates hook and config files with sensible defaults.

codebase-design provides shared vocabulary and principles for building deep modules - placing substantial behavior behind minimal interfaces at clean seams. establishes precise terminology to align designers and reviewers on module structure, depth, and testability.

setup-ts-deep-modules configures dependency-cruiser to enforce deep module boundaries in typescript packages, hiding implementation folders behind root-level entry points and validating the architectural constraint.

to-issues decomposes product plans into independently-deliverable vertical slices and publishes them as tracker issues, with explicit dependency wiring and user-driven iteration before publishing.

wizard generates interactive bash scripts that guide humans through tedious manual procedures (third-party setup, migrations, state transitions) with progress tracking, confirmations, and automated credential storage.

tdd enforces behavior-driven testing through vertical slices and public-api assertions, rejecting implementation-coupled tests and horizontal batch workflows in favor of incremental red-green-refactor cycles.

to-questionnaire converts a gap in knowledge into a structured markdown questionnaire. it interviews the user about recipient context and unmet decisions, then generates questions targeting the information deficit.

claude-handoff launches a background agent with a handoff summary of the current conversation, allowing work to continue asynchronously. the agent inherits context via a seeded prompt and operates in the same working directory.

ubiquitous-language extracts domain terminology from conversation, identifies ambiguities and synonyms, and writes a structured glossary file with definitions, relationships, and example dialogues to formalize domain language.

improve-codebase-architecture surfaces architectural friction by exploring codebases for shallow modules and tight coupling, then generates competing refactor designs based on deep module principles, recommending the strongest approach as a documented rfc.

grill-with-docs runs relentless design interrogation that stress-tests plans against domain models, grounds discussions in codebase artifacts, and produces focused documentation (ADRs, glossary updates) only when decisions crystallize.

handoff creates structured conversation summaries for agent-to-agent continuity, redacts sensitive data, suggests relevant skills, and avoids duplicating existing artifacts by referencing them instead.

qa guides users through conversational bug reporting, explores relevant code sections in parallel, and translates findings into github issues using domain language. incomplete spec.

loop-me conducts structured grilling sessions to extract workflow specifications from users by asking targeted questions about recurring patterns (loops) in their work and life, guiding them toward clear, delegatable automation specs.

write-a-prd guides users through interview, codebase exploration, and module design to produce a structured product requirements document submitted as a github issue.

wayfinder structures big nebulous problems into a tracked map of investigation tickets, then resolves them iteratively until the path forward clarifies. domain-agnostic, git-tracked, compact.

domain-modeling covers the active discipline of building and refining a project's domain model through decision-making and glossary work. establishes file structure conventions for context documentation and architectural records.

review compares code changes against standards and specification compliance using parallel sub-agents, requiring user-supplied fixed points and validated git refs before proceeding.

writing-beats guides iterative article composition via beat selection and preview loops, letting users build narrative arcs from raw material one move at a time.

obsidian-vault provides mechanics for searching, creating, and linking notes within a flat vault structure using wikilinks and index aggregation. covers basic grep workflows but lacks decision logic and failure handling.

batch-grill-me conducts structured decision-tree interviews across frontier questions, advancing rounds as prerequisites settle, stopping only when all branches are explored and understanding is confirmed.

triage moves issues and external prs through a state machine with two category roles (bug, enhancement) and five state roles (needs-triage, needs-info, ready-for-agent, ready-for-human, wontfix), generating agent briefs and respecting prior context from adrs and out-of-scope knowledge bases.

resolving-merge-conflicts covers understanding conflict origins through git history and commit metadata, then systematically resolving hunks while preserving intent and running project checks before completion.

to-tickets converts plans or specs into independent, deployable tickets with explicit blockers and acceptance criteria, published to a tracker and linked back to the source conversation.

teach enables multi-session learning by organizing workspace state into missions, lessons, reference materials, and learning records to scaffold progressive skill acquisition.

to-prd synthesizes conversation and codebase context into a structured product requirements document, then publishes it to the project tracker with appropriate triage labels.

configures per-repo scaffolding for matt pocock engineering skills by establishing issue tracker location, triage label vocabulary, and domain docs layout through interactive exploration and user confirmation.

research initiates a background agent to investigate questions against primary sources and write findings to markdown with citations, allowing continued work during execution.

edit-article provides a framework for restructuring articles by mapping information dependencies and rewriting sections for clarity, but lacks concrete decision criteria and failure handling.

Conduct a retrospective on a coding session.

Implement a specification in code.

Turn a loose idea into a sequenced map of investigation tickets, then drive them to resolution one at a time.

Stop. That last message did not land: re-pitch it.

Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.

Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue. Use when user wants to plan a refactor, create a…

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface…

Tell the agent to zoom out and give broader context or a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how…

Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill.

Migrate test files from `as` type assertions to @total-typescript/shoehorn. Use when user mentions shoehorn, wants to replace `as` in tests, or needs partial…

Writing, explore: mine raw fragments, no structure yet.

Writing, exploit: shape raw material into an article, paragraph by paragraph.

Create exercise directory structures with sections, problems, solutions, and explainers that pass linting. Use when user wants to scaffold exercises, create…

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent…

Turn the current conversation into a spec and publish it to the project issue tracker: no interview, just synthesis of what you've already discussed.

Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes: Standards (does the code follow this repo's documented coding…

Implement a piece of work based on a spec or set of tickets.

Ask which skill or flow fits your situation. A router over the skills in this repo.

Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.

Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a…

A relentless interview to sharpen a plan or design.

Triage GitHub issues through a label-based state machine. Use when user wants to create an issue, triage issues, review incoming bugs or feature requests,…

Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to…

Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local Markdown file in ./plans/. Use when user wants to break…

prd-to-issues — an installable skill for AI agents, published by mattpocock/skills.