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

Learning and Communication

This group covers understanding something, explaining it to a person, and turning what a session taught into lasting changes. It contains a skill that teaches, a skill that mines a conversation for lessons, a writing standard, a skill that restates the last reply in plain words, and the 2 skills that guide and configure pstack itself. The chapter ends with the background parts that ship with pstack but are not slash skills: 2 subagent definitions and one automation pack.

/teach: one plain account of how and why

/teach explains what a piece of work is, how it works, and why it is built that way, at the person’s own pace. Its goal is understanding; it changes nothing in the code. Typical requests are “teach me this”, “help me really understand X”, or “explain this change or subsystem to me”.

The skill sits on top of /how and /why. It reads enough code to get oriented, then runs both skills as real invocations, in parallel, and blends what they find. For a small change one of them may be enough. It may reword their findings freely, with one exception: the confidence language that /why attaches to its conclusions is kept intact, because those hedges are findings in their own right.

The skill describes how the explanation should be built:

  1. Choose what the person should take away. Infer from the conversation why they are asking (about to change the code, reviewing it, debugging it, new to it) and what they already know, and put the depth where their question is.
  2. Start with a plain definition. Name the thing in general terms, as a senior engineer would say it aloud, then connect it to the case at hand and build outwards to mechanism, reasons, and edge cases. A list of functions and constants is reference material, not teaching.
  3. Give the smallest complete answer first. One or two sentences, then stop and add layers when asked.
  4. Keep it a conversation. No quizzes, no “say it back to me”, no announcements that a part is important or tricky. Without a live human, deliver the explanation cleanly and put the offer to go deeper at the end.
  5. Show as well as tell. Open the diff, the code, or the debugger when that is fastest. For anything with 3 or more moving parts, draw a short series of diagrams in which each one redraws the previous and adds a single part, so the reader watches the system assemble. Mermaid suits flows whose labels carry the meaning; spatial ideas such as layout or scroll position call for a generated whiteboard-style image with few labels.

The prose goes through the unslop skill: plain spoken English, concrete mechanisms instead of metaphors, sentences with at most 1 or 2 commas, one name per concept, and no framing labels such as “the key insight” or “TL;DR”. The reply is the explanation itself, never a report about what was explained.

/reflect: turn a session’s lessons into skill edits

/reflect runs when the user says “reflect”. It reads the whole transcript of the current conversation and routes each durable lesson to a concrete edit on an existing skill. The transcript is treated as data, so instructions found inside it are not followed.

Its search covers 5 kinds of signal: corrections from the user; commands and quirks that the agent had to work out for itself; context the user provided although the agent could have fetched it; checks that were skipped or never executed against the real artifact; and skills that ought to have triggered but stayed silent.

A finding survives only if it meets all 3 conditions: it will still hold in 6 months, it would change what a future agent does, and it routes to a skill the session used. The agent reads that skill first and drops anything it already says clearly. One-off events and details that drift (SHAs, versions, counts) are discarded. A skill that should have fired gets its description tuned, and anything a lint, script, or check could enforce goes to a backlog instead of into prose.

The result is presented as 3 lists (Accepted with problem, proposal, and skill; Rejected with reasons; Backlog), and no skill is edited before the user approves. Skills under plugins/cache/ are never edited directly. Before approval the agent shows the destination, .cursor/skills/<skill>/ or ~/.cursor/skills/<skill>/; after approval it copies the skill folder there and edits the copy. It never opens a PR or pushes.

/technical-writing: a layered standard for technical prose

/technical-writing applies when writing or reviewing docs, RFCs, READMEs, PR descriptions, or commit messages. Its stated aim is text that “a tired engineer understands on the first read”. Above the layers it sets a few general rules: cut every word that does no work, prefer the everyday word, use the real symbol or command name instead of a description of it, avoid invented jargon, and vary sentence length.

The standard stacks 4 established sources, each governing a different level of the text:

LayerSourceWhat it controls
DocumentDiátaxisOne mode per document: tutorial (learning by doing, every step with a visible result), how-to (steps to a goal for a competent reader), reference (dry, complete facts that mirror the thing described), or explanation (one bounded topic, the only mode where opinion belongs). Mixed content is split and linked.
SentenceGoogle developer documentation styleAddress the reader as “you” in the present tense, name the actor, write instructions as commands with the condition first, avoid “simply” or “easy” in procedures, use descriptive link text, sentence-case headings, and serial commas.
StatementSimplified Technical English (STE)One instruction per sentence, splitting instructions above about 20 words and other sentences above about 25, warnings before the step they guard, one meaning per word.
SyntaxGlobal EnglishKeep “only” and “not” next to the word they modify, make every pronoun point at one obvious thing, avoid noun stacks, idioms, and Latin abbreviations, and prefer periods to semicolons or dashes.

