Removes telltale AI phrasing from any text you give it.
Runs only when you type /unslop
Provides Cursor plugins and skills that help coding agents plan, review, test, and ship software more reliably.
Removes telltale AI phrasing from any text you give it.
Runs only when you type /unslop
Runs a very strict maintainability review focused on abstraction quality, giant files and tangled conditionals.
Runs only when you type /thermo-nuclear-code-quality-review
Applies TypeScript best practices whenever it reads or edits .ts or .tsx files.
Runs only when you type /typescript-best-practices
Removes AI-generated code clutter and cleans up code style.
Finds what a change could break elsewhere and proves the key safety fact by running code.
Runs only when you type /blast-radius
Explains how a subsystem works, its runtime flow and where code should live.
Runs only when you type /how
Explains the reasoning and tradeoffs behind past design decisions, with citations.
Runs only when you type /why
Applies a layered technical-writing standard to docs, RFCs, readmes, pull request descriptions and commit messages.
Runs only when you type /technical-writing
Runs several parallel attempts at one task and merges the strongest parts into one.
Runs only when you type /arena
Traces each bug symptom back to where the system first went wrong and fixes it there.
Runs only when you type /principle-fix-root-causes
Sketches types, signatures, and module structure before coding, then guides implementation.
Runs only when you type /architect
Turns repeated instructions or corrections into lints, flags, runtime checks or scripts instead of more text.
Runs only when you type /principle-encode-lessons-in-structure
Verifies against the real artifact, not a proxy or self-report, before declaring a task done.
Runs only when you type /principle-prove-it-works
Sends bulky output and long reads to subagents, keeping only summaries in the main conversation.
Runs only when you type /principle-guard-the-context-window
Guides type design so illegal states can't be represented, external data is parsed at boundaries, and variants are exhausted.
Runs only when you type /principle-type-system-discipline
Generates a project skill that drives your app the way a real user would.
Runs only when you type /create-verification-skill
Runs adversarial multi-model review to break a change and keeps only findings proven by a run.
Runs only when you type /interrogate
Keeps validation and error handling at system edges while business logic stays in pure functions.
Runs only when you type /principle-boundary-discipline
Makes the agent answer concisely with careful subagents, clean prose, simple code and verified work.
Runs only when you type /poteto-mode
Has the agent build a reusable script, codemod or generator instead of doing repetitive work by hand.
Runs only when you type /principle-build-the-lever
Biases refactoring toward deletion and the smallest change instead of new abstractions and layers.
Runs only when you type /principle-laziness-protocol
Rethinks the existing design from first principles when folding in a new requirement.
Runs only when you type /principle-redesign-from-first-principles
Removes dead code, redundant validators and stubs before building something new on top.
Runs only when you type /principle-subtract-before-you-add
Builds two or three competing prototypes and compares them before committing to a novel UI or architecture choice.
Runs only when you type /principle-exhaust-the-design-space
Favors user delight over implementation convenience when weighing product and feature-scope tradeoffs.
Runs only when you type /principle-experience-first
Gets core types and data structures right first so downstream code becomes straightforward.
Runs only when you type /principle-foundational-thinking
Designs commands and processing loops to reach the same end state after crashes, restarts or retries.
Runs only when you type /principle-make-operations-idempotent
Simplifies hard-to-trace code by collapsing single-caller wrappers and shrinking mutable scope.
Runs only when you type /principle-minimize-reader-load
Migrates all callers to a new internal API and deletes the old one in the same change.
Runs only when you type /principle-migrate-callers-then-delete-legacy-apis
Guides stateful logic and heavily branching code toward an explicit model of the domain.
Runs only when you type /principle-model-the-domain
Proceeds on reversible work instead of stopping to ask whether it should do it.
Runs only when you type /principle-never-block-on-the-human
Audits a project's verification skill and feature map, then opens one PR of proven corrections.
Runs only when you type /maintain-verification-skill
Drives planned rewrites and migrations to the target architecture without throwaway compatibility code.
Runs only when you type /principle-outcome-oriented-execution
Breaks multi-step work into small units that each end in a verifiable state before the next begins.
Runs only when you type /principle-sequence-verifiable-units
Builds an auditable plan for large or ambiguous changes and logs each decision.
Runs only when you type /figure-it-out
Detects your available models and sets which model and reasoning budget pstack uses for each role.
Reviews the current conversation for lasting lessons and turns each into an edit to an existing skill.
Runs only when you type /reflect
Restates the last message in plain everyday language without jargon.
Runs only when you type /bro
Turns your preferences and working style into a personal skill agents follow.
Runs only when you type /automate-me
Runs a comment-focused review, fixes accepted findings and suggests ways to encode constraints.
Runs only when you type /no-comments
Rebuilds a short brief of your recent work from chat history and state so you can resume.
Runs only when you type /recall
Explains a change or subsystem plainly so you actually understand how it works.
Runs only when you type /teach
Fans out several parallel workers on a task, collects their results and returns one combined report.
Runs only when you type /swarm
Writes a failing test first, then the fix, when you ask for TDD or a regression test.
Runs only when you type /tdd
Tidies commit history, improves the PR description and adds reviewer guidance without changing behavior.
Stops repeated failed fixes by writing down the shared assumption and testing it directly first.
Runs only when you type /principle-attack-the-premise
Writes tests that assert observable behavior so they fail only when that behavior breaks.
Runs only when you type /principle-test-behavior-not-implementation
Resolves merge conflicts automatically, then validates the build and tests.
Builds a custom page or dashboard that wakes a Grok Bot over a webhook.
Runs only when you type /make-bot-ui
Audits a branch's changes for bugs, breaking changes, security issues and feature-gate leaks.
Runs only when you type /thermo-nuclear-review
Builds a local harness to drive, inspect, and profile an interactive CLI or TUI.
Turns your commits over a chosen time period into a short progress update.
Reviews the current branch for bugs and test coverage, runs tests, commits focused work and opens a pull request.
Checks a claim against fresh local evidence and reports whether it holds up.
Summarizes your commits from the past week, grouped into bugfixes, tech debt and new work.
Builds a local browser harness to drive and inspect a web, IDE, or Electron UI.
Finds failing pull request checks, reads the logs and applies focused fixes.
Turns a GitHub pull request into an interactive HTML walkthrough that separates core changes from mechanical ones.
Runs only when you type /pr-review-canvas
Checks a performance measurement for validity before you report or act on it.
Runs only when you type /benchmark-checklist
Runs compile and type-check commands and reports the failures.
Turns repeated agent mistakes into checks that make each one impossible to repeat.
Runs only when you type /correct
Fetches and summarizes review comments from the current pull request.
Runs the security and code-quality reviews in parallel, then combines their findings into one report.
Runs only when you type /thermos
Watches pull request checks and keeps fixing failures until they pass.
Creates a fresh branch, completes the work and opens a pull request.
Runs Playwright smoke tests, debugs failures and verifies the fixes.
Learns your working preferences from recent Cursor chats and turns them into reusable skills or rules.
Guides you through pstack setup and choosing the right skill or principle for a task.
Runs only when you type /poteto-help
Generates a project skill that formally verifies risky code like concurrency and state machines.
Runs only when you type /create-formal-verification-skill
Restates what it thinks your goals and the problem are, in its own words.
Runs only when you type /in-your-own-words
Summarizes what changed in the chat since your last message and lists what awaits your decision.
Runs only when you type /ketchup
Makes a task deeper rather than bigger, then rewrites the prompt.
Runs only when you type /sharpen
Updates a project's formal verification model after code changes and reruns it.
Runs only when you type /maintain-formal-verification-skill
Checks a TLA+ model of a stateful system and draws it as a Mermaid statechart with rule-breaking paths.
Runs only when you type /statechart
Mines past transcripts and updates AGENTS.md so the agent keeps learning.
Runs only when you type /continual-learning
Designs or reviews command-line tools so coding agents can run them reliably.
Guides you through building apps and automations with the Cursor TypeScript SDK.
Splits a large goal into parallel cloud-agent workers and collects their structured handoffs.
Runs only when you type /orchestrate
Creates a new Cursor plugin scaffold with a valid manifest and marketplace wiring.
Renders architecture notes, API references and how-tos as a navigable documentation canvas.
Audits a Cursor plugin's manifests, metadata and discovery paths for marketplace readiness before publishing.
Catches you up with a short subtitled slide video plus the decisions waiting on you.
Runs only when you type /ketchup-video
Runs a task in repeated autonomous iterations until it is finished.
Builds a personalized learning roadmap with milestones and practice checkpoints.
Reviews learning progress, finds blockers and adjusts the learning plan.
Stops or aborts a running Ralph Loop.
Explains how the Ralph Loop plugin works and shows usage examples.
Reproduces triaged bugs, verifies fixes, and opens a draft pull request only after before-and-after proof.
Runs only when you type /reproduce-and-fix-issues
Triages Slack issue reports with evidence review, cause-aware routing, duplicate checks and careful ticket creation.
Runs only when you type /triage-issue-reports
Configures Benny and its triage and reproduction automations, including Slack, tracker, repository and budget settings.
Runs only when you type /setup-benny
Points questions about the Cursor Origin API to the right docs and key rules.
Plans how to port an existing GitHub App to a Cursor Origin App and writes a brief.
Consults a stronger or different model at key checkpoints for a second opinion.
Adds a mic button that turns speech into text in your app using Grok speech-to-text.
Adds a read-aloud button so your app speaks text using Grok text-to-speech.
Adds logging to a Grok voice session and fixes issues by matching logs to your report.
Wires Grok realtime speech-to-speech voice mode into your app with safe auth and mic setup.
Questions a requirement, then deletes, simplifies, optimizes and automates it in order before designing the change.
Runs only when you type /principle-the-algorithm
Implements a Figma design into your UI, mapping it to your own design system.
Applies a concise, verification-first working style with strict merge gates to coding tasks.
Runs only when you type /dyl-mode
Reviews pull requests and gives a short list of fixes plus a green, yellow or red verdict.
Runs only when you type /dyl-review
Reviews a pull request, resolves conflicts and watches CI until it is ready to merge.
Runs only when you type /dyl-ready-pr
Runs a full compatibility pass over the repository, covering scanner, startup, validation, and docs.
Checks what limits a measured number and rules out measurement error before trusting or reporting it.
Runs only when you type /principle-explain-the-number
Keeps a row-per-decision log of what was done, why, the evidence and the result for long unattended runs.
Runs only when you type /show-me-your-work