@mattpocock
Covers product, testing, and writing, with representative works grill-me, improve-codebase-architecture, and tdd.
All Skills by @mattpocock
grill-me
by @mattpocock
Conduct in-depth interviews and questioning of a plan until consensus is reached, ensuring its comprehensiveness and feasibility.
improve-codebase-architecture
by @mattpocock
Explore and analyze codebases like an AI to improve code architecture, enhancing code quality, maintainability, and scalability.
grill-with-docs
by @mattpocock
Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
tdd
by @mattpocock
Adopts Test-Driven Development (TDD) methodology, ensuring code quality and functional correctness through the Red-Green-Refactor cycle.
handoff
by @mattpocock
This skill compacts the current conversation into a handoff document for another agent to pick up. By providing a concise context summary, it significantly enhances the efficiency and task continuity in multi-agent collaboration, reducing context switching overhead.
setup-matt-pocock-skills
by @mattpocock
This skill configures the repository environment for AI engineering skills (e.g., `to-issues`, `triage`). It sets up the issue tracker (GitHub or local Markdown), task triage label vocabulary, and domain documentation layout, ensuring other skills can correctly understand and operate within the repository's context. Run this before the first use of related skills, or if they appear to lack context regarding the issue tracker, triage labels, or domain docs.
triage
by @mattpocock
This skill automates the classification and management of issues in a project tracker using a state machine driven by defined triage roles. It assists users in creating, triaging, and reviewing incoming bugs or feature requests, preparing issues for AFK agents, and optimizing the overall issue workflow to ensure a smooth and efficient development process.
prototype
by @mattpocock
Build a throwaway prototype to flesh out a design before committing to it. Routes between two branches — a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route. Use when the user wants to prototype, sanity-check a data model or state machine, mock up a UI, explore design options, or says "prototype this", "let me play with it", "try a few designs".
grilling
by @mattpocock
This skill relentlessly interviews the user about a plan or design, thoroughly exploring each decision branch and dependency. It helps users stress-test their proposals before building, ensuring a shared understanding within the team and significantly reducing rework risks, thereby increasing project success rates.
domain-modeling
by @mattpocock
This skill helps developers actively build and refine a project's domain model, clarify core business terminology and ubiquitous language, and promptly record significant architectural decisions. By challenging vague concepts, discussing concrete scenarios, and cross-referencing with code, it effectively reduces team communication barriers, deepens business understanding, ensures software design aligns closely with business requirements, and ultimately improves development efficiency and project quality.
teach
by @mattpocock
This skill is designed to teach users new skills or concepts within a workspace. It provides a structured learning environment, including missions, reference materials, learning records, and tailored lessons. This ensures that teaching content is closely aligned with the user's learning goals and personalized to their zone of proximal development, significantly enhancing learning efficiency and knowledge retention.
codebase-design
by @mattpocock
This skill provides a shared vocabulary and principles for designing deep modules, optimizing code interfaces and implementations. It helps developers identify deepening opportunities, define module boundaries, enhance code testability and AI navigability, thereby building software systems with greater leverage, locality, and maintainability.
diagnosing-bugs
by @mattpocock
This skill provides a systematic approach to diagnosing hard bugs and performance regressions by focusing on building a tight feedback loop. It emphasizes establishing a reproducible, fast, and deterministic failure mechanism before deep analysis, preventing speculative debugging and significantly improving the efficiency and accuracy of problem diagnosis.
code-review
by @mattpocock
This skill performs a two-axis code review of the diff from a user-specified fixed point (commit, branch, tag, or merge-base): Standards (code style compliance with repo conventions) and Spec (faithfulness to the originating issue/PRD). Two parallel sub-agents run independently to avoid context pollution, then produce a side-by-side report. It helps teams catch style issues and spec deviations before merging, improving code quality and review throughput.
implement
by @mattpocock
This skill efficiently implements software development tasks based on Product Requirements Documents (PRDs) or issue lists. It integrates Test-Driven Development (TDD) at pre-agreed seams, regularly performs type-checking to ensure code robustness and correctness. Upon completion, this skill runs the full test suite for validation and conducts a self-review before committing high-quality code to the current branch. This significantly boosts development efficiency, code quality, and project delivery speed, ensuring adherence to development processes and reducing manual errors.
ask-matt
by @mattpocock
This skill acts as an intelligent router, guiding users to select the most appropriate AI skill or workflow for their specific situation. It simplifies the use and management of complex AI tools by leading users through processes from idea generation to shipping, or handling specific tasks like bug triage and codebase maintenance. This ensures that each task is efficiently addressed by the correct skill, optimizing overall productivity and reducing decision-making overhead.
wayfinder
by @mattpocock
This skill helps users transform vague, complex problems into a structured map of investigation tickets, resolving them one by one until the goal is clear. It breaks down problems by creating traceable "tickets," clarifying dependencies, and guiding users to systematically progress. This turns uncertain ideas into clear, actionable plans, making complex problem-solving manageable and efficient.
to-spec
by @mattpocock
Automatically synthesize the current conversation and codebase understanding into a technical spec (PRD) and publish it directly to the project issue tracker, eliminating the need for manual interviews and enabling engineering teams to capture and communicate feature requirements efficiently.
to-tickets
by @mattpocock
Break a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, and publish them to the configured tracker (local file or real issue tracker like GitHub/Linear). Ideal for engineering teams to quickly transform ambiguous requirements into actionable task sequences, reducing manual orchestration time and ensuring dependency completeness.
research
by @mattpocock
This skill automatically investigates a question against high-trust primary sources such as official docs and source code, then captures the findings as a Markdown file in the repo. Ideal for delegating research tasks, ensuring accurate and citable results while you focus on other work.
resolving-merge-conflicts
by @mattpocock
This skill offers a systematic approach to efficiently resolve Git merge or rebase conflicts. It guides developers through inspecting history, identifying conflict sources, precisely handling each hunk, and ensuring automated checks pass. This significantly reduces the time and errors associated with manual conflict resolution, ensuring a clean codebase and smooth project progression.
wizard
by @mattpocock
This skill generates an interactive bash wizard that guides users through tedious manual procedures like third-party setup, one-off migrations, or state transitions. It automates opening URLs, capturing values, confirming steps, and writing to .env files and GitHub Actions secrets, significantly improving operational efficiency and accuracy.
git-guardrails-claude-code
by @mattpocock
Responsible for configuring Claude Code hooks to block potentially dangerous Git commands (e.g., force pushes), ensuring code repository security and integrity.
to-questionnaire
by @mattpocock
Transform decisions you can't fully answer into a structured Markdown questionnaire for someone else to fill in asynchronously or together in a meeting. Elicit the knowledge you need to make informed decisions, reducing back-and-forth communication.
setup-pre-commit
by @mattpocock
Configures and enables Git's pre-commit hook, using Husky and lint-staged to automatically perform code checks and formatting before commits, ensuring code quality.
writing-beats
by @mattpocock
This skill shapes raw material into an article as a journey of beats. Users pick a starting beat, and the skill writes each beat sequentially, offering options for the next pivot until the article naturally concludes. It helps users assemble raw material into a coherent narrative rather than a mere argument.
writing-shape
by @mattpocock
This skill takes a markdown file of raw material, such as notes, fragments, or a rough draft, and transforms it into a polished, publishable article. Through an interactive conversational session, it guides the user in drafting compelling openings, developing content paragraph by paragraph, and meticulously refining the format, including lists, tables, and quotes. This process ensures a coherent and well-structured final piece, ideal for users seeking to elevate their raw ideas into professional content.
writing-fragments
by @mattpocock
This skill facilitates a grilling session to extract heterogeneous writing fragments—claims, vignettes, sharp sentences, half-thoughts—and appends them to a single document. It helps users develop ideas and gather raw material for future articles without imposing structure, making the ideation phase more efficient and fluid.
scaffold-exercises
by @mattpocock
Automatically create lint-compliant exercise directory structures, run checks, and submit code, simplifying the course exercise environment setup process.
migrate-to-shoehorn
by @mattpocock
Replace TypeScript 'as' assertions in test code with type-safe shoehorn patterns, improving test maintainability and type safety.
writing-for-agents
by @mattpocock
This skill guides writing documentation for AI agents, such as skills, AGENTS.md, or CLAUDE.md. It leverages context pointers, progressive disclosure, and information hierarchy to make agent behaviour predictable, ensuring the agent takes the same process every run. Ideal for creating or editing skill files or agent instructions, it reduces ambiguity and improves first-run success.
wait-what
by @mattpocock
This skill enables AI assistants to detect when a previous response has failed to land and automatically re-pitch the explanation with additional context. It instructs the AI to utilize ASD-STE100 Simplified Technical English and the ubiquitous language defined in CONTEXT.md, thereby restructuring complex or ambiguous information into clear, easily understandable terms. This approach minimizes misunderstandings, accelerates comprehension, and is particularly beneficial in technical support, documentation, and collaborative scenarios where precise communication is essential. By implementing this skill, AI assistants can significantly improve user satisfaction and reduce the need for iterative clarifications.
loop-me
by @mattpocock
This skill conducts an interactive "grilling" session to deeply understand user needs, generating highly detailed and unambiguous specifications for automated workflows. It focuses on identifying recurring patterns ("loops") in a user's life and translating them into clear instructions that can be directly executed by AI agents. This enables effective task delegation and automation, ensuring specifications are clear enough for implementation without further questions.
claude-handoff
by @mattpocock
This skill summarizes the current conversation and launches a background AI agent to continue the work immediately, eliminating manual saving and context repasting. It streamlines long-running tasks, debugging, and analysis workflows, boosting developer productivity.
setup-ts-deep-modules
by @mattpocock
Enforce deep modules in a TypeScript monorepo using dependency-cruiser: each package exposes only its entry-point files, hiding subfolder implementation. Automatically detects illegal cross-package imports and dependency cycles, ensuring clean boundaries and maintainable architecture.
to-prd
by @mattpocock
This skill automatically generates a Product Requirements Document (PRD) from the current conversation context and codebase understanding, then publishes it to the project issue tracker. It streamlines PRD writing, ensuring comprehensive and consistent documentation, accelerating product iteration.
to-issues
by @mattpocock
This skill breaks down project plans, specifications, or PRDs into independently actionable, end-to-end vertical slice tasks (tracer bullets), converting them into concrete issues in a project management system. It automates task decomposition, dependency management, and issue publishing, helping users efficiently transform high-level plans into implementable development tickets, optimizing work breakdown processes, and enhancing team collaboration.
writing-great-skills
by @mattpocock
This skill provides a comprehensive reference for writing and editing high-quality AI skills, covering core vocabulary and principles to ensure predictability and efficiency. It guides developers in optimizing skill structure, managing context load, and enhancing the accuracy and reliability of AI agent task execution, leading to more stable and maintainable AI applications.
implement-spec
by @mattpocock
This skill parses a specification into a task graph with dependencies, orchestrates multiple implementer subagents to work in parallel, automatically merges branches, and runs code review to produce a complete PR. It maximizes concurrency and reduces manual coordination, ideal for rapidly delivering complex features against a spec.
retro
by @mattpocock
This skill conducts a retrospective on a coding session. It analyzes session logs and agent behavior to identify improvement candidates across navigation, automated checks, coding standards, tool economy, and information access. It helps developers and teams optimize the coding agent's environment for more efficient and higher-quality future runs.
diagnose
by @mattpocock
This skill provides a rigorous diagnostic loop methodology for tackling hard bugs and performance regressions. It emphasizes building fast feedback loops, systematically identifying and resolving issues through reproduction, minimization, hypothesis, instrumentation, fixing, and regression testing, ensuring stable and efficient system operation.
write-a-skill
by @mattpocock
Creates new AI agent skills with proper structure and progressive development, extending agent capabilities.
zoom-out
by @mattpocock
Instructs the AI agent to provide broader context and a higher-level perspective. Use when you're unfamiliar with a section of code or need to understand how it fits into the bigger picture, helping to quickly grasp system structure and module relationships.
design-an-interface
by @mattpocock
Generates multiple distinct interface design solutions, offering innovative perspectives to meet diverse user needs.
request-refactor-plan
by @mattpocock
Create a detailed refactoring plan with small commits based on user interviews. (AI Agent Skill, improves work efficiency and automation capabilities)
qa
by @mattpocock
Interactive QA session tool, guiding users to describe problems and automatically exploring the codebase, generating persistent GitHub Issues conforming to project domain language.
ubiquitous-language
by @mattpocock
Automatically extract domain terms from conversations to form a unified glossary, eliminating homonymic ambiguities, and save as a local file for team reference.
obsidian-vault
by @mattpocock
Manage Obsidian knowledge bases, following title naming and indexed note conventions for flat, efficient knowledge management.
edit-article
by @mattpocock
Segments articles by heading, understands information dependencies using a directed acyclic graph (DAG), ensuring chapter order aligns with logical dependencies.
pr
by @mattpocock
Use this Skill when writing a PR body. It structures the description into Summary, Evidence, and Merge Danger sections, picking the smallest visual—call tree, component tree, Mermaid sequence diagram, or diff—that makes the change obvious to a reviewer. It also demands before/after proof that the change works and forces a clear call on whether the merge is a one-way or two-way door and how far its blast radius reaches, so reviewers can judge risk in minutes rather than asking clarifying questions.
review
by @mattpocock
This skill performs a deep, two-axis review of code changes, assessing whether the code strictly adheres to established coding standards and best practices, and verifying if the implementation precisely matches the original requirements document (e.g., PRD or Issue). It executes these reviews by launching two independent parallel sub-agents, effectively preventing context contamination, and finally aggregates their findings into a clear report. This not only significantly enhances the efficiency and accuracy of code reviews but also identifies potential issues early in development, thereby substantially reducing rework costs and ensuring software quality and timely project delivery.
chief-of-staff
by @mattpocock
This skill acts as a chief of staff that co-ordinates subagents and recurring schedules to pursue a long-running goal within a single session. It delegates all work to background subagents to protect the context window, communicates through context pointers, and relentlessly improves the operating environment so the next task succeeds more easily. It is ideal for long-horizon, multi-threaded objectives that need tactical execution plus strategic compounding.
batch-grill-me
by @mattpocock
This Skill acts like a relentless interviewer that asks every frontier question at once, round by round, mapping decisions into a design tree. It helps users systematically explore dependencies, uncover hidden assumptions, and reach shared understanding for complex product or design decisions.
decision-mapping
by @mattpocock
This skill transforms a vague idea into a structured decision map and a sequence of investigative tickets. By creating a trackable Markdown decision map, it helps users systematically break down complex problems, resolve open questions step-by-step, clarify project paths, and enhance the efficiency and quality of multi-session collaboration.
write-a-prd
by @mattpocock
This skill is invoked when a user needs to create a Product Requirement Document (PRD), assisting in writing detailed and standardized PRDs.
prd-to-issues
by @mattpocock
Break down Product Requirement Documents (PRD) into individual GitHub Issues, facilitating team collaboration and task assignment, and improving development efficiency.
prd-to-plan
by @mattpocock
Break down Product Requirement Documents (PRD) into phased implementation plans using a vertical slicing approach, ensuring smooth project progress.
triage-issue
by @mattpocock
Automatically investigates issue reports, identifies root causes, and creates GitHub Issues with TDD-based fix plans, requiring minimal human intervention.
better-sqlite3-rebuild
by @mattpocock
This skill automatically runs npm rebuild and retries whenever better-sqlite3 native module errors appear, covering NODE_MODULE_VERSION mismatch, "compiled against a different Node.js version", and other native binding failures. It lets an AI agent self-heal broken dependencies without interrupting the user, cutting troubleshooting time from tens of minutes to seconds and keeping the development loop moving.