pstack for pi

unofficial port. this project is not affiliated with, endorsed by, or connected to Cursor or Lauren Tan. it's an independent, unofficial pi port of the skills from the original Cursor plugin.

get started

two steps:

1. install, then run /skill:setup-pstack and choose which models you want.
2. use /skill:poteto-mode whenever you're doing anything that requires rigor.

requirements

none of these are hard requirements. the skills are written against them, but the agent can usually find another way without them — and if you prefer a different package that provides similar functionality, install that instead and the agent will adapt.

• pi

• pi-subagents — the two custom subagents (poteto-agent, comment-sicko), every routed workflow skill (how, why, arena, swarm, interrogate, reflect), and scheduled runs go through its subagent tool:

  pi install npm:pi-subagents

• @juicesharp/rpiv-todo — the todo tool and live task overlay the playbooks use to track multi-step work:

  pi install npm:@juicesharp/rpiv-todo

• @juicesharp/rpiv-ask-user-question — structured questionnaires the playbooks use to ask you for decisions instead of guessing:

  pi install npm:@juicesharp/rpiv-ask-user-question

install

git installs only for now:

pi install git:github.com/ngctro/pi-pstack            # track main
pi install git:github.com/ngctro/pi-pstack@v0.1.3     # pin a release

note: pi -e git:github.com/ngctro/pi-pstack (try without installing) loads the skills and commands but not the two subagents — agent discovery scans installed package roots only.

new here? the pstack guide walks you through a first real task, from setup and prompting through verification and overnight runs.

that's it. the other skills are situational; the mode skill uses them for you as needed. /skill:setup-pstack maps each role (code, judgment, the review panels) to real model ids and writes ~/.pi/agent/pstack-models.md.

usage

use /skill:poteto-mode at the start of a task. it reads your request, picks from a set of playbooks, and runs the other skills as the steps need them.

the playbooks: feature, refactoring, prototype, visual parity, authoring a skill, eval, babysit, shipping, autonomous run, orchestrate, autopilot-full, autopilot-stack, session pickup, pause safely, multi-phase plan, worktree cleanup, and more — all under skills/poteto-mode/playbooks/.

all skills load natively in pi — invoke any of them with /skill:<name>, e.g. /skill:poteto-mode or /skill:setup-pstack.

skills

/skill:poteto-mode runs most of these for you when a step needs them (how, why, architect, arena, swarm, interrogate, unslop, no-comments, technical-writing, tdd, and the principles).

skill	use it when
/skill:poteto-mode	default entry point for any non-trivial task.
/skill:how	you want a walkthrough of how a subsystem works.
/skill:why	you want to know why code exists, from every evidence source available.
/skill:architect	you're about to write code that crosses a function boundary.
/skill:arena	you want competing implementations raced, judged, and grafted.
/skill:swarm	you want N parallel workers across different slices or races, then one aggregated report.
/skill:interrogate	you have a diff and want several different models to try to break it.
/skill:recall	you're starting or resuming work and want recent context rebuilt into a tight brief.
/skill:blast-radius	you have a small-looking change and want to know what else it could break.
/skill:no-comments	strip comments before review.
/skill:unslop	any prose surface.
/skill:deslop	strip AI slop from a diff before commit.
/skill:control-cli	drive and profile an interactive CLI/TUI through a local harness (tmux/PTY).
/skill:control-ui	drive and inspect a web/Electron UI through Playwright or CDP.
/skill:verify-this	prove or disprove a claim with baseline/treatment evidence and a verdict.
/skill:create-skill	author or edit a SKILL.md that triggers reliably (pi-native replacement for Cursor's built-in).
/skill:tdd	test-driven development.
/skill:setup-pstack	pick which models pstack uses per role.

plus twenty-one short principle skills (principle-*), one principle each, indexed inline by poteto-mode.

the poteto-agent and Comment Sicko subagents

pstack ships two pi-subagents custom agents:

• poteto-agent — runs poteto's style end to end. spawn it with agent: "poteto-agent".
• comment-sicko — read-only comment reviewer. spawn it with agent: "comment-sicko".

/skill:poteto-mode and poteto-agent route through the same wrapper.

what changed from the Cursor original

• the plugin manifest became a pi package manifest (pi.skills, pi.subagents.agents).
• Cursor skill commands became native pi skill commands (/skill:poteto-mode, /skill:setup-pstack).
• Task/subagent_type spawning became pi-subagents (subagent tool, agent: param; read-only panels use the builtin reviewer, workers use worker).
• Cursor rules (~/.cursor/rules/pstack-models.mdc) became ~/.pi/agent/pstack-models.md.
• transcript mining reads ~/.pi/agent/sessions/.
• deslop, control-cli, control-ui, and verify-this are ported from the cursor-team-kit plugin (MIT), which pstack's playbooks reference.
• Cursor's built-in create-skill is re-authored here as a pi-native skill (Agent Skills standard, pi frontmatter rules, trigger/follow test bench).
• Cursor's built-in /loop maps to pi-subagents scheduled runs (subagent → schedule.create); the playbooks name that primitive directly.
• the dormant benny automation pack was not ported (it targets Cursor's cloud automations).

license

MIT — see LICENSE. original work by Lauren Tan; pi port of the same skills.