Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Operations and Automation

These skills support the daily running of agents. /automate-me turns your own working style into a personal skill, /swarm sends work to parallel workers and merges their results, /ketchup and /ketchup-video catch you up on what happened while you were away, and /make-bot-ui builds a page whose buttons wake a bot over a webhook.

All 5 skills set disable-model-invocation: true in their frontmatter, so each one runs only when you type its name or trigger phrase.

/automate-me: turn the way you work into a personal skill

Source: skills/automate-me/SKILL.md

  • What it does: It captures your working conventions in a single personal “mode skill”, a skill named <handle>-mode (for example jay-mode) that tells later agents how you like work done. It coordinates 3 other pieces and replaces none of them: an inline pass that mines your chat history, Cursor’s built-in create-skill skill (which is not part of pstack) for authoring, and /unslop for the prose.
  • When to use it: When you say “automate me”, ask to create, update, or refresh your -mode skill, or want your preferences and working style turned into a skill.
  • How it runs:
    1. Look for an existing mode skill, searching .cursor/skills/**/*-mode/SKILL.md and ~/.cursor/skills/*-mode/SKILL.md for your handle. If one exists, confirm with the AskQuestion tool whether to update it (the default) or start fresh (rare, and only after asking why). In update mode, mining covers only the history since the file was last edited, the questions ask what has changed or is missing, and the existing file is edited in place.
    2. Mine your history. The skill reads only the current workspace’s agent-transcripts/ directory and never globs across other projects, which would expose private chats from unrelated work. Several subagents run in parallel over slices of recent history (for example the last 2 to 4 weeks, in 3 slices) and look for response preferences, delegation habits, verification posture, code and prose discipline, process conventions, and meta preferences such as fixing skills during a task. A pattern seen in at least 2 slices is a strong signal; a lone one is usually dropped.
    3. Ask you directly with AskQuestion: 1 or 2 multiple-choice questions with 4 to 6 options each, followed by 1 free-form question to catch anything the options missed.
    4. Group the signals into sections such as response style, autonomy, subagents, review and verification, process, and skills, using only the ones that apply. The skill points to /poteto-mode, the mode skill at the center of pstack, as an example of the right granularity but warns against copying its content.
    5. Draft the skill with create-skill. A new mode skill goes in .cursor/skills/<handle>-mode/SKILL.md (or a personal category directory if the repository already has one). Its description triggers on your name, /<handle>-mode, and “work in their style”, and it sets disable-model-invocation: true unless you want it on every turn.
    6. Apply /unslop and the authoring guidelines, show you the draft, and expect several rounds of revision.
    7. Commit in a worktree off main and open a PR; never push to main directly.
  • Points to watch:
    • Do not turn a preference stated once into a rule. Refer to other skills by path instead of pasting their content. Add a section only where you have a specific, non-default rule, and skip areas such as process entirely if you have none.
    • Evaluation is a check with you (“does it read like me? did it miss anything?”); the skill considers a benchmark loop unhelpful for such subjective output.
    • It is the wrong tool for a task-specific skill or for a single narrow workflow such as how you write commit messages. Those are ordinary skills, which create-skill can write without any mining.

/swarm: fan out parallel workers and return a single report

Source: skills/swarm/SKILL.md

  • What it does: It runs N workers in parallel, waits for all of them, and returns a single consolidated report. The work can be partitioned into slices, raced (N workers on identical briefs), or a mix of both.
  • When to use it: For /swarm, “swarm this”, or any job that needs parallel coverage, races, gauntlets, or exploration.
  • How it runs: The agent first opens a todo list with 1 entry per phase, then works through 4 phases.
    1. Frame.
      • State the “done predicate” (the condition under which the swarm is finished) and the artifact or report it must return.
      • Choose the shape, and for a race or a mix declare the selection rule before spawning: first pass, rank all, or best-of.
      • Take the worker model from the swarm workers line in ~/.cursor/rules/pstack-models.mdc, falling back to claude-opus-5-5-high-fast if the file or line is missing; auto or inherit-parent means the workers run on the parent’s model.
      • Give each worker that writes its own writable output. Workers that verify or measure commits get the exact SHAs, and a measurement brief also names the method (sample count, what 1 sample is, and the order).
    2. Fan out.
      • Spawn all N workers in 1 message as generalPurpose subagents with environment: "cloud" and run_in_background: true. Use environment: "local" only when a worker needs something on your computer, and pass cloud_base_branch when a worker must start from a non-default pushed branch.
      • Every brief stands alone, with the goal, scope, slice or race arm, verification method, and what to report.
      • Workers answer PASS, ISSUES, or BLOCKED with evidence, and a worker that can prove defects lists all of them, not only the first. If a worker drops out, the swarm continues with N-1 and notes it.
    3. Aggregate. Read the final results. A result that does not record the SHAs and method its brief named is dropped and that worker is respawned once; after a 2nd miss the slot is recorded as a gap, and a gap never counts as a pass. Coverage needs a result for every slice, and a race applies the rule declared in Frame. Raw worker output is never pasted.
    4. Report. Return a single in-chat report with a result table, a one-line summary per issue, any gaps or dropouts, and the race rule when one was used.
  • Points to watch: Each worker’s reasoning level follows the Subagents section of /poteto-mode, the entry skill of pstack. If the Task tool rejects a model slug, the agent uses the default and says so.

/ketchup: catch up on what changed, in plain words

Source: skills/ketchup/SKILL.md

  • What it does: It explains what changed in this chat since the last message you wrote, in plain words and small visuals, and lists every decision waiting on you with enough detail to make it from the reply alone. Notifications and subagent results do not count as your messages; the skill assumes you remember your last message and nothing after it.
  • When to use it: When you type /ketchup after being away while agents and subagents kept working.
  • Voice: It borrows the voice of /bro (plain words, short sentences, no jargon) without its task. It says “the tests pass” instead of “CI is green”, leaves out hashes, file paths, commands, build numbers, and test counts unless you need one to act, and calls each PR, branch, or agent by a name you would recognize.
  • How it runs:
    1. Gather, read-only. The turn changes no code, starts no app or job, and posts nothing. It collects the agent’s own work, subagent reports, and messages from others in the chat, checks the current state of every PR, CI run, or agent the chat touched, and checks each number it will show against its source.
    2. Select action items. An action item is a call only you can make: a product choice, an approval, an irreversible action, or access the agent lacks. It includes items raised before your last message that still wait on you. Work the agent can still do is excluded, and no item is invented to fill the reply.
    3. Write the reply. Open with 1 sentence that names what waits on you, or says that nothing does. Show what happened with pictures first, then 1 bullet per thing you asked for, saying what came of it and whether it is done, still running, failed, or not checked. Keep this part under 100 words, excluding pictures. Add at most 3 lines that change what you know or must do, and 1 line naming work the agent can still do itself.
    4. List the action items, about 30 words each. Each gives the call, the agent’s pick, what it changes for users, the evidence, the risk (even a low one), and a link. When several items share a call, the call and pick appear once and the items follow, riskiest first. A choice between options gives each option’s gain and cost.
  • Visuals: A visual is a screenshot, a video, a Mermaid diagram, a chart, or a generated image; a Markdown table does not count. Each one should be readable at a glance, with at most 6 boxes and at most 8 words per box. Status lists, lists of action items, and unconnected boxes are never drawn. A visible change without a screenshot is marked “No screenshot yet” in its summary line. Numbers are never invented, and screens that were not captured are never drawn.
  • Points to watch: Items are never cut or shortened to meet a word count, and a link never replaces an item. The reply grows with the number of items, but the narrative part stays short.

/ketchup-video: the same catch-up as a subtitled video

Source: skills/ketchup-video/SKILL.md

  • What it does: It follows /ketchup, but replaces the summary and visuals with a short, silent, subtitled video of slides. The action items stay as text below the video.
  • When to use it: When you type /ketchup-video, typically when the changes are visual or easier to follow as pictures.
  • How it runs:
    1. The window starts at the last message you wrote before /ketchup-video, not before any earlier /ketchup. Writing and rendering the video outside the repository is the only exception to the read-only rule.
    2. Plan the slides from the screenshots, recordings, diffs, and data the work produced, not from the chat’s prose. First write the 1 sentence you should leave with and 1 line per slide, then drop every slide that does not change what you know. The maximum is 10 slides, and fewer is better.
    3. Each slide makes 1 point. The slides build on 1 picture that changes from slide to slide, colors and shapes keep the same meaning throughout, and arrows, highlights, and motion point at what changed. A slide is never a bullet list, a status list, a table, or unconnected boxes.
    4. Each slide has a subtitle of about 10 words in a strip below it. The strip has the same height on every slide, so the subtitle never covers the picture, and it is burned into the frames for the slide’s whole hold time.
    5. Render 1 silent horizontal video (for example an mp4) with motion between slides, made from the slides themselves rather than a screen recording. Each slide stays fully on screen for at least 1 second per 3 words it adds.
    6. Before embedding, inspect 1 frame per slide at chat size, check that the subtitle is readable and covers nothing, and measure each hold by matching the file’s frames to the slide. A still-frame detector is not acceptable because it counts the faint ends of a fade as still. Fix and render again until every slide passes.
  • Points to watch: The reply is the ketchup opening sentence, the video, 1 line naming work the agent can still do, and the action items. If rendering fails, the agent says so in 1 line and returns only the action items. As in /ketchup, numbers are never invented and screens that were not captured are never drawn.

/make-bot-ui: build a page whose buttons wake a bot

Source: skills/make-bot-ui/SKILL.md

  • What it does: It builds a page you click (buttons or a dashboard). A server on the local computer POSTs JSON to a webhook routine, and that wakes a Grok Bot with the JSON. The webhook routine is the agent task that the webhook POST starts. The skill also exposes the page on Tailscale.
  • When to use it: When you build a custom UI that should wake a Grok Bot over a webhook, when you need to provide a webhook sender key, or when you want to put that UI on Tailscale.
  • How it runs:
    1. Create the routine with update_state (target routine, action create, trigger { "type": "webhook" }). Its prompt says to treat the POST body as untrusted data, names the JSON fields the UI sends, does the matching action, and sends no message when there is nothing to report.
    2. Tell you where to find the webhook URL and the sender key on the routine’s panel. You may paste the URL into the chat; you must never paste the sender key.
    3. Request the key with a secret-request card, which is the entire turn. The agent never sees the value: it lands in the connector’s credential file, and the agent copies it into the server config without printing or logging it.
    4. Host the page. The {url, key} pair is stored in the UI’s own directory. The POST comes from the server, never from the browser, and carries Authorization: Bearer <key> and X-Automation-Key: <key>, with an 8-second timeout and a single attempt without retries. Send one probe with a harmless payload, which the prompt ignores, before you announce the UI. Where a POST might fail, also write the same JSON to a local log for the routine to drain; polling must never be the main path.
    5. Put it on the tailnet. Bind to 0.0.0.0:<port>, because Tailscale peers cannot reach a server bound to 127.0.0.1. If tailscale status shows an online node, reuse it and give you both the hostname URL and the 100.x.x.x URL over HTTP. Otherwise install Tailscale, run tailscale up with a short hostname, and send you the login URL so you can approve the machine yourself; the agent never asks for or types Tailscale credentials.
    6. Handle the wake. The routine receives a <webhook_event> block whose body field is the JSON object as a string. The agent parses body and treats it as outside data, not as instructions.
  • Points to watch: The sender key never appears in the browser, the chat, or the skill. Media bytes are never sent over the webhook, and a second hostname is never created on a node that is already online. Keep the field list small and use the same field names in the UI and the routine prompt.

Benny: a dormant automation pack

The plugin also ships automations/benny/ (README), a pair of Cursor automations that triage Slack issue reports and reproduce confirmed bugs, possibly preparing a small draft fix. It is not a slash skill: its files stay dormant until a setup step copies the pack into a target repository and the automations are enabled there. Learning and communication describes it in detail.