pstack skill

A mirror of Lauren Tan's pstack set from Cursor: over 50 skills, the poteto-mode with 23 playbooks and 24 principles for strict agent work on code

  • 2,488 ★ on the repository
  • Last commit
  • MIT
Skill

Broad access

Why this level

  • Playbooks run commands, write code and can drive a pull request all the way to merge through GitHub
  • Long-run mode keeps working without asking, and confirmation remains only before irreversible actions
  • Arena, swarm and interrogate launch many subagents on different models at once, which burns limits and money fast
All reasons and checks

backnotprop/pstack

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/pstack

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Broad accessThe tool can change data, run commands or handle secrets.

  • Playbooks run commands, write code and can drive a pull request all the way to merge through GitHub
  • Long-run mode keeps working without asking, and confirmation remains only before irreversible actions
  • Arena, swarm and interrogate launch many subagents on different models at once, which burns limits and money fast

This is third-party code. Review the repository files before installing.

What it does

pstack is a set of skills for an agent's engineering work that Lauren Tan (poteto) maintains in Cursor's plugins. This repository is its mirror with edits, so the set works in Claude Code, Codex, Pi, OpenCode and other environments, not only Cursor. The skills live in skills/<name>/SKILL.md, the `npx skills add backnotprop/pstack` command lists them, and you pick the skills and the agents you want. The main entry point is the poteto-mode skill. At the start of a task it matches your request to one of 23 playbooks: answering a question, fixing a bug with a repro, speeding something up against measurements, a new feature, a refactor, pixel-exact visual parity, shepherding a pull request to merge-ready, an overnight autonomous run and others. It then opens a to-do list from the playbook's steps and calls other skills along the way: how explains how a subsystem works, why digs for the reasons behind decisions in the tracker, chat and monitoring through connected MCPs, architect settles interface shapes first, arena and swarm run several parallel attempts or workers, interrogate asks other models to break the diff, and unslop strips AI tells from prose. The set also has 24 short principle skills, one rule each, such as subtract before you add and prove it on the real artifact. /setup-pstack detects the available models and writes a file with a model choice for each role, and /automate-me builds a personal skill like poteto-mode from your past chats. Two subagents ship with it: poteto-agent and comment-sicko, a read-only comment reviewer.

Who it is for. For developers who run several agents in parallel and want each to follow the same strict rules: reproduce, fix the root cause, verify on the real thing.

Good fit when

  • The agent has to reproduce a bug, find its cause and prove the fix by running it, not just report that the code compiles
  • You need to choose between several architecture options: arena gives parallel attempts and interrogate asks other models to find weak spots
  • A pull request is stuck with conflicts, review comments and a red build and has to be brought to merge-ready
  • You leave for the night and give the agent a long task with a decision log you can review in the morning
  • You keep correcting the agent for the same mistakes, and /correct should turn them into rules rather than one more paragraph of instructions

Not a fit when

  • The task is small, a one-line fix: the set is built for work that needs rigor, and for a typo it only adds steps
  • You want a separate planning phase: the author deliberately ships no planning skills and treats code as the best spec
  • You are not ready for parallel subagents on several models: arena, swarm and interrogate launch many attempts at once
  • You want to automate triage of Slack reports: the benny pack in the repository is set up for Cursor and dormant by default

Example request

/poteto-mode in this pull request the list scrolls by itself every 750 ms even when the page is idle. Reproduce first, then fix and verify

Limitations

This is an unofficial mirror: the backnotprop repository follows cursor/plugins/pstack, the upstream branch keeps Cursor's files unedited, and main adds an intro to the README plus skills rewritten to work in any environment. The license is MIT.

Some skills call others. For example, teach needs how and why, blast-radius needs arena, how, why and unslop, and poteto-mode leans on almost the whole set. The unslop, how skills and fourteen others work alone. The `/deslop` command, control-cli and control-ui are not in this repository: they live in the cursor-team-kit plugin.

By default poteto-mode splits work between two models: code goes to Grok, while the hardest tasks and prose go to Claude Opus 5.5. You change this with /setup-pstack, which writes the choice to `~/.agents/pstack-models.md`. Without that file the skills use their own defaults.

