Matt Pocock

Asks relentless follow-ups on your design, strategy, or roadmap — one branch at a time — until you've thought through the gaps and can defend every trade-off.

Walks through your plan line-by-line, flags where it conflicts with your domain model or past decisions in CONTEXT.md and ADRs, and updates those docs as the gaps resolve.

Reads your codebase, architecture-decision records, and domain language docs, then surfaces tightly-coupled modules, testability gaps, and consolidation opportunities with a priority order.

Writes a failing test that captures the requirement, then builds the minimal code to pass it, then refactors for clarity. Keeps you from gold-plating.

Adds a one-time config block to your AGENTS.md pointing Claude skills at your issue tracker, labels, and docs structure — so triage and issue-creation skills know where to write.

Reads a bug report or feature request and assigns it to the right team—security, backend, product—with severity and context. Prevents issues from getting stuck in a backlog.

Distills the current chat thread into a tight handoff document—decisions made, open questions, context—so the next Claude instance starts without backlog.

Takes the discussion you just had and molds it into a structured PRD with success criteria, scope, and open questions — then posts it straight to your issue tracker.

Scaffolds a minimal web app with toggleable UI variations or state logic, so you can click through a design before writing the real thing. No build step needed.

Takes a spec or roadmap item and carves it into vertical slices — each one small enough for one person to finish, each one shippable on its own.

Takes a topic you're unfamiliar with and breaks it into digestible lessons with examples, exercises, and checkpoints — all tailored to your level and learning pace.

Takes a bug report and runs a structured loop: reproduce it, strip it to the minimum case, form a hypothesis, add instrumentation, then fix and regression-test.

Turns a repetitive workflow into a properly formatted SKILL.md with triggers, instructions, and bundled resources—ready to publish or share with your team.

Takes a snippet or function you're confused by and explains its role in the larger system—what calls it, what it depends on, why it matters.

Strips articles, filler, and pleasantries while keeping technical accuracy and meaning intact. Useful when you're paying by token or need to fit an answer into a tight space.

Interview the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any 'grill' trigger phrases.

Build and sharpen a project's domain model. Use when the user wants to pin down domain terminology or a ubiquitous language, record an architectural decision, or when another skill needs to maintain the domain model.

Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

Reference for writing and editing skills well — the vocabulary and principles that make a skill predictable.

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

Generates 3–5 radically different interface designs for the same module—different method names, parameter shapes, trade-offs—so you can spot the best tradeoff without lengthy debate.

Implement a piece of work based on a PRD or set of issues.

Asks you about the mess, then writes a step-by-step refactor plan with granular commits that can each be reviewed and reverted independently. Files it straight to GitHub.

Extracts the jargon and ambiguous terms from your conversation and produces a UBIQUITOUS_LANGUAGE.md—a shared glossary that keeps your team saying the same thing about the domain.

Chat about a bug like you're talking to a colleague. The skill extracts the repro steps, severity, and context from your description, then files a formatted issue in GitHub with relevant codebase pointers.

Sets up git hooks that block Claude from running destructive commands like force-push or hard-reset until you approve them—adds a safety layer for high-stakes repos.

Finds notes by meaning or keyword, creates new linked notes, and refactors your vault structure — maintaining wikilinks and index relationships as it goes.

Restructures sections for flow, cuts redundancy, sharpens unclear passages, and tightens prose — returning a marked-up version showing every edit with a reason.

Installs Husky and configures pre-commit hooks to auto-format, type-check, and test every commit—all in your repo, no external service needed.

Generates a folder tree with exercise stubs, solution code, and explainer markdown—structured to pass linting and ready for your students or team to fill in.

Loads a markdown dump of notes and walks you through building an article piece by piece: testing opening angles, growing sections in dialogue, choosing callouts and quotes that land.

Asks you probing questions about a topic, collects your scattered claims and anecdotes, then appends them to a growing document — messy raw material ready to shape into an article later.

Finds all the `as` type assertions in your test suite and replaces them with @total-typescript/shoehorn, making partial test data type-safe and maintainable.

Organizes raw notes into narrative waypoints, then writes one beat at a time. You steer the arc by picking which direction to go next—like branching dialogue in a game.

Use when you need to resolve an in-progress git merge/rebase conflict.

Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo. Use when the user wants a topic researched, docs or API facts gathered, or reading legwork delegated to a background agent.

Diffs code since a commit, branch, or tag and audits it on two tracks in parallel: Does it follow your repo's style guide? Does it match the ticket it claims to close?

Chart a route through a foggy problem — turn a loose idea into a map of investigation tickets and resolve them one at a time until the way to the goal is clear.

Grill me about specs for the workflows I want to build, within this workspace.

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.

Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published to the configured tracker — edges as text in a local file, or native blocking links on a real tracker.

Generate an interactive bash wizard that walks a human through a manual procedure — third-party setup, a one-off migration, an A→B state transition — opening URLs, capturing values, confirming each step, and writing .env files and GitHub Actions secrets.

Hand the current conversation off to a fresh background agent that picks up the work immediately.

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

Wire dependency-cruiser into a TypeScript repo so each package is a deep module — implementation hidden in subfolders, reachable only through its entry-point files. User-invoked.

Turn a decision you can't fully answer into a questionnaire for someone else to fill in.