Matt Pocock

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.

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.

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.

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.

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.

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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?

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.

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.

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.

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

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

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

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.

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.