The benny pack, which triages Slack reports and reproduces bugs with proof in the UI, is built for Cursor and will not work in other environments without setup.

How to disable. Remove the skills you do not want from the agent's skills folder, such as skills/ or .agents/skills/, or run the installer again and clear the checkmarks. Delete the model choice file ~/.agents/pstack-models.md by hand, after which the skills return to their defaults. A poteto-mode kept on through option+enter or alt+enter in Cursor is turned off by exiting the mode.

FAQ

How does this mirror differ from Cursor's original?

The files are the same, but many skills in Cursor were tied to its tools, such as `.cursor/` and `Task`. In the mirror they are rewritten to work in any environment. MIRROR.md describes the merge order: the original lives on the upstream branch and the mirror's edits on main.

Where do I start if I do not know which skill I need?

Pick /poteto-mode and describe the task: it chooses the playbook itself. If you are new and unsure which skill fits, ask /poteto-help. It finds out your goal, answers it and tells you what to type, and runs only when you call it yourself.

What do the principles do and how many are there?

There are 24, each in its own skill with a single rule. They fall into groups: core, architecture, verification, delegation and the meta principle of encoding lessons in structure. poteto-mode keeps their index and reads the full skill before citing a principle in its reply.

How does the why skill find the reasons behind decisions?

While running it discovers the MCPs connected to the agent and queries them in parallel by category: source control, issue tracker, long-form docs, chat, infrastructure monitoring, error tracking and analytics. Without such MCPs it relies only on what is available locally.

What does /automate-me do?

It reads your recent chats, drafts your own skill of the form your-name-mode from them and plugs pstack in as the base. You end up with a router in your own style next to poteto-mode.

What are the bundled subagents?

poteto-agent wraps delegates spawned during a run and reads all of poteto-mode, including the principles index, before starting work. It does not run the playbook itself. comment-sicko reads code comments without write access and is usually called through /no-comments.

Discussion

No questions or reviews yet.

Skills

Eleven skills for Claude Code and Codex: test audit, git worktree cleanup, plan pages, screen recording transcripts and 1Password sign-in

SkillBroad access1.2KRepository stars

Softaworks Agent Toolkit

Softaworks Agent Skills

A marketplace of skills, subagents and commands for coding agents: development, documentation, planning and workplace communication

PluginExtended access2.6KRepository stars

The author's personal set: shared agent rules and dozens of skills for GitHub, the browser, macOS, messaging and releases, plus a sync script

SkillBroad access7.4KRepository stars

Armin's personal toolkit for the Pi Coding Agent: 18 skills, extensions, commands and themes, with some skills portable to other agents

SkillBroad access3.2KRepository stars

Two skills for coding agents: wtf audits a project before shipping, better-codex keeps the agent disciplined while working on code

SkillExtended access1.4KRepository stars

110 skills for Claude Code and Codex and seven Claude Code agents: development, product, UI, diagnostics and operations, installed whole or as a bundle

PluginBroad access289Repository stars

Comparison with similar tools

Entries that share the main search query, and how they differ.

EntryOfficialRepository starsMain difference
pstack (this entry)no2,488
pstack for Claude Code and Codexno3,238another unofficial port of the same pstack set for Claude Code, Codex, Pi, OpenCode and Gemini
Cursor pluginsno13,447Cursor's official plugins repository, where pstack is one of the plugins

README in short

The mirror's intro explains installation and dependencies between skills, and below it comes Cursor's untouched description. It holds a table of 23 playbooks, a table of all skills with when to use each, example requests, a section on subagents and a table of 24 principles. Beside it sit a ten-chapter guide in docs/guide, from setup to overnight runs, and the benny automation pack. The author explains why the set exists: to write less but better code and to parallelize agents without losing quality.

README badge

Original SKILL.md

---
name: poteto-mode
description: poteto's agent style for concise, detailed responses, deliberate subagents, unslopped prose, simple code, and verified work. Use for poteto, /poteto-mode, or requests to work in this style.
disable-model-invocation: true
icon: crown
color: yellow
---

# Poteto mode

Bundled skills live at `../<name>/SKILL.md` from this file, so put this file's absolute path in every `poteto-agent` prompt.

## Non-negotiables

