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

Overview and the Four Layers

pstack ships 58 skills and 22 playbooks. The numbers look intimidating, but they are arranged in four layers, and once you see the layers you will find that daily use requires you to remember very little.

The four layers

LayerWhat it isCountHow you reach it
1. Entry point/poteto-mode1 skillYou pick it from the / menu
2. PlaybooksStep-by-step procedures inside /poteto-mode22/poteto-mode matches one to your task
3. SkillsIndividual tools such as /how or /swarm33 skillsCalled by playbook steps, or typed directly
4. PrinciplesOne rule per skill, named principle-*24 skillsRead by /poteto-mode; named by you to steer

The 1 entry point, the 33 other skills, and the 24 principles add up to the 58 skill folders under skills/.

Layer 1: the entry point

The only command a human really needs is /poteto-mode. You select it at the start of a task and describe the task in ordinary language. Its frontmatter sets disable-model-invocation: true, so an agent does not switch it on by itself; it runs because you chose it.

Layer 2: playbooks

Playbooks live in skills/poteto-mode/playbooks/ and are not slash commands. /poteto-mode reads your request, picks the matching playbook, and copies its steps verbatim into the todo list as the first items. A bug fix therefore always starts from the same sequence (reproduce, find the root cause, fix, verify on the same surface), whichever agent runs it.

When no playbook fits, or the work is large, cross-cutting, or unattended, /poteto-mode routes it to the figure-it-out skill, which designs a dedicated, auditable playbook for that task. The chapter Playbooks covers all 22.

Layer 3: skills

Skills are the tools that playbook steps call: explaining a subsystem (/how), sending one task to several models and combining the best parts (/arena), running many workers in parallel (/swarm), or asking other models to break a diff (/interrogate). You can type any of them directly, but the README says the other skills are “situational” and that /poteto-mode runs them for you as needed. The chapter Skills describes each one.

Layer 4: principles

Each principle is a short skill that states one rule, grouped as core, architecture, verification, delegation, or meta. /poteto-mode contains an inline index of all 24 and reads it at the start of every task. In its replies it must name each principle that shaped a decision and the specific choice that principle changed, and it may cite only principles whose full file it read in that session.

This makes the principles a shared vocabulary. Because the agent names them, you can name them back: “that does not meet Prove It Works” is a short and precise correction. The chapter Principles covers them.

Supporting parts

Two subagents and one automation pack sit behind the four layers.

  • poteto-agent is the subagent type for delegates spawned during a /poteto-mode run. Before doing any work it reads the poteto-mode skill in full, including the principles index, so delegated work follows the same style. The README warns that substituting a general-purpose subagent skips that read and “drifts”, and that poteto-agent must not be spawned to run the playbook itself. The chat that received /poteto-mode owns the playbook, the todo list, and every spawn.
  • Comment Sicko is a read-only reviewer that hunts for comments to delete. It keeps only a short list of exceptions (license headers, public API doc comments, constraints imposed by something outside the codebase, and a few others) and marks code that needs a comment to be understood as MUST KILL, meaning it should be renamed, extracted, typed, or restructured. It never edits code. You normally reach it through /no-comments.
  • benny is a dormant pack of automations that handles issue reports from Slack: one automation triages incoming reports, and a second one reproduces the bugs that triage confirms and may draft a small fix. None of its files become slash skills. During setup the pack is copied to .cursor/automations/benny/ in the target repository; since it depends on Cursor Automations, it runs only in Cursor.

What pstack relies on but does not bundle

/poteto-mode refers to a few tools that ship elsewhere. The README lists them:

  • /deslop and the deslop skill, which /poteto-mode runs before a commit, come from the cursor-team-kit plugin.
  • control-cli (for command-line tools and terminal UIs) and control-ui (for browsers, Electron, and the web), used when shipping UI or CLI work, also come from cursor-team-kit.
  • /create-skill is built into Cursor. Cursor also has a built-in /autopilot that watches a pull request, but inside /poteto-mode a request for PR status goes to the Babysit playbook instead.

Install cursor-team-kit next to pstack if you want the full set.

Why there are no planning skills

pstack deliberately has no skill dedicated to writing a plan. The README points out that Cursor already has a plan mode that works well with pstack, and then states the author’s own view: “i don’t believe in planning. the best spec is code.”

The same attitude runs through the skills. When a design question can be settled by an experiment, /poteto-mode builds a throwaway prototype (the Prototype playbook) instead of asking or debating. A plan is still available when the work genuinely spans phases or stacked pull requests: the Multi-phase plan playbook covers it, but it is not the default.