pstack

pstack is the evidence pack from What it takes to trust an agent, the one that guards the moment an agent reports success. A claim of "done" counts for nothing until a check against something real backs it.

This page orients and records how the pack behaves in practice. The README and the pstack guide own the details, and both change often.

What it is

A Cursor plugin by poteto (Lauren Tan), MIT licensed. The author describes it as the skills used daily to ship code at Cursor, and sets its goal as less code at higher quality, not more lines. It is model-agnostic by design. Several skills run the same task across different models on purpose, because different models fail in different ways.

The pack has three layers:

• One entry point. /poteto-mode reads the request, matches it to a playbook (bug fix, feature, refactoring, perf, investigation, shipping, autonomous run, multi-phase plan and more), copies that playbook's steps into a todo list, and calls the other skills as the steps need them.
• Situational skills. how and why for understanding code, architect for settling a module's shape before writing it, arena, swarm and interrogate for parallel work and review, tdd, blast-radius, reflect and others.
• Principles. Standalone rules the playbooks cite by name, among them prove it works, sequence verifiable units, guard the context window and subtract before adding.

The failure point it guards

The agent says it works, and it doesn't. The prove it works principle is the core of the pack: verify against the real artifact, meaning run the feature, read the actual value, inspect the diff, and never trust a proxy, a self-report or "it compiles." The guide scripts the correction for an agent that claims success because the build passed: run the real flow and show the written records.

Planning is present, but in the same shape. There is no PRD-writing skill. The multi-phase plan playbook produces a checklist where every box names the evidence that checks it: a file, a log line, a screenshot, a test run or a commit. A box is checked only when its evidence exists.

When to use it

Reach for it when:

• The work is hard to verify by eye: a bug that won't reproduce, a performance regression, a migration, a change with a wide blast radius.
• An agent will run unattended, overnight or across many PRs, and the result has to be trustworthy in the morning.
• A design question can be settled by running something. The playbooks prefer a cheap prototype over a debate.
• Several models are available, and disagreement between them is useful signal.

Skip it when:

• The change is small and visual. A button color needs a look at the result, not a playbook.
• The real risk is building the wrong thing. pstack is light on up-front alignment. Matt Pocock's skills cover that point.
• A team needs a recognizable, end-to-end lifecycle through CI, launch and deprecation. Addy Osmani's agent-skills are closer to that.

At a glance

Main skills

• /poteto-mode — the default entry for any non-trivial task. Picks a playbook and runs it.
• /arena — several parallel attempts at the same task, then the best parts of each are combined.
• /swarm — parallel workers across different slices of a problem, with one aggregated report.
• /interrogate — different models try to break a diff, including a strict code-quality lens.
• /how and /why — a walkthrough of how a subsystem works, and an evidence search for why it was built that way.
• /architect — settles the caller's usage, types and module shape before code crosses a function boundary.
• /create-verification-skill — generates a project-local verify skill for an app that has no scripted way to prove its behavior.
• /setup-pstack — picks which model and reasoning budget each role uses.

How to install

In Cursor:

/add-plugin pstack

Then run /setup-pstack to pick models and a reasoning budget, and start tasks with /poteto-mode. The upstream pack targets Cursor. Other harnesses need a port, as described below.

On this build

pstack runs on this build inside Claude Code, as a port of the Cursor plugin. The verification half of the engineering loop leans on it. The port taught more about the pack than reading it did:

• Roles became agents. Upstream passes a model on each call. Claude Code binds a subagent's model and reasoning effort in the agent definition, so each pstack role (code, deep reasoning, panel, review, worker) became its own role agent. /setup-pstack rewrites those definitions.
• Panel diversity is weaker. Upstream panels mix vendors, and three vendors disagreeing is strong evidence. Inside Claude Code the panel draws on one model family, so a unanimous panel is weaker signal. The port records that at the point of use instead of hiding it.
• Model choice and effort are separate settings. An "Opus everywhere" setup could not be expressed without also raising effort, so model-per-role and effort cap became two separate axes. Putting one model in every panel slot is refused unless forced, because that turns an arena or an interrogation into one reviewer run three times, and agreement between those slots is not evidence.
• The verification skill is not for every repo. The generated verify skill drives a user-facing app end to end. It was declined for the assistant repo, which has no such app and already has its own tests, and kept for the product apps where it fits.

Where it helped most so far: the multi-phase plan playbook, used to plan a sports-stats data pipeline for eightballsports.com as a stack of small PRs. Its prototype step measured the real data before anything was built, and the row volume came in about an order of magnitude below the spec's estimate. The plan was sized to the measurement, not the guess. That is the pack's thesis in one result. No arena or swarm run worth reporting has happened yet.

Related

• What it takes to trust an agent — the essay that frames all three packs as theories of where agent work breaks.
• Matt Pocock's skills — the intent pack: agree on what to build before any code.
• Addy Osmani's agent-skills — the process pack: the full lifecycle, plus a table of the agent's excuses.
• Claude Code — the harness the port runs in here.
• Cursor — the harness pstack was built for.