Find AI skills and prompts

Apply when the user requests integration testing, feature validation, or test plan execution.

/agent-integration-testing in Cursor’s slash menu

Finds and fixes duplicated logic, unnecessary complexity, silent errors, and inconsistent conventions in AI-written code.

/anneal in Cursor’s slash menu

Create a researched long-form article from a topic prompt via an orchestrated pipeline - research agent (first-person sources, working-definition gate).

/article-factory in Cursor’s slash menu

Runs repeated experiments and keeps changes that improve one measurable outcome.

/autoresearch in Cursor’s slash menu

Develop custom modules for [Harbor Boost](https://github.com/av/harbor/tree/main/boost), an optimizing LLM proxy.

/boost-modules in Cursor’s slash menu

Systematically explore and test any software project (CLI, API, Backend, Library, etc.) to find bugs, usability issues, and edge cases.

/bugbash in Cursor’s slash menu

Finds bugs in a defined area, verifies and fixes them, then checks the fixes against project constraints.

/bughunt in Cursor’s slash menu

Catalog-then-fix slop removal on an existing prose draft.

/catalog-deslop in Cursor’s slash menu

Gives agents a set of rules for scoping work, tracking constraints, verifying claims, and recovering from failures.

/discipline in Cursor’s slash menu

Rephrase content as a flat list of atomic facts in the style of av/facts fact sheets.

/factual-communication in Cursor’s slash menu

Runs a timed brainstorming session in which independent agents propose, critique, and compare ideas.

/ideate in Cursor’s slash menu

Reviews an existing skill, makes one focused change, and has an independent reviewer check the result.

/improve-skill in Cursor’s slash menu

Create a HyperFrames video composition from a brief/script autonomously.

/make-video in Cursor’s slash menu

Assemble a finished piece from human-written fragments via an orchestrated two-loop pipeline - an assembly loop (assembler + cold reviewer).

/mosaic-writing in Cursor’s slash menu

Build-less ESM frontends that run directly in the browser without bundlers.

/preact-buildless-frontend in Cursor’s slash menu

Downloads llama.cpp models and describes a CPU fallback for ROCm environments.

/pull-llamacpp-model in Cursor’s slash menu

Set up and run local LLMs with Harbor.

/run-llms in Cursor’s slash menu

Orchestrate AI coding agents (Claude Code, Codex, OpenCode) in isolated sandboxes using the @ai-hero/sandcastle SDK.

/sandcastle in Cursor’s slash menu

Set up and operate the Claude Code harness for large codebases.

/superclaude in Cursor’s slash menu

Carry out a task iteratively over a user-specified duration by dispatching subagents.

/timeboxed-iterating in Cursor’s slash menu

Builds a sourced research dossier by dividing a date range into year and month research passes.

/timeframe-research in Cursor’s slash menu

Deep learning framework development with tinygrad - a minimal tensor library with autograd, JIT compilation, and multi-device support.

/tinygrad in Cursor’s slash menu

Shows how to install, configure, and use Turso DB, a SQLite-compatible database engine written in Rust.

/turso-db in Cursor’s slash menu

Shows how to call installed coding agents as headless workers from a coordinating session.

/use-coding-agents in Cursor’s slash menu

Orchestrate work as a cyclic directed graph of subagent-executed nodes with transition criteria on edges, budgeted cycles, and per-node gates.

/workgraph in Cursor’s slash menu

Carry out work as an explicit event-driven state machine executed by subagents.

/workmachine in Cursor’s slash menu

Designs and implements web motion, choosing the purpose, properties, timing, and interruption behaviour.

/animate in Cursor’s slash menu

Designs and implements motion in React Native and Expo, including gestures and thread choices.

/animate-expo in Cursor’s slash menu

Diagnoses frame drops and selects animation techniques that keep rendering responsive.

/animation-performance in Cursor’s slash menu

Names motion patterns precisely so animation requests translate into clear design and implementation choices.

/animation-vocabulary in Cursor’s slash menu

Apple's approach to interface design and fluid, physical motion, translated for the web.

/apple-design in Cursor’s slash menu

Shows how to configure Sonner and manage toast messages, promises, and loading states.

/ask-sonner in Cursor’s slash menu

Stress-tests interfaces with extreme and incomplete data, then reports the visual and behavior failures.

/break-ui in Cursor’s slash menu

Applies Emil Kowalski’s approach to component design, animation, and interface polish.

/emil-design-eng in Cursor’s slash menu

Search a codebase or UI for places that don't animate but should, and reject everything that shouldn't.

/find-animation-opportunities in Cursor’s slash menu

Survey a codebase's animation and motion code as a senior motion advisor, then produce a prioritized audit and self-contained implementation.

/improve-animations in Cursor’s slash menu

Refines web layouts and controls for phones, including safe areas, viewport sizing, and touch behaviour.

/mobile-native in Cursor’s slash menu

Selects a dependable frontend library that fits the component need and preferred toolset.

/pick-ui-library in Cursor’s slash menu

Builds contrasting interface concepts so teams can compare options before committing to a direction.

/prototype in Cursor’s slash menu

Assesses animation and motion code against a high craft bar derived from Emil Kowalski's design engineering philosophy.

/review-animations in Cursor’s slash menu

Guides modern Swift development with value types, Swift 6 data-race safety, and concurrency.

/write-swift in Cursor’s slash menu

Checks keyboard, screen-reader, form, motion, and zoom behavior against accessibility standards.

/better-accessibility in Claude Code after a direct install

Creates semantic color palettes and evaluates them for consistency and readable contrast.

/better-colors in Claude Code after a direct install

Evaluates screens and user flows across accessibility, layout, copy, typography, color, and visual polish.

/better-interface in Claude Code after a direct install

Refines grouping, reading order, responsiveness, and translation support across screen sizes.

/better-layout in Claude Code after a direct install

Improves type scale, spacing, font features, wrapping, and truncation for readable interfaces.

/better-typography in Claude Code after a direct install

Polishes interface details such as icons, surfaces, shadows, and motion with concrete design values.

/better-ui in Claude Code after a direct install

Makes interface messages clearer and more useful across labels, errors, empty states, and confirmations.

/better-writing in Claude Code after a direct install

Renders a component you choose under every scenario that can reach it on a temporary page and stress tests it.

/break in Claude Code after a direct install

Turns a visual reference into interface code while respecting the project’s existing components and tokens.

/build-design in Claude Code after a direct install

Explains how a site or visual effect works using a live page or screenshot as evidence.

/explain-interface in Claude Code after a direct install

Finds interface regressions in a branch or change across accessibility and visual design concerns.

/interface-review in Claude Code after a direct install

Displays every component state with mock data so teams can inspect edge cases in context.

/state-machine in Claude Code after a direct install

Creates technical illustrations that show how physical objects and interface components are put together.

/teardown in Claude Code after a direct install

Creates and compares multiple component directions to help select the strongest design.

/variant in Claude Code after a direct install

Ask which skill or flow fits your situation.

/ask-matt in Claude Code after a direct install

Pursue a long-running goal in a single session by co-ordinating subagents.

/chief-of-staff in Claude Code after a direct install

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

/claude-handoff in Claude Code after a direct install

Reviews changes against project standards and the original specification in separate passes.

/code-review in Claude Code after a direct install

Helps choose module boundaries and interfaces that make a codebase easier to test and navigate.

/codebase-design in Claude Code after a direct install

Diagnosis loop for hard bugs and performance regressions.

/diagnosing-bugs in Claude Code after a direct install

Defines domain terms and relationships for glossaries, architecture decisions, and code.

/domain-modeling in Claude Code after a direct install

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute.

/git-guardrails-claude-code in Claude Code after a direct install

A relentless interview to sharpen a plan or design.

/grill-me in Claude Code after a direct install

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

/grill-with-docs in Claude Code after a direct install

Grill the user relentlessly about a plan, decision, or idea.

/grilling in Claude Code after a direct install

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

/handoff in Claude Code after a direct install

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

/implement in Claude Code after a direct install

Build the result of /to-spec and /to-tickets in code.

/implement-spec in Claude Code after a direct install

Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

/improve-codebase-architecture in Claude Code after a direct install

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

/loop-me in Claude Code after a direct install

Migrate test files from `as` type assertions to @total-typescript/shoehorn.

/migrate-to-shoehorn in Claude Code after a direct install

Drafts a pull request body that explains the change, evidence, and risk.

/pr in Claude Code after a direct install

Builds contrasting interface concepts so teams can compare options before committing to a direction.

/prototype in Claude Code after a direct install

Investigate a question against high-trust primary sources and capture the findings as a Markdown file in the repo.

/research in Claude Code after a direct install

Reviews a completed coding session to capture lessons and improve future work.

/retro in Claude Code after a direct install

Develop exercise directory structures with sections, problems, solutions, and explainers that pass linting.

/scaffold-exercises in Claude Code after a direct install

Set up this repo for the engineering skills: set up its issue tracker, triage label vocabulary, and domain doc layout.

/setup-matt-pocock-skills in Claude Code after a direct install

Set up Husky pre-commit hooks with lint-staged (Prettier), type checking, and tests in the current repo.

/setup-pre-commit in Claude Code after a direct install

Wire dependency-cruiser into a TypeScript repo so each package is a deep module, with implementation hidden in subfolders and reachable.

/setup-ts-deep-modules in Claude Code after a direct install

Builds features through a test-first cycle that checks behavior before and after implementation.

/tdd in Claude Code after a direct install

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

/teach in Claude Code after a direct install

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

/to-questionnaire in Claude Code after a direct install

Convert the current conversation into a spec and publish it to the project issue tracker: no interview, just synthesis of.

/to-spec in Claude Code after a direct install

Stress-test a plan, spec, or the current conversation into a set of tracer-bullet tickets, each declaring its blocking edges, published.

/to-tickets in Claude Code after a direct install

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

/triage in Claude Code after a direct install

Rephrases confusing messages in clearer language so the conversation can move forward.

/wait-what in Claude Code after a direct install

Shape a huge chunk of work (more than one agent session can hold) as a shared map of decision tickets.

/wayfinder in Claude Code after a direct install

Produce an interactive bash wizard that walks a human through steps only they can perform.

/wizard in Claude Code after a direct install

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

/writing-beats in Claude Code after a direct install

Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.

/writing-for-agents in Claude Code after a direct install

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

/writing-fragments in Claude Code after a direct install

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

/writing-shape in Claude Code after a direct install

Plans API contracts and module boundaries early, then keeps design choices aligned as implementation develops.

/architect in Cursor’s slash menu

Compares several independent approaches, then combines the strongest ideas into one polished result.

/arena in Cursor’s slash menu

Drafts or revises a personal -mode skill via create-skill + unslop, optionally pulling fresh evidence from recent transcripts.

/automate-me in Cursor’s slash menu

Assess a perf measurement (limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before you report or act.

/benchmark-checklist in Cursor’s slash menu

Tests what a change might break outside the diff and verifies the assumption that keeps it safe.

/blast-radius in Cursor’s slash menu

Rephrase the last message in plain human language, with no jargon.

/bro in Cursor’s slash menu

Identify the mistakes agents keep repeating in this repo and make each one impossible.

/correct in Cursor’s slash menu

Produce a project-local skill that formally verifies the code where a bug costs the most and tests reach the least.

/create-formal-verification-skill in Cursor’s slash menu

Creates a project-specific skill that tests an application through the same steps a user takes.

/create-verification-skill in Cursor’s slash menu

Builds an auditable playbook for a complex task, with hypotheses, checks, and a decision log.

/figure-it-out in Cursor’s slash menu

Explains a system’s design and runtime flow to answer ownership, placement, and implementation questions.

/how in Cursor’s slash menu

Rephrase in your own words what you think the user's goals are and what problem they're trying to solve.

/in-your-own-words in Cursor’s slash menu

Challenges a change from several independent review angles to expose assumptions and overlooked risks.

/interrogate in Cursor’s slash menu

Catch the user up on what changed in this chat since their last message, in plain words and small visuals.

/ketchup in Cursor’s slash menu

Updates formal models and verification checks after code changes and distinguishes verification drift from bugs.

/maintain-formal-verification-skill in Cursor’s slash menu

Reviews a project’s verification guide against its features and tests those features in a live session.

/maintain-verification-skill in Cursor’s slash menu

Creates a control interface that triggers a Grok Bot through a webhook with the required sender handoff.

/make-bot-ui in Cursor’s slash menu

Compare Comment Sicko, fix accepted findings, and offer encodings for claimed constraints.

/no-comments in Cursor’s slash menu

Directs users through pstack setup, /poteto-mode, and picking the skill, playbook, or principle for a task.

/poteto-help in Cursor’s slash menu

poteto's agent style for concise, detailed responses, deliberate subagents, unslopped prose, simple code, and verified work.

/poteto-mode in Cursor’s slash menu

Apply when two or more fixes that share one premise have failed the same gate.

/principle-attack-the-premise in Cursor’s slash menu

Apply when wiring validation, error handling, or framework adapters.

/principle-boundary-discipline in Cursor’s slash menu

Apply to any non-trivial work, not just bulk work: edits, migrations, analyses, checks.

/principle-build-the-lever in Cursor’s slash menu

Apply when you catch yourself writing the same instruction a second time, or notice a recurring correction.

/principle-encode-lessons-in-structure in Cursor’s slash menu

Apply when facing a novel UI interaction or architectural decision with no precedent in the codebase.

/principle-exhaust-the-design-space in Cursor’s slash menu

Apply when product, UX, or feature-scope tradeoffs come up.

/principle-experience-first in Cursor’s slash menu

Apply before you trust, report, or act on a number you measured: a speedup, a regression, a throughput, a latency.

/principle-explain-the-number in Cursor’s slash menu

Apply when debugging. Trace each symptom back to the first place the system went wrong and fix it there.

/principle-fix-root-causes in Cursor’s slash menu

Apply before writing logic: choosing core types and data structures, sequencing scaffold-vs-feature work, asking what concurrent actors share.

/principle-foundational-thinking in Cursor’s slash menu

Apply when context is filling up: large outputs, long files, repeated reads, fan-out planning.

/principle-guard-the-context-window in Cursor’s slash menu

Apply when refactoring, evaluating diff size, or tempted to add abstractions, layers, or signal threading.

/principle-laziness-protocol in Cursor’s slash menu

Apply when designing commands, lifecycle steps, or processing loops that run amid crashes, restarts, and retries.

/principle-make-operations-idempotent in Cursor’s slash menu

Apply when introducing a new internal API while old callers still exist.

/principle-migrate-callers-then-delete-legacy-apis in Cursor’s slash menu

Apply when reviewing or shaping code that's hard to trace.

/principle-minimize-reader-load in Cursor’s slash menu

Apply when writing stateful logic, or when code branches a lot or repeats a shape assumption across files.

/principle-model-the-domain in Cursor’s slash menu

Apply when tempted to ask 'should I do X?' on reversible work.

/principle-never-block-on-the-human in Cursor’s slash menu

Apply during planned rewrites and migrations with explicit phase boundaries.

/principle-outcome-oriented-execution in Cursor’s slash menu

Apply after completing a task, before declaring done.

/principle-prove-it-works in Cursor’s slash menu

Apply when integrating a new requirement into an existing design.

/principle-redesign-from-first-principles in Cursor’s slash menu

Apply when concurrent actors might write to the same file, branch, key, or state object.

/principle-separate-before-serializing-shared-state in Cursor’s slash menu

Apply to multi-step work (sweeps, migrations, runs of similar edits) and to how you stack commits and PRs.

/principle-sequence-verifiable-units in Cursor’s slash menu

Apply when sequencing an addition, refactor, or rewrite.

/principle-subtract-before-you-add in Cursor’s slash menu

Apply when you write, change, or keep a test.

/principle-test-behavior-not-implementation in Cursor’s slash menu

Apply when designing types, reviewing a function signature, or writing code in any statically-typed language.

/principle-type-system-discipline in Cursor’s slash menu

Reconstructs recent work from chat, live state, and shared records into a short handoff.

/recall in Cursor’s slash menu

Compares independent reviews of a session and turns findings into edits to existing skills.

/reflect in Cursor’s slash menu

Set up which models pstack uses per role and at what reasoning budget.

/setup-pstack in Cursor’s slash menu

Create a task deeper, not bigger, then rewrite the prompt.

/sharpen in Cursor’s slash menu

Records decisions, evidence, and outcomes in a reviewable log during longer tasks.

/show-me-your-work in Cursor’s slash menu

Draw what an app's user sees as a Mermaid statechart from a TLA+ model.

/statechart in Cursor’s slash menu

Fan out N parallel workers, drain them, and return one report.

/swarm in Cursor’s slash menu

Builds features through a test-first cycle that checks behavior before and after implementation.

/tdd in Cursor’s slash menu

Clarify a body of work plainly so a person actually understands it.

/teach in Cursor’s slash menu

Layered technical-writing standard: Diátaxis structure, Google developer style sentences, STE instruction rules, Global English syntax.

/technical-writing in Cursor’s slash menu

TypeScript best practices. Use when reading or editing any .ts or .tsx file.

/typescript-best-practices in Cursor’s slash menu

Removes common AI wording patterns from copy while preserving meaning and voice.

/unslop in Cursor’s slash menu

Searches project evidence to explain why a decision was made and cites the tradeoffs it finds.

/why in Cursor’s slash menu

Starts creative work with a structured idea session to clarify the problem and compare possible directions.

/superpowers:brainstorming in Claude Code with the Superpowers plugin

Investigates failed Superpowers sessions, including repeated work and ignored plans.

/superpowers:diagnosing-superpowers in Claude Code with the Superpowers plugin

Apply when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies.

/superpowers:dispatching-parallel-agents in Claude Code with the Superpowers plugin

Carries out an implementation plan in the current session with checkpoints for review.

/superpowers:executing-plans in Claude Code with the Superpowers plugin

Apply when implementation is complete, all tests pass, and you need to decide how to integrate the work.

/superpowers:finishing-a-development-branch in Claude Code with the Superpowers plugin

Apply when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical.

/superpowers:receiving-code-review in Claude Code with the Superpowers plugin

Apply when completing tasks, implementing major features, or before merging to verify work meets requirements.

/superpowers:requesting-code-review in Claude Code with the Superpowers plugin

Apply when executing implementation plans with independent tasks in the current session.

/superpowers:subagent-driven-development in Claude Code with the Superpowers plugin

Apply when encountering any bug, test failure, or unexpected behavior, before proposing fixes.

/superpowers:systematic-debugging in Claude Code with the Superpowers plugin

Apply when implementing any feature or bugfix, before writing implementation code.

/superpowers:test-driven-development in Claude Code with the Superpowers plugin

Sets up an isolated Git worktree for a feature or implementation plan.

/superpowers:using-git-worktrees in Claude Code with the Superpowers plugin

Apply when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including.

/superpowers:using-superpowers in Claude Code with the Superpowers plugin

Apply when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification.

/superpowers:verification-before-completion in Claude Code with the Superpowers plugin

Apply when you have a spec or requirements for a multi-step task, before touching code.

/superpowers:writing-plans in Claude Code with the Superpowers plugin

Apply when creating new skills, editing existing skills, or verifying skills work before deployment.

/superpowers:writing-skills in Claude Code with the Superpowers plugin