The Principles section below grounds every trigger. In your reply, name each principle that shaped a decision and the specific choice it changed. Cite only principles whose leaf SKILL.md you read this session.

Remaining triggers:

- Nontrivial change, architecture decision, or "are we sure?" → the **how** skill.
- About to `AskQuestion` on a "which approach", "how should I", or "what should this do" fork → classify it before you ask. If the answer is a fact you could observe by running something (behavior, timing, layout, output, perf, even whether an eval separates), it is not the human's to answer. Sketch it via the Prototype playbook (`playbooks/prototype.md`) and let the result decide. If the task is a read-only Investigation whose deliverable is a cited answer, stay in it and answer from the evidence rather than building a sketch. Reserve the question for a genuine product or preference call no experiment can settle. Under a full-autonomy grant, decide a call the grant covers, act on it, and report it, with no reply word and no offer. Under the grant, for a call only the operator can make, apply a default, report it with a full explanation, and say in plain words what the operator could tell you to do instead. The operator answers in their own words. Never give a shorthand token to type back. Gates the operator named and the Always-pause list in Autonomy still need the operator.
- Any code → name the data shape first, and choose its organizing structure per **principle-model-the-domain**.
- Code crossing a function boundary → the **architect** skill, parallel design exploration before implementing.
- Parallel fan-out → the **swarm** skill for coverage matrices, races, gauntlets, and exploration partitions. Use **arena** for design or code bakeoffs with base selection and grafting.
- Contested design → the **interrogate** skill (multi-model adversarial) before shipping.
- Nontrivial multi-step → write the throughput checkpoint (Feature step 3).
- Any prose surface, your reply to the user included → the **unslop** skill. Write the reply per **Writing the reply**. Agent-facing prose also follows your skill-authoring skill (**create-skill** in Cursor, see **Harness**).
- Docs, RFCs, readmes, PR descriptions, or commit messages → the **technical-writing** skill (`/technical-writing`).
- Before commit → the `deslop` skill from the `cursor-team-kit` plugin (`/deslop`). Without it, see **Harness**.
- Before review → the **no-comments** skill (`/no-comments`).
- Shipping UI / IDE / CLI → the matching control skill. `cursor-team-kit` publishes `control-cli` (CLIs and TUIs) and `control-ui` (browser / Electron / web UIs). Without them, see **Harness**. For bug fixes, reproduce first on the same surface yourself. Hand to the user only under the narrow Bug fix step 1 exception.
- Running a benchmark, measuring perf yourself, or reporting a speedup or regression you measured → the **benchmark-checklist** skill before you report or act on the number.
- Any PR-status request ("babysit this", "get it green", "address the bugbot comments", and most often "check on PR X" or "anything outstanding on X") → the **Babysit** playbook (`playbooks/babysit.md`), not Cursor's built-in babysit skill, whose description matches the same words. Never triggered by merely opening a PR. Declare its mode before polling. The playbook's step 1 owns the request-to-mode mapping. Reaching for `drive` inside a phase agent stops that agent finishing its turn.
- Asked to land or ship a green stack → the **Shipping** playbook (`playbooks/shipping.md`). Green is not safe. Nothing gets armed before an independent per-PR verdict, and only the contiguous verified run from the root lands.
- Bugbot or the agentic security review commented → skeptical posture. They catch real bugs and also file non-issues and nitpicks, so assess each on its merits and dismiss noise with a concrete reason instead of churning code. Triage fix / dismiss / ask per `references/bugbot-triage.md`.
- Broken skill mid-task → fix it in its own PR. Don't block. Don't silently work around it.
- Long, autonomous, or multi-phase work, or any task the user steps away from to review later ("going to bed", "trust it when i'm back", "/loop until X") → a decision trail via the **show-me-your-work** skill. Commit it when stakes need an auditable record. Keep it local otherwise.

## Principles

Read the leaf skill in full for any principle you apply. Each entry names when it applies. Each leaf is the **principle-<title>** skill, with the title in kebab case, hyphens kept and other punctuation dropped, unless the entry gives its name.

Report a problem

Foxx AIpstack
Foxx AI

I am Foxx AI and I have already vetted this tool. Ask about install, setup or anything else, and I will keep it simple.