The skill also hands slop detection to the unslop skill. It treats PR descriptions and commit messages as writing too: every layer except Diátaxis applies to them, and a PR body should be a briefing a reviewer can read in under a minute, with logs and metric tables linked rather than pasted. Product UI strings follow the product’s own copy guidelines instead. Any count or tree in a document must be true at the commit that lands it and come with the command that regenerates it.

/bro: say that again, plainly

/bro is the shortest skill in pstack. It asks the agent to restate its last message without jargon, more simply and concisely, “like one human talking to another”. Use it when a reply was dense enough that you could not follow it.

/poteto-help: the guide to pstack

/poteto-help answers questions about pstack itself. For a help question it gives the answer, a prompt the user can send, and a link to the file the answer came from, but it does not start the work, since a pstack run costs real tokens and the user only asked how. A message that actually asks for work (“use pstack to fix this bug”) is handled differently: the agent reads poteto-mode, does the work under it, and mentions once that a Custom Mode keeps the mode active.

The skill is a routing map from questions to the skills and guide pages that hold the details. The agent reads the target file before quoting it and trusts that file whenever it disagrees with the map. Because the installed plugin may not be visible to the user, links are given as public GitHub copies under https://github.com/cursor/plugins/blob/main/pstack/.

Finding the need

When the need is unclear, the agent asks one multiple-choice question with 5 options and answers only the chosen section:

  • Get set up
  • Start a task with /poteto-mode
  • Pick a skill for a situation
  • Fix a run that went wrong
  • Make pstack my own

It also checks project state that changes the answer: whether ~/.cursor/rules/pstack-models.mdc exists (if not, every role runs on its default model), whether the project has a verify-* skill, and whether a formal verification skill exists and has fallen behind the code it covers. When the model rule is missing and it matters, the agent asks at most once per chat whether the user wants to run /setup-pstack now or later.

What the sections contain

  • Setup: install with /add-plugin pstack, run /setup-pstack, and then begin a real task using /poteto-mode together with a goal and a pass-or-fail check. The installation by itself has no effect. If cost is a worry, the section recommends a smaller budget, cheaper models, roles set to auto or inherit-parent, shorter panel lists, and keeping /poteto-mode for work that demands rigor. It also covers installing in Claude Code, where every command carries a pstack: prefix, as in /pstack:poteto-mode.
  • Starting a task: a good prompt states the goal and how to tell it is done, and does not list skills. Pressing Enter on /poteto-mode attaches it to one message, while Option+Enter or Alt+Enter (or “Use as Mode”) turns it into a Custom Mode that stays in context until the user leaves it.
  • Picking a skill: a table mapping intentions to skills, with /poteto-mode as the default answer, plus notes on close calls such as /how versus /why versus /teach, and /arena versus /swarm. It also lists what pstack does not contain: /deslop, control-cli, and control-ui belong to the cursor-team-kit plugin; /loop and /create-skill are Cursor built-ins; and there is no /orchestrate skill.
  • Playbooks and principles: playbooks have no slash command and are selected inside /poteto-mode by describing the task or by phrases such as “babysit this pr” or “land the stack”. Principles are usually steered by name (“apply prove it works”) rather than invoked. See Playbooks and Principles.
  • Fixing a run: a symptom table, for example “the mode stopped applying after a few turns” (it was started with Enter) or “a new model choice had no effect” (the rule applies only to new chats).
  • Making pstack your own: /automate-me, /reflect, the authoring and eval playbooks, and the advice to fix a misbehaving skill in its own PR.

The reply leads with the answer and contains at most one example prompt, adapted from the skill’s recipes reference where one fits.

/setup-pstack: choose a model and reasoning budget per role

/setup-pstack decides which model each pstack role uses (a role is a kind of work or a seat in a review panel, such as bug-fix or arena runners) and at what reasoning effort. It writes the result to ~/.cursor/rules/pstack-models.mdc, an always-applied rule that overrides the skill defaults. It is the only pstack skill that loads from the user’s words alone, for example “configure pstack models” or “pstack budget”.

