---
title: "pstack"
date: 2026-10-20
url: https://blog.duyet.net/note/pstack
---

[pstack](https://github.com/cursor/plugins/tree/main/pstack) is a set of agent skills from [poteto](https://x.com/poteto) (Lauren Tan). I am collecting the parts that help me run many agents in parallel, keep the quality, and trust the result more. The idea is to go deep on one agent first, trust it, then parallelize.

This is a cheat sheet grouped by what you want to do. Almost everything is one command, `/pstack:poteto-mode`.

## Why this matters

Running more agents is easy. Trusting what they produce is the hard part. Without that trust you review every line, and you become the bottleneck. More agents then means more babysitting, and the extra output is mostly slop.

pstack attacks the trust problem, not the speed problem.

- **Verification replaces line-by-line review.** An agent that can run your app and prove its own work lets you check outcomes, not diffs.
- **Agents stop compounding mistakes.** Banning workaround comments, adding lints, and encoding repeated corrections stop one agent's hack from becoming the next agent's pattern.
- **Better decisions before code.** Prototypes and competing designs settle questions with evidence, so you do not build the wrong thing fast.
- **Scale comes last.** Once one agent is trustworthy, you can run many with confidence. She reports about 2,000 to 2,500 PRs a month to production this way. That number is self-reported, so treat it as a claim and not as a benchmark.

These skills are worth learning even if you never install pstack.
- They are small. Principles are 10 to 20 lines, and most skills are a short list of steps.
- They come from real corrections. Many principles were extracted from months of fixing agent mistakes.
- They transfer. A verification skill with a feature map, a ban on workaround comments, and prototype before plan work with any agent and any model.
- They compound. Each step makes the next one safer, which is why the order below matters.

## Install

```bash
/plugin marketplace add cursor/plugins
/plugin install pstack@cursor-plugins
```

Run `/pstack:setup-pstack` once to pick models and a reasoning budget.

## Adopt it one step at a time

Do not turn everything on at once. Add one step, use it until it feels normal, then add the next. Each step builds on the one before, so the advantage grows over time.

| Step | Add | What you get |
|---|---|---|
| 1 | Prefix prompts with `/pstack:poteto-mode` | Rigor by default. The agent picks a playbook, proves its work, and names the principles it used. |
| 2 | `/pstack:create-verification-skill` | The agent can run your app and check its own work, so you stop babysitting. |
| 3 | `/pstack:in-your-own-words`, `/pstack:teach` | You catch misunderstandings before any code, and you keep a mental model of the codebase. |
| 4 | Prototype playbook, `/pstack:architect` | Better designs, decided by evidence and not by abstract plans. |
| 5 | `/pstack:swarm`, `/pstack:arena` | Several agents at once without losing quality, because step 2 verifies each one. |
| 6 | `/pstack:no-comments`, `/pstack:correct`, lints | Agents stop copying each other's hacks, so quality improves instead of decaying. |
| 7 | Babysit and shipping playbooks, daily `/pstack:maintain-verification-skill` | PRs land with less of your time, even overnight. |
| 8 | `/pstack:reflect`, `/pstack:automate-me` | The setup tunes itself to how you work. |

Parallelism comes late on purpose. Without step 2, more agents only means more output to babysit.

## Example: one bug report, step by step

A user reports in Slack that the list scrolls and jitters. Here is how the steps above look in prompts. The prompts are adapted from her Part 2 guide.

**Without pstack.** You paste the report and say "fix the scroll bug". The agent guesses a cause, edits code, says "done", and you read the diff to find out if it worked.

**With pstack.**

1. Understand (step 3). Do not give your theory.

```
/pstack:poteto-mode read this slack thread. restate in your own words and in plain english what you think the underlying issue is.
```

2. Reproduce (step 2). The agent drives the app with the verification skill.

```
/pstack:poteto-mode repro this with the verification skill. if it repros on main, fix it and show me a video as proof.
```

3. Not a one-line fix (step 4). Compare options with evidence.

```
/pstack:poteto-mode prototype a few options for the fix. drive the app, take screenshots, and pick one with data.
```

4. Large change (steps 4 and 5). Design first, then fan out.

```
/pstack:poteto-mode /architect a new virtualization approach that removes the jitter. answer open questions with prototypes, then let me review.
```

```
/pstack:poteto-mode create a plan to migrate every list to it. small PRs, each with visual regression tests and live verification steps.
```

5. Land it (step 7), even when you are away.

```
/pstack:poteto-mode i'm going to bed. land the stack even if ci flakes. i want everything merged by morning.
```

What changes for you. You read a short restated problem, a video, and a verified result, not a diff full of guesses.

## Start here

**`/pstack:poteto-mode`** is the main shortcut. Use it whenever you are doing anything that requires rigor. It picks one of twenty-three playbooks (investigation, bug fix, perf, feature, refactoring, prototype, babysit, shipping, autonomous run, orchestrate, and more) and calls the other skills when the steps need them.

```
/pstack:poteto-mode this pr has a subtle bug where the scroll drifts every 750ms even when idle. repro first, then fix and verify.
```

## Trust the output

An agent that cannot verify its own work leaves you as the bottleneck. Fix that first.

- **`/pstack:create-verification-skill`** makes a skill that teaches the agent to run, control and debug your app, plus a feature map of what the app does and how a user reaches it.
- **`/pstack:maintain-verification-skill`** keeps that map current. Run it daily as an automation.
- **`/pstack:blast-radius`** finds what a small change can break outside the diff.
- **`/pstack:benchmark-checklist`** checks whether a performance number is trustworthy.

```
/pstack:create-verification-skill for this app, with a feature map.
```

## Understand before you build

Most bad output comes from unclear intent or missing context.

- **Ask in its own words.** Do not state your own hypothesis. Make the agent restate the problem, so you catch a wrong turn before any code. `/pstack:in-your-own-words` is the skill for it.
- **`/pstack:teach`** explains a change so you understand it. It calls **`/pstack:how`** (runtime mechanics) and **`/pstack:why`** (history and intent).
- **`/pstack:recall`** pulls context from past chats so a fresh agent starts well.

```
/pstack:poteto-mode read this slack thread. restate in your own words and in plain english what you think the underlying issue is.
```

## Design without abstract plans

Plan with code, not with long documents.

- **Prototype playbook.** Ask for a few options and let the agent answer its own questions with evidence.
- **`/pstack:architect`** grounds the problem, sketches competing designs across model families, has another model judge them, implements against the sketch, and scraps it if it proves wrong.
- **Planning playbook.** Turn a settled design into small PRs, each with live verification steps.
- **`/pstack:technical-writing`** for readme-driven design. Write the tutorial for the API first.

![pstack-p2-architect.jpg](/media/notes/pstack-p2-architect.jpg)

```
/pstack:poteto-mode prototype a few options for <feature>. drive the app and take screenshots for me to choose from.
```

```
/pstack:poteto-mode /architect this new <feature>. answer open questions with prototypes, then let me review.
```

## Parallel at scale

- **`/pstack:swarm`** splits work into slices for coverage, or races several routes.
- **`/pstack:arena`** runs N attempts at the same brief, picks a base, and grafts in the best parts.
- **`/pstack:interrogate`** has models from different families review a diff.
- **Projects.** A coordinator manages hundreds of cloud agents.
- **Multiple models.** Opus is a good manager of other models. Set roles in `/pstack:setup-pstack`.

```
/pstack:poteto-mode review every package for the same bug class. one agent per slice, one report at the end.
```

## Keep the code clean

- **`/pstack:no-comments`.** Ban and delete most code comments. Agents copy a workaround comment, and it spreads. Move that prose into lint rules, types and better APIs.
- **`/pstack:correct`** fixes a repeated agent mistake at the highest layer that works, from architecture down to docs.
- **Refactor for agents.** Make the code easier for an agent to navigate and verify.
- **Still read the code.** For each smell, refactor it away or add a lint so it cannot return.

```
/pstack:poteto-mode spawn a /swarm that uses /no-comments to find useless comments. plan which workarounds to fix by refactoring and which to delete.
```

## Ship and run unattended

- **Babysit playbook** drives a PR to green and handles review comments.
- **Shipping playbook** verifies a green stack independently, then lands it.
- **Autonomous run** keeps going until done.
- **`/pstack:show-me-your-work`** keeps a decision log so you can audit a long run.

```
/pstack:poteto-mode i'm going to bed. land the stack even if ci flakes. i want everything merged by morning.
```

## Principles

Principles are tiny skills of 10 to 20 lines. `poteto-mode` loads an index of them and asks the agent to name each principle that shaped a decision. Call one directly as `/pstack:principle-<name>`.

- **prove-it-works.** Verify against the real artifact, not "it compiles".
- **attack-the-premise.** When two fixes fail the same way, write the premise down and test it.
- **build-the-lever.** On big tasks, build the tool (codemod, script) instead of editing by hand.
- **fix-root-causes.** Trace the symptom to the first place it went wrong.
- **test-behavior-not-implementation.** Fewer useless tests.
- **laziness-protocol.** Prefer deletion and the smallest change.

## Make it yours

- **`/pstack:reflect`** mines a session for lessons and proposes skill edits.
- **`/pstack:automate-me`** builds your own `-mode` skill from your chat habits.

## `/pstack:bro`

My favorite. It restates the last reply in plain language. When an agent answer is long or too technical, type it and get the short version.

## Sources

Her posts, in the order they help most.

- [The Complete Guide to pstack, Pt. 1](https://x.com/poteto/status/2094457600259842065) on verification
- [Pt. 2](https://x.com/poteto/status/2097732320606507506) on supervising someone smarter than you
- [Create and maintain a verification skill](https://x.com/poteto/status/2082874054483255805)
- [Ban and delete most if not all code comments](https://x.com/poteto/status/2110149626133438732) and the [follow-up](https://x.com/poteto/status/2110214216783401042)
- [Engineering principles](https://x.com/poteto/status/2110496830429839869), [attack the premise](https://x.com/poteto/status/2097380152703615396), [build the lever](https://x.com/poteto/status/2059870196559700428)
- [Still read the code](https://x.com/poteto/status/2092512896408592713)
- [Projects and cloud agents](https://x.com/poteto/status/2098165460714057863), [multi-model](https://x.com/poteto/status/2059793670359204225)
- [/in-your-own-words](https://x.com/poteto/status/2110047236369547621), [refactor for agents](https://x.com/poteto/status/2110758136852385984)
- [How she shipped 2,500 PRs in a month](https://x.com/poteto/status/2102050467505430555) (self-reported), [How I Use Cursor](https://x.com/poteto/status/2058975157503570132)

![pstack-2500-prs.jpg](/media/notes/pstack-2500-prs.jpg)