Matt Skills Curated

handoff

Compact current conversation context, decisions, evidence, and next actions into a portable markdown handoff for a fresh agent session. Use when ending a session, transferring work to another agent, switching workspaces, or preparing a resume point — even if the user just says "save progress". Do NOT use for committing code to git or creating branch PRs.

implement

Build scoped code changes and run verification from an approved specification or plan. Use when a concrete spec, approved plan, or set of tickets is ready to implement, when the user asks to build or code a planned feature, or when executing tasks — even if they don't explicitly say "implement". Do NOT use for initial architecture exploration or vague requirements.

implement-spec

Execute a full specification across task tickets using isolated subagent branches into a unified PR. Use when a specification with associated task-graph tickets is ready to implement across multiple subagents or isolated worktrees, and the goal is a complete pull request on a single branch — even if the user says "build the whole spec". Do NOT use for single isolated bug fixes or exploratory coding without tickets.

improve-codebase-architecture

Survey codebases for shallow modules, weak seams, and deepening opportunities, producing a visual report. Use when conducting architectural reviews, identifying design debt, finding deepening opportunities, or preparing codebase refactors — even if the user says "analyze our architecture". Do NOT use for basic syntax linting or formatting.

j-space

Operate the agent's inner cognitive workspace for multi-step reasoning, long-horizon planning, deep debugging, and calibrated self-monitoring. Use when tackling complex multi-step problems, architecture design, long mechanical tasks requiring goal preservation, suspicious input audits, or when asked to think deeper or harder — even if they don't explicitly say "J-space". Do NOT use for single-step trivial lookups, basic formatting, or conversational small talk.

migrate-to-shoehorn

Migrate unsafe TypeScript test assertions to @total-typescript/shoehorn with explicit fixture intent. Use when test files contain unsafe `as` or `as unknown as` typecasts, when mock fixtures break under typechecking, or when modernizing test typing — even if the user says "fix test type assertions". Do NOT use for production code types.

ml-best-practices

Statistical machine learning best practices, exploratory data analysis, feature engineering, and rigorous model evaluation. Use when analyzing tabular datasets, engineering features, training classifiers or regressors, forecasting time series, or computing 95% bootstrap confidence intervals — even if they don't explicitly say "ml best practices". Do NOT use for standard database queries without ML, basic spreadsheet formatting, or general application backend logic.

prototype

Build a throwaway prototype to answer a specific design, state model, or UI exploration question. Use when evaluating whether an interface feels right, exploring UI concepts, or testing logic before committing to a full spec — even if the user says "mock this up". Do NOT use for production implementation.

research

Investigate a technical question against high-trust primary sources and capture findings as a cited Markdown note. Use when gathering API facts, reading documentation, verifying library capabilities, or delegating reading legwork — even if the user says "look into this library". Do NOT use for writing production feature code.

resolving-merge-conflicts

Resolve in-progress git merge or rebase conflicts by intent traced to primary sources. Use when hit with merge conflicts, CONFLICT markers in files, rebase pauses, or when git prompts to resolve conflicted hunks — even if the user just says "fix this merge". Do NOT use for creating new branches or routine rebasing without conflicts.

retro

Conduct a retrospective on a coding session to systematically improve agent environment, navigation pointers, automated checks, coding standards, tool economy, or AGENTS.md instructions. Use when reflecting on completed work, auditing agent mistakes, or optimizing repository rules — even if the user says "run a retro". Do NOT use during active mid-task implementation.

scaffold-exercises

Scaffold course, workshop, or tutorial exercises following repository conventions. Use when creating exercise folders, problem/solution/explainer variants, numbered lesson files, or workshop boilerplate — even if the user says "add a new exercise". Do NOT use for routine application feature scaffolding.

setup-engineering-workflows

Configure repository issue-tracking, triage-label, domain-doc, and agent-instruction conventions. Use when initializing engineering workflows in a repo, configuring GitHub/GitLab issue labels, or establishing CONTEXT.md conventions — even if the user says "setup our workflows". Do NOT use for general project package installs.

setup-pre-commit

Configure pre-commit quality checks with Husky and lint-staged while preserving package manager conventions. Use when setting up git pre-commit hooks, automated formatters, staged linters, or typecheck gates — even if the user says "add pre-commit hooks". Do NOT use for continuous integration (CI) pipeline setup.