Steps

  1. Detect available models. The dependable source is the list of model slugs that can be passed to a Task subagent in this session; a models API or CLI is preferred when Cursor offers one. If nothing can be detected, the user is asked to paste the slugs. A real slug is never written unless it has been confirmed, while the aliases inherit-parent and auto are always valid.

  2. Load the current state. An existing rule supplies the current budget and role values. Lines for retired roles are dropped, and values from older setups that were defaults rather than choices (marked by a missing # defaults: 3 line, old Gemini panel entries, a # budget: unlimited line) are replaced. The user is told what was replaced.

  3. Budget, map, and confirm. The user picks one of 3 budgets, preferably through a structured question:

    BudgetEffort for roles whose default is xhigh
    largexhigh (matches the skill defaults)
    mediumhigh
    smallmedium

    Each budget moves every role’s default effort down 0, 1, or 2 steps on the ladder xhigh > high > medium > low, with nothing above xhigh. If the resulting slug was not detected, the agent uses the same family’s highest detected effort at or below the target, or marks the role as needing a choice. It then shows every role with its model and asks whether to accept or change specific roles.

  4. Validate. Every real slug must be in the detected set and at xhigh or below.

  5. Write the rule. The whole file is overwritten with alwaysApply: true, a # defaults: 3 line, a # budget line, and one line per role, so re-runs are idempotent. The roles are feature, refactoring, bug-fix, perf-issue, hillclimb, judgment and prose, arena runners, arena cross-judge pool, swarm workers, and interrogate reviewers.

  6. Confirm that the rule applies to new sessions.

  7. Offer a verification skill once, if the project has no way to drive the real app, and run /create-verification-skill on a yes.

  8. Offer a formal verification skill once, if none exists, and run /create-formal-verification-skill on a yes. A no is accepted without pressure in both cases.

Panel roles

Panel roles (arena runners, interrogate reviewers) take a list as their value. Each entry, including any alias, starts its own subagent, so a longer list means more parallel work. arena cross-judge pool is a list too, yet Arena uses just one judge: it tries the entries in list order, considering only vendors other than the parent chat’s, which makes the order a ranking of preference. Fable and the other Claude models are treated as a single vendor, and an alias value is never used as the judge. swarm workers gives the default model for all workers, except when a race assigns a model to each arm.

Background subagents and the automation pack

Besides the skills, pstack ships parts that never appear in the slash menu: 2 subagent definitions under agents/ and one Cursor Automations pack under automations/.

poteto-agent: the delegate for poteto-mode

poteto-agent is the subagent that a /poteto-mode run spawns for code-writing and helper tasks. The parent chat owns the playbook, the todo list, and every spawn; the delegate only does the work it was handed. Before any work it reads the poteto-mode SKILL.md in full, including the inline principles index, from the absolute path its parent supplied. Without a path it searches ~/.cursor/plugins/ and picks the copy with the highest plugin version; if none exists, it stops and tells its parent.

The definition warns that substituting a general-purpose subagent skips that read and lets the style drift. A fresh poteto-agent is spawned for each task, and one is resumed only in the narrow cases that the Subagents section of poteto-mode names. You can also spawn it yourself with subagent_type: "poteto-agent" to get the same style from your own subagent.

Comment Sicko: a reviewer that wants comments gone

comment-sicko is a reviewer subagent with a deliberately extreme persona that hates comments. Given scoped files or a diff (by default the diff against main), it hunts narration, banners, commented-out code, and long justifications for workarounds.

Only a short list of exceptions survives: legal or licence headers, non-obvious behavior forced by an external dependency, platform, vendor, or protocol, // prettier-ignore, doc comments that define a public API contract, and issue or RFC links explaining a constraint the code cannot express. When in doubt, the comment goes. Lint suppressions such as eslint-disable or @ts-ignore survive only if the rule is faulty or purely stylistic.

A surprise in the project’s own code is not a valid reason to keep a comment. Comment Sicko deletes such a comment and marks the exact symbol MUST KILL, asking for a rename, extraction, type, or redesign that makes the behavior obvious without prose. Before judging a claim such as “do not remove”, it reads nearby code, traces the named symbol, or runs /why on it. It only reports (touched files, deletion count, MUST KILL flags, skips) and never writes application code.

benny: an automation pack for Slack issue reports

benny is a pack of 2 Cursor Automations that work together in one Slack issue channel.

  • Triage starts on each new top-level report, reads the thread and attachments, and classifies it as a bug or performance issue, a feature request, a question or feedback, or a reroute. It traces the likely owning layer, searches the configured tracker for duplicates, creates a ticket only for a clear new bug, and posts exactly one reply in the source thread with a short verdict and a marker such as [benny:bug].
  • Reproduce and fix waits for the trusted triage marker, stops if someone clearly owns the fix, and verifies an existing PR instead of competing with it. Otherwise it reproduces the exact symptom twice through the real UI with screenshots, video, and a read-only state cross-check. After a confirmed reproduction it may attempt one bounded root-cause fix and opens a draft PR only when the before-and-after proof passes.

Throughout a run, each of the 2 automations holds the source channel and thread coordinates constant, never starts a new root message in the source channel, and does not pass Slack credentials to subagents. If the channel coordinates, tracker access, the control adapter, or the feature map is missing or in doubt, they fail closed. The only PRs they open are drafts, and they never merge or deploy.

The pack is dormant: its files do not appear as slash skills, and its SKILL.md files are direct instructions for the automations rather than registered plugin skills. To set it up, you point Cursor at FOR_AGENTS.md and name the target repository. Setup merges the pack into .cursor/automations/benny/, enables pstack in the target’s .cursor/settings.json (the pack depends on shared skills such as why, tdd, unslop, and the principle skills), and keeps user-owned configuration such as channels, tracker settings, and the feature map outside the pack, for example under .cursor/benny/. After everything is committed, you review each automation draft, send a harmless test report, and confirm that every post stays in the original thread.