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

Using /poteto-mode

/poteto-mode is the front door to pstack. It takes a goal, matches it to one of 22 playbooks, copies that playbook’s steps into the todo list, and calls the other skills as each step needs them. This chapter covers how to start it, how to write a prompt for it, the rules it follows while it works, and how to steer, pause, and resume it.

Starting it

In Cursor, pick /poteto-mode from the / menu before you type the task, so that Cursor attaches the skill to the message. Plain Enter attaches it to that one message only, and its influence fades as the chat moves on.

If you want it active for the entire chat, select it from the menu and confirm with Option+Enter (Mac) or Alt+Enter (Windows) rather than Enter. The skill then becomes a Custom Mode: it remains in context on every turn until you exit the mode. Custom Modes are available in Cursor’s Agents Window and CLI. Claude Code uses the command /pstack:poteto-mode.

The README also notes that /poteto-mode works well with Cursor’s built-in /loop command, which lets an agent keep working for many hours. /loop is part of Cursor, not a pstack skill.

Writing the prompt

You do not write a specification. You state what is wrong or what you want, the way you would brief a colleague. The guide lists up to 5 elements of a useful prompt, each of which fits in one sentence:

ElementWhat it means
The goalWhat is wrong, or what you want.
The done checkA condition that can pass or fail. “Make it better” and “work on it for an hour” are not checks.
The proof you wantOutput from a real command, a recording of the flow, the value as stored, or a number measured before and after.
What you already knowA symptom, a repro step, a log line, or a link; each one saves the agent a search.
The real constraintsPhrases such as “repro first”, “don’t change any code yet”, “zero behavior change”, or “let me review before proceeding”, each of which changes what the agent does.

The guide’s example contains all 5:

/poteto-mode the csv export drops its last row since yesterday's deploy. failing job id is 4812. repro first, then fix. done means the 60k-row fixture exports every row. show me the row counts before and after.

What to leave out

Two things are better left out of the first prompt.

  • The method. Describe the outcome you need and let the agent look for a route that may be better than the one you had in mind.
  • Your theory of the cause. A stated guess narrows the search to wherever you pointed. Let the agent restate the problem first; if it has misread something, the misreading shows up before any code exists and costs one message to correct.

When the input is noisy, for instance a long thread or a loosely described bug, ask for the restatement before anything else:

/poteto-mode read this thread. restate the underlying issue in your own words, in plain english. don't change any code yet.

If you want only the restatement, without a playbook, use /in-your-own-words.

Do not list skills in your prompt. A hand-written sequence such as “use /architect, then /arena, then /interrogate” tends to reorder or drop steps that the playbook would have kept. Name a skill only when you want to override one specific choice.

If you are unsure whether a prompt is aimed correctly, run /sharpen on it first. It describes what a top professional would do that you did not ask for, the raw material and methods they would use, and an outside check on the result, then hands back a rewritten prompt that is deeper rather than longer. It does not carry out the task; you read the rewrite and send it yourself.

Short follow-ups and new tasks

Once the chat already holds the context, a follow-up can be tiny: “/poteto-mode do it”, “continue”, or “keep going until done” are all enough. Short prompts work because the playbook holds the structure.

A long chat accumulates context from the previous task. When you change subject, say “new task”, which makes /poteto-mode match a playbook again instead of continuing the old one:

/poteto-mode new task. figure out why the cache entry survives logout. don't change any code yet.

Here “don’t change any code yet” also pins the new task to the Investigation playbook. Without both phrases, an agent in the middle of a feature tends to treat your question as the next feature step.

What happens after you send it

The sequence is fixed:

  1. On the first message, the agent restates your goal and the smallest change that meets it, then proceeds.
  2. It reads the principles index and matches the task to a playbook.
  3. It opens the playbook file and copies its steps into the todo list first.
  4. It works through the steps, calling skills as they fire, and names in its reply each principle that shaped a decision.

The common routes are:

Kind of taskPlaybook
A read-only questionInvestigation
A defectBug fix
New or changed behaviorFeature
A change to structure onlyRefactoring
Measured slownessPerf issue
Large, cross-cutting, or unattended work, or no matchthe figure-it-out skill

The remaining playbooks cover hillclimbing a metric, runtime and trace forensics, prototypes, visual parity, authoring and evaluating skills, babysitting a PR, shipping a verified stack, autonomous runs, the two autopilot modes, session pickup, pausing, multi-phase plans, worktree cleanup, and opening a PR. The chapter Playbooks covers each.

The rules it works by

