Yellow potatopstack

Skill flows

All 37 skills, each drawn as the steps it runs. Dotted lines mark where a skill reaches for a principle, a playbook, another skill, or an agent. Click any of those to open it.

  • Step
  • Decision
  • Loops back
  • Principle
  • Playbook
  • Skill
  • Agent

Start and steer

The entry point, setup, and the short skills that restate or reshape a request.

/poteto-mode

poteto's agent style for concise, detailed responses, deliberate subagents, unslopped prose, simple code, and verified work. Read the skill

cross-cutting or none fits multi-day program one fits models per role subagents fan-out bakeoff long runs Task arrives Restate the goal and the smallest change Match a playbook All 23 playbooks All 23 playbooks /figure-it-out /figure-it-out Orchestrate Orchestrate Copy its steps into the todolist /setup-pstack /setup-pstack Understand and design /how /how /architect /architect /interrogate /interrogate Build and measure Poteto subagent Poteto subagent /swarm /swarm /arena /arena /benchmark-checklist /benchmark-checklist Prepare for review /no-comments /no-comments /technical-writing /technical-writing /show-me-your-work /show-me-your-work Reply naming each principle used All 24 principles All 24 principles /unslop /unslop Opening a PR Opening a PR /reflect /reflect /why /why
Draws on
24 principles
23 playbooks
14 skills
Used by
      11 skills

        /poteto-help

        Guides users through pstack setup, /poteto-mode, and picking the skill, playbook, or principle for a task. Read the skill

        work help get set up pick a skill playbooks and principles run went wrong make it theirs make it theirs Question about pstack Help or work? /poteto-mode /poteto-mode Check state: model rule, verify skills What do they need? /setup-pstack /setup-pstack All 37 skills All 37 skills All 23 playbooks All 23 playbooks Symptom and fix table /automate-me /automate-me /reflect /reflect Answer, one example prompt, source link Poteto subagent Poteto subagent
        Draws on
          33 skills

          /setup-pstack

          Configure which models pstack uses per role and at what reasoning budget. Read the skill

          no yes Detect model slugs this session can use Load the current rule or the defaults Ask for a budget Set every role's effort from the budget Show roles, confirm changes Every slug available? ↩ Back to confirming roles Write pstack-models.mdc Offer to generate a verify skill /create-verification-skill /create-verification-skill Offer a formal verification skill /create-formal-verification-skill /create-formal-verification-skill
          Draws on
                Used by

                      /in-your-own-words

                      Restate in your own words what you think the user's goals are and what problem they're trying to solve. Read the skill

                      The user's request Restate their goal Restate the problem they are solving The user corrects or confirms
                      Used by

                            /sharpen

                            Make a task deeper, not bigger, then rewrite the prompt. Read the skill

                            Your prompt What a top professional would add The rawest material they start from Their methods and tools What outside check proves it right Rewritten prompt, deeper not bigger Your choices left open
                            Used by

                                  /bro

                                  Restate the last message in plain human language, with no jargon. Read the skill

                                  The last message Drop the jargon Say it simply, one person to another
                                  Used by

                                        Understand

                                        Read-only skills that explain code, its history, and recent work.

                                        /how

                                        Explore the codebase to answer "how does X work?" questions. Produce architectural explanations at the level of a senior engineer onboarding onto a… Read the skill

                                        simple complex Simple or complex? One explainer explores and explains Split into 2 to 4 angles Explorers run in parallel One explainer synthesizes the findings Overview, key concepts, how it works, where things live, gotchas /poteto-mode /poteto-mode
                                        Draws on
                                              Used by
                                                  10 skills

                                                    /why

                                                    Investigate the motivation and intent behind code. The companion how skill answers what the code does and how it works. why answers what forces led to… Read the skill

                                                    about to change it Pin the target and the question Code anchor: blame, log, PRs, tickets Map available MCPs to evidence categories Source control, always Tickets, docs, team chat Observability, errors, analytics Synthesizer keeps confidence levels Found, inferred, unknown, sources consulted Preserve, change, avoid, risk /how /how /poteto-mode /poteto-mode
                                                    Draws on
                                                          Used by
                                                              10 skills

                                                                /teach

                                                                Explain a body of work plainly so a person actually understands it. Read the skill

                                                                yes no Pick what they should walk away knowing /how /how /why /why Plain definition, tied to this case Smallest complete answer, then stop They want more? Add one layer and redraw the diagram ↩ Back to: they want more? Done /unslop /unslop
                                                                Draws on
                                                                      Used by

                                                                            /recall

                                                                            Reconstruct your recent working context from your own chat history, live state, and the shared record (user reports, prior fixes, incidents), then hand back a tight current-state brief. Read the skill

                                                                            resume one chat habits into a skill load recent context source investigators Classify the ask Session pickup Session pickup /automate-me /automate-me Lock the scope: window, topic, workspace Fan out over chat history Sweep the shared record /why /why Check PRs and branches live Capsule, threads, problems, next move /poteto-mode /poteto-mode /unslop /unslop
                                                                            Draws on
                                                                                Used by

                                                                                      /ketchup

                                                                                      Catch the user up on what changed in this chat since their last message, in plain words and small visuals. Read the skill

                                                                                      voice Everything since the user's last message Gather read-only: work, subagents, PR and CI state Check every number against its source Find calls only the user can make One line on what waits on them Pictures, then one line per ask Action items with picks and risks /bro /bro
                                                                                      Draws on
                                                                                            Used by

                                                                                                  /ketchup-video

                                                                                                  Catch the user up like /ketchup, with a short subtitled video of slides for what happened and the waiting calls as text under it. Read the skill

                                                                                                  same window and calls no yes /ketchup /ketchup One takeaway, one line per slide At most 10 slides on one evolving picture A subtitle strip under each slide Render a silent landscape video Every slide readable in its hold? ↩ Fix and render again Opening line, video, action items
                                                                                                  Draws on
                                                                                                        Used by

                                                                                                              /blast-radius

                                                                                                              Find what a change could break somewhere else before it ships, beyond the diff, and prove the one fact it's safe because of by running real code instead of writing it up. Read the skill

                                                                                                              PR and commits yes no Read the change, including what the diff doesn't say Find the one fact it's safe because of /why /why Look where grep stops: libraries, timing, wire formats Rate each risk by chance and cost Prove the fact by running real code Big or wide change? /arena /arena Writeup with the fact proven or unproven /how /how /unslop /unslop
                                                                                                              Draws on
                                                                                                                    Used by

                                                                                                                          Design

                                                                                                                          Parallel attempts, races, and adversaries before code settles.

                                                                                                                          /architect

                                                                                                                          Sketch types, signatures, and module structure before code, then stay in the loop while implementation fills in. Read the skill

                                                                                                                          ownership changes yes optional pressure pushback no scaffold first no yes /how /how Ground: model every system touched /why /why Sketch: design it twice /arena /arena Exhaust the Design Space Exhaust the Design Space Screen against design red flags Checkpoint requested? Show the sketch, wait for sign-off /interrogate /interrogate ↩ Re-ground, then sketch again Implement against the sketch Foundational Thinking Foundational Thinking Outcome-Oriented Execution Outcome-Oriented Execution Same friction keeps recurring? Design package and rationale Scrap and redesign smaller Redesign From First Principles Redesign From First Principles Fix Root Causes Fix Root Causes Subtract Before You Add Subtract Before You Add ↩ Back to the sketch, re-run arena
                                                                                                                          Draws on
                                                                                                                              Used by

                                                                                                                                    /arena

                                                                                                                                    Spawn N parallel candidates at the same task, pick a base, graft the strongest parts of the losers into it. Read the skill

                                                                                                                                    own worktree each tie goes to the smaller API frame was wrong missed a graft Frame: task, rubric, runners Fan out N candidates Separate Before Serializing Shared State Separate Before Serializing Shared State Candidate 1 Candidate 2 Candidate N Cross-judge from another model family Read all, pick a base Laziness Protocol Laziness Protocol Graft the best parts by hand Redesign From First Principles Redesign From First Principles Verify the result Prove It Works Prove It Works ↩ Reframe and re-run ↩ Back to grafting Artifact and synthesis note /poteto-mode /poteto-mode
                                                                                                                                    Draws on
                                                                                                                                        Used by

                                                                                                                                              /swarm

                                                                                                                                              Fan out N parallel workers, drain them, and return one report. Read the skill

                                                                                                                                              partition race Frame: done predicate and report Shape Slice the work N workers, identical briefs, rule declared up front Fan out cloud workers in one message Each reports PASS, ISSUES, or BLOCKED Aggregate: respawn a bad result once, else a gap One consolidated report /poteto-mode /poteto-mode
                                                                                                                                              Draws on
                                                                                                                                                    Used by

                                                                                                                                                          /interrogate

                                                                                                                                                          Adversaries try to break a change or a design. A finding survives only when a run proves it. Report the findings. Do not apply fixes. Read the skill

                                                                                                                                                          phases A and B breaks the intent doesn't reproduce Scope: branch diff by default State the intent /in-your-own-words /in-your-own-words Fan out adversaries, each in its own worktree /arena /arena Each proves findings with a real run Rerun every finding's command Keep, merge shared root causes Drop Intent, verified findings, drops, no fixes
                                                                                                                                                          Draws on
                                                                                                                                                                Used by

                                                                                                                                                                      Build and clean

                                                                                                                                                                      Rules applied while writing code, tests, prose, and numbers.

                                                                                                                                                                      /tdd

                                                                                                                                                                      When fixing a bug with a clear, cheap test path, make the broken behavior executable before changing production code. The goal is a focused regression… Read the skill

                                                                                                                                                                      no yes no yes Understand the bug Cheap test path? Closest executable check instead Write the failing test Fails for the right reason? ↩ Fix the test first Smallest production fix Rerun: it passes Report fail-before and pass-after evidence
                                                                                                                                                                      Used by

                                                                                                                                                                            /typescript-best-practices

                                                                                                                                                                            TypeScript best practices. Read the skill

                                                                                                                                                                            apply first Type System Discipline Type System Discipline Discriminated unions, not optional-field bags Brand primitives, parse at the boundary Boundary Discipline Boundary Discipline unknown over any, no as casts Exhaustive switches, satisfies Real tests, structured telemetry
                                                                                                                                                                            Draws on
                                                                                                                                                                                  Used by

                                                                                                                                                                                        /no-comments

                                                                                                                                                                                        Spawn Comment Sicko, fix accepted findings, and offer encodings for claimed constraints. Read the skill

                                                                                                                                                                                        thin keeps and kills rejected twice no yes sketch only Scope: diff against main Comment Sicko Comment Sicko Audit its report, reject overreach /how /how /why /why Fail and report it open Fix needs a new shape? Delete the dead path, use the real API /architect /architect Smallest root-cause fix in scope Fix Root Causes Fix Root Causes Redesign From First Principles Redesign From First Principles Offer to encode constraint comments Report deletions, fixes, open work /poteto-mode /poteto-mode
                                                                                                                                                                                        Draws on
                                                                                                                                                                                          Used by

                                                                                                                                                                                                /unslop

                                                                                                                                                                                                Cut AI tells from any writing. Read the skill

                                                                                                                                                                                                Draft text Scan the pattern catalog Content Language Style Filler and jargon Plain speech Rewrite, keeping meaning and tone
                                                                                                                                                                                                Used by
                                                                                                                                                                                                    11 skills

                                                                                                                                                                                                      /technical-writing

                                                                                                                                                                                                      Layered technical-writing standard: Diátaxis structure, Google developer style sentences, STE instruction rules, Global English syntax. Read the skill

                                                                                                                                                                                                      Draft Pick one mode Tutorial How-to Reference Explanation Sentences to the reader One statement at a time One reading only Vary the rhythm /unslop /unslop
                                                                                                                                                                                                      Draws on
                                                                                                                                                                                                            Used by

                                                                                                                                                                                                                  /benchmark-checklist

                                                                                                                                                                                                                  Vet a perf measurement (limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before you report or act on it. Read the skill

                                                                                                                                                                                                                  one number in the PR baseline vetted here harness vetted here Write the claim you expect to ship Read the script, check machine load Why not double? Name the limiter Was every side tuned? Did it break physical limits? Did it error? Does it reproduce over 5 alternating runs? Does it matter end to end? Did the work even happen? Verdict, number, runs, range, limiter Opening a PR Opening a PR Perf issue Perf issue Hillclimb Hillclimb
                                                                                                                                                                                                                  Draws on
                                                                                                                                                                                                                        Used by

                                                                                                                                                                                                                              Long runs

                                                                                                                                                                                                                              Designing a bespoke run and keeping a trail a human can audit.

                                                                                                                                                                                                                              /figure-it-out

                                                                                                                                                                                                                              Design an auditable playbook when no narrower one fits: a large migration, an ambitious multi-part change, or work a human reviews after stepping away. Read the skill

                                                                                                                                                                                                                              read its principles one-way doors skip for settled designs yes no next unit all units done /poteto-mode /poteto-mode Frame: done predicate, scope, rigor Prove It Works Prove It Works Never Block on the Human Never Block on the Human Design the workflow: units, riskiest first, harness first Foundational Thinking Foundational Thinking Separate Before Serializing Shared State Separate Before Serializing Shared State /architect /architect /arena /arena Laziness Protocol Laziness Protocol Run a unit as an experiment Sequence work into verifiable units Sequence work into verifiable units Moved the predicate? Keep Revert Log a row /show-me-your-work /show-me-your-work ↩ Next unit Verify the whole on the real product Encode Lessons in Structure Encode Lessons in Structure Playbook, rigor, trail, what's open
                                                                                                                                                                                                                              Draws on
                                                                                                                                                                                                                                  Used by

                                                                                                                                                                                                                                        /show-me-your-work

                                                                                                                                                                                                                                        Keep a reviewable decision trail for long-running or unattended work: a TSV log with one row per decision (what, why, evidence, result). Read the skill

                                                                                                                                                                                                                                        plain words evidence from scripts gap or wrong row Start decisions.tsv from the template One row per decision: what, why, evidence, result /unslop /unslop Encode Lessons in Structure Encode Lessons in Structure Append only, supersede wrong rows Audit rows against the transcript Add superseding rows Cross-model review of the trail Reply ends with an Attention section /poteto-mode /poteto-mode
                                                                                                                                                                                                                                        Draws on
                                                                                                                                                                                                                                            Used by

                                                                                                                                                                                                                                                  Verify

                                                                                                                                                                                                                                                  Project-local skills that drive the real app or check a property formally.

                                                                                                                                                                                                                                                  /create-verification-skill

                                                                                                                                                                                                                                                  Generate a project-local verification skill that drives your app the way a user does — any language, framework, or platform. Read the skill

                                                                                                                                                                                                                                                  no yes fails no yes Interview the repo: surface, run, drive, observe, isolate Builds and starts? Fix it or report it first Generate verify skill: launch, doctor, drive, evidence, cleanup Seed a feature map with the top features Run it end to end on one feature Evidence survives cleanup? ↩ Fix the skill, run again Offer the maintenance loop /maintain-verification-skill /maintain-verification-skill
                                                                                                                                                                                                                                                  Draws on
                                                                                                                                                                                                                                                        Used by

                                                                                                                                                                                                                                                              /maintain-verification-skill

                                                                                                                                                                                                                                                              Periodic pass that keeps a project's verification skill and feature map honest: parallel source readers per feature, one live session driving every feature, at most one PR of proven corrections. Read the skill

                                                                                                                                                                                                                                                              none found doc drift harness gap product bug Locate the verify skill Fix the feature map index /create-verification-skill /create-verification-skill Source wave: one read-only subagent per feature Reconcile recipes, spot-check drift Live pass: drive every feature, doctor between drives Triage each gap Fix the map Fix the harness, drive it again Report it, keep it out of the PR One PR of proven fixes, or clean or blocked
                                                                                                                                                                                                                                                              Draws on
                                                                                                                                                                                                                                                                    Used by

                                                                                                                                                                                                                                                                          /create-formal-verification-skill

                                                                                                                                                                                                                                                                          Generate a project-local skill that formally verifies the code where a bug costs the most and tests reach the least, in any language, with whichever verification tool fits. Read the skill

                                                                                                                                                                                                                                                                          read TLA+ results no yes Pick a promise where a break hurts users Let the question pick the tool Verify one property, true to the code Show it fail on a broken variant Generate a verify skill with coverage and sync commit /statechart /statechart Catches a scratch break? ↩ Fix the skill or the check Hand off: property, tool, bounds, findings /maintain-formal-verification-skill /maintain-formal-verification-skill
                                                                                                                                                                                                                                                                          Draws on
                                                                                                                                                                                                                                                                                Used by

                                                                                                                                                                                                                                                                                      /maintain-formal-verification-skill

                                                                                                                                                                                                                                                                                      Bring a project's formal verification back in line with the code after the code changes: find the commits that touched verified code, update the model, harness, or properties to describe the code as it is now, rerun, and say whether each failure is drift in the verification or a bug in the code. Read the skill

                                                                                                                                                                                                                                                                                      none found no effect changed shape promise changed on purpose promise may be broken pass fail a step can't happen every step happens Find verify skills and their sync commit Run each check as it is /create-formal-verification-skill /create-formal-verification-skill Read every change to covered code What did the change do? Update the verify skill and sync commit Update the model from the code Change the property, cite evidence Rerun Break the code, confirm the check still fails Replay the counterexample on real code ↩ Fix the model, rerun Report a bug with its commit Each check: in sync, updated, bug, or blocked
                                                                                                                                                                                                                                                                                      Draws on
                                                                                                                                                                                                                                                                                            Used by

                                                                                                                                                                                                                                                                                                  /statechart

                                                                                                                                                                                                                                                                                                  Check a TLA+ model of a system that moves between states, such as a product flow, a protocol, or a service, and draw it as a Mermaid statechart. Read the skill

                                                                                                                                                                                                                                                                                                  too busy yes TLA+ spec: the reader's rules as invariants View: state and step labels in the reader's words Run the statechart command TLC checks each rule, re-runs past breaks About 20 arrows or fewer? ↩ Coarser labels or hidden steps Show chart.mmd and one line per bug Replay each bug path on real code
                                                                                                                                                                                                                                                                                                  Used by

                                                                                                                                                                                                                                                                                                        Make it yours

                                                                                                                                                                                                                                                                                                        Turning habits, sessions, and repeated mistakes into durable changes.

                                                                                                                                                                                                                                                                                                        /automate-me

                                                                                                                                                                                                                                                                                                        A guided flow for turning the user's working conventions into a skill agents will follow. The output is one -mode skill tailored to them (e.g. jay-mode… Read the skill

                                                                                                                                                                                                                                                                                                        yes no shape, not content Existing -mode skill? Mine history since its last edit Mine recent transcripts in parallel slices Ask structured questions Cluster signals into sections /poteto-mode /poteto-mode Draft with create-skill Iterate the prose with the user /unslop /unslop Land it through a worktree and PR
                                                                                                                                                                                                                                                                                                        Draws on
                                                                                                                                                                                                                                                                                                              Used by

                                                                                                                                                                                                                                                                                                                    /reflect

                                                                                                                                                                                                                                                                                                                    Spawn three parallel review subagents over the active transcript, surface learnings, and route each to a concrete edit on an existing skill. Read the skill

                                                                                                                                                                                                                                                                                                                    approved subset Locate this chat's transcript Judgment reviewer Tooling reviewer Divergent reviewer Synthesizer: accepted, rejected, backlog Move lint-able items to backlog Encode Lessons in Structure Encode Lessons in Structure File backlog items now User approves edits? Copy the skill locally, then edit Summary of edits, backlog, drops /poteto-mode /poteto-mode
                                                                                                                                                                                                                                                                                                                    Draws on
                                                                                                                                                                                                                                                                                                                        Used by

                                                                                                                                                                                                                                                                                                                              /correct

                                                                                                                                                                                                                                                                                                                              Find the mistakes agents keep repeating in this repo and make each one impossible. Read the skill

                                                                                                                                                                                                                                                                                                                              no no no yes yes yes operator corrects again Read commits, reverts, reviews, workaround comments Group mistakes into classes seen twice Architecture can remove it? Types or a lint can block it? A behavior test can catch it? Docs or an agent rule, last Fix it, one commit per class Prove the check fails on a real past mistake Update the rule table ↩ Fix and add the rule
                                                                                                                                                                                                                                                                                                                              Used by

                                                                                                                                                                                                                                                                                                                                    /make-bot-ui

                                                                                                                                                                                                                                                                                                                                    Build a page the user clicks. A server on this computer POSTs JSON to a webhook routine. The bot wakes with that JSON. Keep the sender key on the… Read the skill

                                                                                                                                                                                                                                                                                                                                    Create a webhook routine User copies the URL and sender key Request the key with a secret card, never in chat Local server stores the URL and key Expose it on the tailnet over HTTP Probe with a harmless payload Page buttons POST to the local server Server POSTs JSON to the webhook Bot wakes and treats the body as data
                                                                                                                                                                                                                                                                                                                                    Used by

                                                                                                                                                                                                                                                                                                                                          Benny automation

                                                                                                                                                                                                                                                                                                                                          The skills behind the Benny pack for Slack issue reports.

                                                                                                                                                                                                                                                                                                                                          /setup-benny

                                                                                                                                                                                                                                                                                                                                          Configure Benny and prepare its triage and repro automations. Read the skill

                                                                                                                                                                                                                                                                                                                                          no yes Copy the pack into the target repo Enable pstack in project settings Shared pstack skills resolve? Stop and explain Adapt config, feature map, routing map /how /how /why /why /tdd /tdd /unslop /unslop Fill required choices, check integrations Verify the control adapter Prepare the two live automations Test thread safety 6 principles 6 principles
                                                                                                                                                                                                                                                                                                                                          Draws on

                                                                                                                                                                                                                                                                                                                                              /triage-issue-reports

                                                                                                                                                                                                                                                                                                                                              Triage Slack issue reports with one thread-only verdict, evidence review, cause-aware routing, tracker dedupe, and fail-closed ticket creation. Read the skill

                                                                                                                                                                                                                                                                                                                                              regressions bug or performance feature, question, reroute Freeze the source thread coordinates Read the whole report and attachments Separate Before Serializing Shared State Separate Before Serializing Shared State Trace the cause before routing /how /how /why /why Classify Route, dedupe, file if new Preflight the parent, post one verdict /unslop /unslop Minimize Reader Load Minimize Reader Load Watch one follow-up window
                                                                                                                                                                                                                                                                                                                                              Draws on

                                                                                                                                                                                                                                                                                                                                                  /reproduce-and-fix-issues

                                                                                                                                                                                                                                                                                                                                                  Reproduce triaged Slack bugs through a configured app-control adapter, verify existing fixes, and open a bounded draft pull request only after before-and-after proof. Read the skill

                                                                                                                                                                                                                                                                                                                                                  other or timeout bug or performance person owns it fix artifact neither read-only workers no repro confirmed Freeze source coordinates Wait for a trusted triage marker Stop silently Someone fixing it, or a fix exists? Verify the existing fix Study the report and trace the code /how /how /why /why Guard the Context Window Guard the Context Window Reproduce twice through the real UI Report could not reproduce Capture evidence, post the repro /unslop /unslop Root-cause and implement a bounded fix Fix Root Causes Fix Root Causes /tdd /tdd Prove the fix through the same UI path Prove It Works Prove It Works Sequence work into verifiable units Sequence work into verifiable units Open a draft PR
                                                                                                                                                                                                                                                                                                                                                  Draws on

                                                                                                                                                                                                                                                                                                                                                      Slack conversations

                                                                                                                                                                                                                                                                                                                                                      Previous Page

                                                                                                                                                                                                                                                                                                                                                      Agents

                                                                                                                                                                                                                                                                                                                                                      Agent instructions from the pstack plugin.

                                                                                                                                                                                                                                                                                                                                                      An unofficial reader for poteto's pstack plugin. All content comes from the cursor/plugins GitHub repo. Not affiliated with poteto or Cursor.

                                                                                                                                                                                                                                                                                                                                                      On this page

                                                                                                                                                                                                                                                                                                                                                      Start and steer/poteto-mode/poteto-help/setup-pstack/in-your-own-words/sharpen/broUnderstand/how/why/teach/recall/ketchup/ketchup-video/blast-radiusDesign/architect/arena/swarm/interrogateBuild and clean/tdd/typescript-best-practices/no-comments/unslop/technical-writing/benchmark-checklistLong runs/figure-it-out/show-me-your-workVerify/create-verification-skill/maintain-verification-skill/create-formal-verification-skill/maintain-formal-verification-skill/statechartMake it yours/automate-me/reflect/correct/make-bot-uiBenny automation/setup-benny/triage-issue-reports/reproduce-and-fix-issues