setup-ts-deep-modules

Enforce TypeScript package boundaries, entry points, and cyclic dependency rules with dependency-cruiser. Use when structuring monorepo packages, establishing public API entry points, or preventing circular imports — even if the user says "fix TS package boundaries". Do NOT use for non-TypeScript repositories.

skill-conductor

Author, refine, evaluate, and package agent skills across their full lifecycle. Use when building a new skill from scratch, improving an existing skill, fixing a skill that triggers unreliably, running skill evals, benchmarking skill performance, or packaging skills for distribution — even if they don't explicitly say "skill conductor". Do NOT use for general software coding tasks or using pre-existing skills.

tdd

Implement features and bug fixes test-first using red-green-refactor cycles. Use when writing new functionality, adding regression tests, fixing bugs with test coverage, or designing behavior through test assertions — even if the user says "write tests for this". Do NOT use for throwaway exploratory prototypes.

teach

Teach a technical concept interactively using the workspace as an active learning lab with durable learning records. Use when the user asks to understand a codebase concept, learn a language feature, explore design patterns, or practice coding skills — even if they say "explain how this works to me". Do NOT use for silent autonomous code generation.

to-questionnaire

Transform unknown requirements and stakeholder dependencies into a structured questionnaire. Use when a plan or spec is blocked by external stakeholder decisions, business rules, or missing domain facts — even if the user says "what should I ask them?". Do NOT use when the user can answer the questions themselves.

to-spec

Synthesize conversation and codebase context into an unambiguous, buildable technical specification. Use when requirements and design decisions are settled and need to be formalized into a technical spec — even if the user says "write a spec for this". Do NOT use when the core idea is still fuzzy and ungrilled.

to-tickets

Decompose an approved specification or plan into ordered, dependency-linked tracer-bullet implementation tickets. Use when turning a spec or architectural plan into actionable tracker issues with clear acceptance criteria — even if the user says "break this into tickets". Do NOT use for initial requirements gathering.

triage

Classify, verify, and prepare external bug reports and feature requests into agent-ready briefs. Use when processing incoming issues, validating bug reproductions, rejecting out-of-scope requests, or structuring contributor tickets — even if the user says "triage these issues". Do NOT use for internal tickets already produced by to-tickets.

wait-what

Re-pitch an explanation or proposal from a simpler angle with reset assumptions and plain English. Use when the previous explanation was confusing, jargon-heavy, or did not land — even if the user just says "what?" or "I don't get it". Do NOT use for general brainstorming or initial planning.

wayfinder

Map and navigate large, uncertain multi-session efforts through a shared graph of decision tickets. Use when facing complex greenfield projects or massive architectural migrations that exceed a single session — even if the user says "map out this massive project". Do NOT use for small, well-scoped features.

wizard

Generate an interactive bash wizard to guide humans through manual setup, dashboard, or credential steps. Use when setting up API keys, third-party dashboards, CI secrets, or infrastructure where human authentication is required — even if the user says "create a setup wizard". Do NOT use for steps the AI agent can execute autonomously.

workflow-designer

Specify recurring operational, review, or content workflows with explicit triggers, inputs, actions, and ownership. Use when designing repeatable team routines, approval loops, release checklists, or automated processes — even if the user says "design a workflow for this". Do NOT use for one-off coding tasks.

writing-beats

Develop long-form writing through an interactive progression of narrative and argumentative beats. Use when drafting essays, articles, documentation, or blog posts where structure evolves beat by beat — even if the user says "write this post with me". Do NOT use for quick single-sentence copy edits.

writing-for-agents

Author and refine agent-facing instructions, skills, AGENTS.md files, and context pointers. Use when creating new agent skills, optimizing prompt guidelines, writing steerable docs, or organizing progressive disclosure — even if the user says "write a skill for this". Do NOT use for human-facing marketing copy.

writing-fragments

Capture and refine raw ideas, quotes, and observations before committing to an article outline. Use when collecting source material, brainstorming essay fragments, or exploring angles without structure pressure — even if the user says "help me brainstorm notes". Do NOT use for final draft formatting.

writing-shape

Shape raw notes, transcript fragments, and research into a structured, coherent article draft. Use when assembling collected fragments into narrative sections, establishing flow, and building a draft block by block — even if the user says "turn these notes into a draft". Do NOT use for initial fragment generation.