/poteto-mode carries a short list of fixed triggers, which it calls its non-negotiables. A few of them explain much of its behavior:

  • Prototype instead of asking. A decision that running something could settle is prototyped (the Prototype playbook) instead of being put to you.
  • Data shape first. Before code, it names the data shape. Code that crosses a function boundary goes through /architect; fan-out goes to /swarm, a bake-off to /arena, and a contested design to /interrogate.
  • Prose is cleaned. Every piece of prose, the reply included, goes through /unslop; docs, PR descriptions, and commit messages also go through /technical-writing.
  • Before commit and review. It runs /deslop (from cursor-team-kit) before committing and /no-comments before review.
  • Numbers are vetted. Any number it measured goes through /benchmark-checklist.
  • Long work leaves a trail. Long or unattended work keeps a /show-me-your-work decision log.
  • Bot review comments are judged one by one on their merits.

Its replies follow a style rule as well: short declarative sentences, the change for the user first, and every claim labeled with its evidence or as measured, inferred, or a guess. It must never hand you a check that it could run itself. And it is allowed to say no: asked whether to add scope or shown an approach, it gives its real judgment, including “this doesn’t earn its place” when that is true.

Autonomy and the irreversible line

The default is to act. Reversible work and routine external actions (team chat, ticket updates, starting evals) proceed without asking. The agent always pauses before irreversible writes: a force-push to a shared branch, a deploy, data deletion, or a message to a customer.

Phrases such as “don’t stop”, “going to bed”, “run until done”, or “be fully autonomous” are session overrides: they tell the agent to keep going without checking in. They do not remove the pause before irreversible actions.

Steering a run

Because /poteto-mode names the principles behind its decisions, the most efficient correction is to name one back, for example “this doesn’t meet Prove It Works”. A principle name is shorter and more precise than a paragraph of instructions. The chapter Principles lists all 24.

You can also add a constraint mid-run. “Let me review before proceeding” switches the agent to waiting for your approval at that point.

Running agents in parallel

Several agents working in one repository on one machine will compete for the working tree, the ports, and the build output. The guide gives two ways to isolate them:

  • Cloud subagents. Every cloud subagent runs on a dedicated VM and branch, which lets it install dependencies, start the app, and capture video while your own machine stays untouched. Either put /in-cloud in front of the task, or tell the parent chat to delegate work to cloud subagents.
  • Worktrees. When the work must stay local, ask for a fresh worktree and branch per task. Worktrees cost disk space, so a laptop runs only a handful at once. The Opening a PR playbook already works from a worktree for code changes.

When worktrees pile up, the Worktree cleanup playbook classifies each one by merge state, uncommitted work, and which chats still use it. It deletes only what that evidence clears and waits for you on anything holding uncommitted work.

Delegation inside a run

The chat that receives /poteto-mode runs the playbook itself. Any subagent it spawns directly in a playbook step uses the poteto-agent type, except where a routed skill such as /swarm or /interrogate sets its own type.

Every agent it starts receives a kickoff whose first line tells it to read worker.md. That file states the rules a worker follows for the operator, the person the whole run works for. Among them: the bar stated in the kickoff is the whole bar; reversible choices are made and explained instead of being asked about; PRs are opened ready for review, never as drafts, with a type(scope): subject title and a body of at most 40 lines.

The parent owns every subagent’s work: it reviews the diff and writes its own summary. Fix rounds, follow-ups, retries, and the next queue item go to a fresh subagent, which receives the original brief, every later directive, and the previous agent’s report and branch. An existing subagent is resumed only when the work depends on state that lives in it and is costly to move, such as its checkout, its uncommitted changes, or a process it is still running.

Pausing and resuming

To stop on purpose, tell the agent to pause, or that you are about to go offline or restart Cursor. The Pause safely playbook then:

  1. stops at a safe boundary, finishing or backing out of the current step and canceling nested subagents;
  2. takes no irreversible action to pause (no new PR or push);
  3. commits uncommitted edits as one wip: commit on the current branch;
  4. writes a resume note covering intent, progress, what is verified, next steps, key files, and pitfalls.

The pause is explicit only: “keep going” or “going to bed, keep going” never triggers it.

A fresh chat resumes the work through the Session pickup playbook. It reads the previous agent’s trail (a transcript in the active workspace, a cloud agent URL, or a pushed branch), treats that trail as authoritative, and names the resume point without redoing finished work. It then hands the rest to the matching playbook and verifies the inherited claims on the real artifact, because a passing self-report from the previous agent is not proof.

For long or unattended runs, the /show-me-your-work decision log makes the work reviewable when you return. The chapter Running work while you sleep covers that in detail.