mattpocock/skills▌

Relentless interviewing skill that stress-tests plans and designs through systematic questioning. \n \n Conducts deep-dive questioning across all aspects of a plan, walking through decision trees branch-by-branch until shared understanding is reached \n Automatically explores the codebase to answer questions where code context is available, reducing redundant back-and-forth \n Designed for design reviews, architecture validation, and pre-implementation planning where thorough vetting prevents do

Collaborative PRD creation through structured interviews, codebase analysis, and modular design planning. \n \n Guides users through problem definition, solution ideation, and iterative design interviews to reach shared understanding \n Explores the codebase to validate assumptions and understand current architecture before planning changes \n Designs modular solutions by identifying deep modules with simple, testable interfaces that encapsulate significant functionality \n Generates comprehensi

Convert a PRD into a phased implementation plan using vertical-slice tracer bullets. \n \n Breaks down product requirements into thin, end-to-end slices that cut through all integration layers (schema, API, UI, tests) rather than horizontal layers \n Identifies and documents durable architectural decisions upfront (routes, schema, data models, auth boundaries) so all phases reference consistent foundations \n Outputs a structured Markdown plan file in ./plans/ with phases, user story mappings, a

Turn the current conversation context into a PRD and submit it as a GitHub issue.

Extract and formalize domain terminology from the current conversation into a consistent glossary, saved to a local file.

Convert product requirements into independently-deliverable GitHub issues using vertical-slice architecture. \n \n Fetches PRD content from GitHub, analyzes the codebase context, and breaks requirements into thin vertical slices that span all integration layers end-to-end \n Distinguishes between HITL (human-in-the-loop, requiring decisions) and AFK (autonomous, mergeable without review) slices, preferring AFK where possible \n Presents proposed breakdown for user feedback on granularity, depend

Configure this repo for the engineering skills — set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.

A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.

Tell the agent to zoom out and give broader context or a higher-level perspective.

Scaffold new agent skills with structured templates, progressive disclosure, and bundled utility scripts. \n \n Guides skill creation through a four-step process: gather requirements, draft the skill structure, review with user, and finalize \n Provides SKILL.md template with quick start, workflows, and advanced features sections; splits content into separate reference files when exceeding 100 lines \n Includes utility script patterns for deterministic operations like validation and formatting t

Generate multiple radically different interface designs using parallel sub-agents to explore module shape options. \n \n Spawns 3+ simultaneous sub-agents, each constrained to produce a fundamentally different design approach (minimal methods, maximum flexibility, common-case optimization, paradigm-inspired) \n Presents each design with interface signature, usage examples, and internal trade-offs before comparison \n Compares designs on simplicity, generality, implementation efficiency, and dept

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

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

Break a plan, spec, or PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices.

Set up Claude Code hooks to block dangerous git commands before they execute.

Analyze codebases for architectural friction and propose module-deepening refactors as testability improvements. \n \n Explores codebases organically to surface shallow modules, tightly-coupled components, and untested seams rather than following rigid heuristics \n Applies John Ousterhout's \"deep module\" principle: small interfaces hiding large implementations for better testability and AI navigability \n Generates multiple radically different interface designs (minimalist, flexible, caller-o

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

/mnt/d/Obsidian Vault/AI Research/

Grill 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.

Interactive QA session where users report bugs conversationally, and the agent files GitHub issues while exploring the codebase for context.

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.

Plan a huge chunk of work — more than one agent session can hold — as a shared map of investigation tickets on your issue tracker, and resolve them one at a time until the way to the destination is clear.

Teach the user a new skill or concept, within this workspace.

Test-driven development with vertical slices, behavior-focused tests, and incremental red-green-refactor cycles. \n \n Emphasizes integration-style tests that verify behavior through public APIs, not implementation details; tests should survive refactors unchanged \n Requires vertical slicing (one test → one implementation → repeat) instead of horizontal slicing (all tests first, then all code), preventing brittle, behavior-insensitive test suites \n Includes planning phase to confirm interface

Compact the current conversation into a handoff document for another agent to pick up.

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 UI should look like.

Check for package-lock.json (npm), pnpm-lock.yaml (pnpm), yarn.lock (yarn), bun.lockb (bun). Use whichever is present. Default to npm if unclear.

Writing, exploit — assemble raw material into a journey of beats, grounding each term before a beat leans on it.

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 standards?) and Spec (does the code match what the originating issue/PRD asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to "review since X".

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

Intercept and block dangerous git commands before Claude executes them via PreToolUse hooks. \n \n Blocks five command categories: git push (including --force ), git reset --hard , git clean , git branch -D , and git checkout / git restore on tracked files \n Installs as a bash hook script to either project scope ( .claude/settings.json ) or globally ( ~/.claude/settings.json ) \n Customizable blocklist: edit the hook script to add or remove patterns based on your safety requirements \n Claude r

\n First, divide the article into sections based on its headings. Think about the main points you want to make during those sections. \n \n Consider that information is a directed acyclic graph, and that pieces of information can depend on other pieces of information. Make sure that the order of the sections and their contents respects these dependencies. \n Confirm the sections with the user. \n \n For each section: \n \n 2a. Rewrite the section to improve clarity, coherence, and flow. Use maxi

Move issues and external PRs through a state machine of triage roles — categorise, verify, grill if needed, and write agent-ready briefs.

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.

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

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.

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.

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

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

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.

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

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

Triage GitHub issues through a label-based state machine for efficient issue management.

Create exercise directory structures that pass pnpm ai-hero-cli internal lint, then commit with git commit.

shoehorn lets you pass partial data in tests while keeping TypeScript happy. It replaces as assertions with type-safe alternatives.

Interview-driven refactoring planner that breaks changes into tiny, safe commits and files a GitHub issue. \n \n Conducts a detailed user interview to understand the problem, explore alternatives, and nail down exact scope before planning \n Verifies assertions by exploring the repository and assesses existing test coverage in the affected codebase \n Breaks implementation into the smallest possible commits, each leaving the codebase in a working state \n Generates a structured GitHub issue with

Investigate a reported problem, find its root cause, and create a GitHub issue with a TDD fix plan. This is a mostly hands-off workflow - minimize questions to the user.