A field guide for Spencer Hanson

Become an expert pstack user

Summary by Spencer. Based on Lauren Tan’s pstack work; see the original sources.

pstack is Lauren Tan's plugin of skills that makes your Grok Bot agents plan, check, and prove their work like a careful senior engineer. This guide covers what it is, the eight skills to learn first, recipes you can copy, and where to watch Lauren use it.

Start here Cheat sheet Videos

What pstack is

pstack is a free plugin of skills by Lauren Tan, who goes by @poteto. She works on Grok Bot, helped build React Compiler, and worked at Meta and Netflix before that. A skill is just a saved set of written instructions an agent follows. pstack is the set she uses every day, shared so your agents work the way a careful senior engineer does.

Her stated goal is the opposite of "more code faster". In the README she writes that pstack "helps you write less, but higher quality code", and that if you want to go fast, go deep first.

The mental model: a restaurant kitchen

Lauren's favorite picture is a Michelin kitchen. You are the head chef. You no longer chop every onion, but you are responsible for every plate, so you set up the kitchen: the recipes, the stations, the tools, and the tasting. pstack is a ready-made kitchen setup.

YouState the goal and how you'll know it's done.
/poteto-modeThe head of the kitchen. Picks the right recipe and keeps the to-do list.
23 playbooksThe recipes: bug fix, feature, prototype, overnight run, and so on.
SkillsThe stations: /sharpen, /arena, /unslop, /reflect and about 30 more.
24 principlesThe house rules, each 10 to 20 lines, like "prove it works".

Three ideas run through everything:

Trust comes from proof. An agent that can run your app and show you real output is one you can leave alone. That's why verification skills matter most.
Many models beat one. Several skills give the same job to different AI models and compare. When two models agree, that's a strong signal.
Fix the kitchen, not the plate. When agents keep making the same mistake, change the setup (a rule, a check, a skill edit) so the next agent can't make it.

pstack was built for Cursor and also runs in Grok Bot, where it updates on its own. Some of its docs mention Cursor-only features like Custom Modes, worktrees and /loop. The rule that always works: start each serious task with /poteto-mode.

Setup in three steps

Install it. In a chat, type /add-plugin pstack, or add it from the plugin list. Lauren says installs through Grok Bot or Cursor update automatically. Installing changes nothing until you call a skill.
Pick your budget and models. Run /setup-pstack. It asks for a reasoning budget, then shows each role (code helpers, judgment and writing, review panels) with a model, and writes a small rule file. The budgets are:
unlimited max reasoninglarge xhigh, the defaultmedium highsmall medium
Setting a role to auto or inherit-parent makes it use whatever model your chat uses, which saves money. The new settings apply to new chats, so start a fresh one afterward.
Run one real task. Start with /poteto-mode, a goal, and a check that can pass or fail. Watch the to-do list. Its first items are the playbook's steps, and any step it skips stays visible as skip: reason.

/setup-pstack

/poteto-mode add a word-count line under each story page in the archive. nothing else on the page changes. show me a screenshot.

About cost

pstack spends extra on helper agents and review panels. Each entry in a panel list is one more helper. To spend less: rerun /setup-pstack with a smaller budget, set roles to auto, shorten panel lists, and save /poteto-mode for work that needs rigor.

Lost? /poteto-help answers questions about pstack and hands you a prompt to send. It never starts the work itself.

/poteto-help which skill should i use to get a second opinion on a book draft?

Start here: the 8 that matter most for you

Picked for a team of bots doing creative writing, a small-business automation side project, and a home-server app. Replace anything in <angle brackets>. Tap a card to open it.

1/poteto-modeThe front door

What it does. You give it a goal and a way to tell it's done. It matches the task to one of 23 playbooks (step lists for bug fixes, features, prototypes, overnight runs and more), copies those steps into a visible to-do list, and calls the other skills when a step needs them. Then it checks its own work against the real thing and writes you a plain reply.

Use it when. Your hardest or most important tasks. Lauren's own advice: you don't have to use it for everything, just the work that needs the most rigor. Skip it for quick questions.

Tip. State the goal, the done check, and the proof you want to see. Leave out the how, and don't list skills. If you change subjects mid-chat, start with "new task".

Try one:

/poteto-mode the appointment reminder for the dental project sometimes sends the same patient two texts. repro it first with the test patient list, then fix it. done means one text per appointment. show me the real output.

/poteto-mode add a search box to the text archive on my home server. the existing archive pages stay exactly the same. done means searching a word i know is in the archive returns that message. send me a screenshot from a phone-sized screen.

/poteto-mode investigate why the archive import skipped last week's messages. tell me what we know, what data you used, and your best guesses. don't change anything yet.

2/in-your-own-wordsCheck it understood you

What it does. The agent restates, in its own words, what it thinks your goal is and what problem you're trying to solve. Nothing else. Lauren added it in pstack 0.15.23 to make sure you and the agent agree on the goal before work starts.

Use it when. Before any task where a misunderstanding would waste a lot of effort: a messy brain-dump, a long voice note, a request with several parts. A misreading costs one message to fix here, and a whole run to fix later.

Tip. Hold back your own theory of the cause until it has restated the problem. Your guess narrows where it looks.

Try one:

/in-your-own-words i want the bot team to turn my rough notes for <book title> into a 12-spread picture book draft for ages 4 to 7. keep my jokes. the main character should sound like she does in book one.

/in-your-own-words <paste the dentist's email or the long voice-note transcript here>

3/sharpenAim the task higher

What it does. Before starting, the agent asks how a top expert would approach the task (their real sources and methods, plus an outside check that the result is right), what you are really after, and whether you over- or under-specified it. It loosens constraints that don't help, leaves your choices to you, then does the work. It does not hand you back a rewritten prompt.

Use it when. When you know roughly what you want but suspect a pro would go about it differently. Great for creative work, plans, and anything where the obvious first attempt would be mediocre.

Tip. Sharpen keeps one outside check that the result is right. Ask what that check was if it doesn't say.

Try one:

/sharpen write the opening spread for book two. it should feel like it belongs with book one.

/sharpen draft a plan to automate new-patient intake for the dental practice using the tools they already have.

/sharpen set up nightly backups of the text archive on my home server.

4/ketchup and /broCatch up in plain words

What it does. /ketchup tells you what changed in this chat since your last message, in well under 150 words plus small pictures, and lists only the decisions that are truly yours to make, each with a recommendation and what happens if you don't answer. /bro restates the last reply in plain human language, shorter, with no jargon.

Use it when. /ketchup when you come back to a busy chat on your phone. /bro any time a reply is thorough but you still don't know what it said.

Tip. Both are the whole prompt. Just type the command.

Try one:

/ketchup

/bro

5/arenaSeveral attempts, keep the best

What it does. Runs several attempts at the same brief in parallel (by default one on a Claude model and one on a Grok model), has a judge from a different model family score them against a rubric, picks the best one as the base, then hand-folds in the strongest parts of the others. You get one result plus a note on what came from where.

Use it when. When one attempt would lock in the first idea: a book opening, a page layout, a pitch, a system design. Also a cheap second opinion on an approach before you commit.

Tip. Arena is for one brief done several ways. If you want different pieces checked in parallel, that's /swarm.

Try one:

/arena write the first three spreads of <book title>. same brief to each attempt. pick the strongest and fold in the best lines from the others.

ask /arena for a second opinion on this thread and our approach.

6/unslopMake the writing sound human

What it does. Edits writing to remove the patterns that make text sound machine-written: words like delve, crucial and tapestry, em dashes, "not just X but Y", forced groups of three, chatbot phrases, vague hedging, and fancy words where plain ones work.

Use it when. Any prose your bots produce: book text, back-cover blurbs, emails to the dental practice, website copy, your own drafts.

Tip. Say the tone you want to keep. Unslop changes the patterns, not the meaning.

Try one:

/unslop the back-cover blurb. keep it warm and playful. no em dashes.

can we unslop and tighten the new changes?

7/reflectLearn from the session

What it does. Three reviewers read the chat from different angles (judgment, tooling, and a contrarian view). A fourth merges what they found into Accepted, Rejected and Backlog lists, each item routed to a specific edit on an existing skill. Nothing changes until you approve.

Use it when. At the end of a long or bumpy session, so the next run starts smarter. This is how your bot team improves over weeks.

Tip. Approve only the edits that would change a future decision. Skip one-offs.

Try one:

/reflect that took too long. capture what we learned so the next run doesn't repeat it.

8/create-verification-skillLet agents prove it works

What it does. Studies your project and writes a project-local skill that teaches any agent to start your app, use it the way a person does, capture proof (screenshots, logs, stored values), and clean up. It also writes a feature map: each feature, how a user reaches it, and what proves it works. It runs the new skill once end to end before handing it over.

Use it when. As soon as a project is real: the archive web app on your home server, the dental automation. Lauren calls verification the single most important skill, because an agent that can check its own work is one you can trust when you're not watching.

Tip. Keep the feature map fresh with /maintain-verification-skill. Lauren runs it as a daily automation.

Try one:

/create-verification-skill for the text archive web app on my home server. drive it the way i do from my phone's browser.

/maintain-verification-skill

The full skill catalog

One line each, grouped by what you're trying to do. /poteto-mode already calls most of these when a step needs them.

Front door and setup

/poteto-modeDefault entry point for any non-trivial task. Picks a playbook and runs the other skills for you.
/poteto-helpAsk how to use pstack. Answers, hands you a prompt to send, and starts no work.
/setup-pstackPick a reasoning budget and a model for each role. Writes a rule that applies to new chats.

Understand before acting

/in-your-own-wordsThe agent restates your goal and the problem so you can catch a misreading early.
/sharpenApproach the task like a top expert, aimed at what you really want, then do it.
/howHow something works now, or where new code should live. A senior-engineer walkthrough.
/whyWhy something is shaped the way it is. Searches history, tickets, docs and chat, with honest confidence levels.
/teachRuns /how and /why and explains it plainly, building diagrams up one piece at a time.
/recallRebuilds your recent context on a topic from past chats and the shared record. A tight brief.
/ketchupWhat changed in this chat since your last message, short, with only your decisions listed.
/broThe last reply again, in plain human words.

Design and decide

/architectSettles the shape (types, functions, modules) before code, using an arena of sketches. Add "with checkpoint" to review first.
/arenaSeveral attempts at one brief, a cross-model judge, keep the best and graft in the rest.
/figure-it-outDesigns a custom, auditable plan for big or unusual work, then runs it as small experiments.

Run in parallel and review

/swarmMany cloud workers over separate slices or a race, one combined PASS / ISSUES / BLOCKED report.
/interrogateDifferent models try to break a change. Findings sorted into act on, consider, noted, dismissed.
/blast-radiusWhat a small change could break elsewhere, with the one fact that makes it safe proven by running code.
/benchmark-checklistVets a speed number before you trust or share it.

Build and fix

/tddFix a bug by writing a failing test first, only when a cheap test path exists.
/typescript-best-practicesTypeScript rules for .ts and .tsx work.
/no-commentsA separate reviewer (Comment Sicko) strips needless code comments before review.

Write well

/unslopRemoves the tells of machine-written prose.
/technical-writingA layered standard for docs, READMEs, plans, PR descriptions and commit messages.

Prove it and keep a record

/create-verification-skillGenerates a project skill so agents can drive your app like a user and capture proof, plus a feature map.
/maintain-verification-skillBrings that skill and its feature map back in line with the app as it changes.
/show-me-your-workKeeps a decision log (one row per decision, with evidence) and ends with an Attention section from a different model.

Get better over time

/reflectTurns what a session taught into skill edits you approve.
/correctFinds mistakes agents keep repeating in a project and makes them impossible: structure first, then types, lint, tests, and docs last.
/automate-meDrafts your own personal mode skill (say, spencer-mode) from how you actually work.

Grok Bot specific

/make-bot-uiBuilds a page or dashboard whose buttons wake a Grok Bot over a webhook, keeps the key on the server, and can share it over Tailscale.

The 23 playbooks inside /poteto-mode

Playbooks are step lists, not skills, so they have no slash command. Describe the task and /poteto-mode picks one. A few phrases pick one directly: "babysit this pr", "land the stack", "take over this branch", "pause safely", "full autopilot on this queue", "stack them, don't ship".

Investigation. A read-only question. How does it work, why is it like this, are we sure.
Bug fix. Reproduce a defect, find the root cause, fix it with real evidence.
Perf issue. Trace a measured slowness and improve it against a baseline.
Hillclimb. Improve one number steadily with before and after measurements and a decision log.
Runtime forensics. Diagnose a live symptom like a leak or a spinning CPU. The deliverable is a diagnosis.
Trace forensics. Diagnose a captured profile or trace someone hands you.
Feature. New or changed behavior, built from a named data shape.
Refactoring. Change structure without changing behavior.
Prototype. A throwaway sketch to make a decision cheaply, or to settle a question by trying it.
Visual parity. Make two screens match pixel for pixel.
Authoring a skill. Write or edit a SKILL.md with validation and review.
Eval. Test, blind, whether a skill or prompt change really changes agent behavior.
Babysit. Drive a pull request to merge-ready. Doesn't merge unless you ask.
Shipping. Independently verify a green stack, then land it from the bottom up.
Autonomous run. Drive one long task to a finish condition without stopping.
Orchestrate. A multi-day program run by one coordinator chat with many helpers.
Autopilot-full. A queue of independent changes run all the way to merged, each verified.
Autopilot-stack. Build and verify a queue of changes as one stack that you land yourself.
Session pickup. Take over another agent's in-flight work without redoing finished parts.
Pause safely. Stop cleanly with a checkpoint and a resume note.
Multi-phase plan. Write a plan of small verifiable steps. Plans only, no building.
Worktree cleanup. Reclaim disk space from old copies of a project, safely.
Opening a PR. Small ordered commits and a clear description. Runs at the end of the others.

Not in pstack, though it mentions them: /deslop, control-cli and control-ui come from the cursor-team-kit plugin. /loop and /create-skill are Cursor built-ins. There is no /orchestrate skill; Orchestrate is a playbook.

The 24 principles, in plain words

Principles are one-rule skills that /poteto-mode reads and cites when they change a decision. You rarely call one directly. Instead, you steer with its name in one line, because the agent already knows the rule.

Core

Laziness protocol. Make the smallest change that solves the problem. Fewer lines beat clever ones. Say: "apply laziness protocol. what's the smallest change?"
Foundational thinking. Get the basic structure right before the details, so the rest becomes obvious. Say: "apply foundational thinking before you write logic."
Redesign from first principles. When a new need arrives, redesign as if it had been there from day one instead of bolting it on. Say: "redesign from first principles, don't bolt it on."
Attack the premise. If two fixes built on the same assumption both failed, test the assumption instead of trying a third fix. Say: "attack the premise. what are both fixes assuming?"
Subtract before you add. Clear out dead weight first, then build on the simpler base. Say: "subtract before you add."
Minimize reader load. Make things easy to follow: fewer layers, less hidden state. Say: "minimize reader load here."
Outcome-oriented execution. In a planned rewrite, head straight for the finished design. Don't build throwaway in-between states. Say: "be outcome oriented. skip the compatibility shims."
Experience first. Choose what delights the person using it over what's convenient to build. Fewer polished things beat many rough ones. Say: "experience first. what would delight the reader?"
Exhaust the design space. For a new kind of problem, build two or three real options and compare them before choosing. Say: "exhaust the design space. show me 3 options."
Build the lever. Build the tool or script that does or proves the work instead of doing it by hand. A reviewer can rerun the tool. Say: "build the lever. script it so i can rerun it."

Architecture

Model the domain. Put the rules of the real-world thing into one clear structure, like a state machine or a table, instead of scattered if-statements. Say: "model the domain instead of adding more branches."
Boundary discipline. Check messy outside input once, where it enters. Trust it inside. Say: "apply boundary discipline."
Type system discipline. Design data types so wrong states can't even be written down. Say: "make the illegal states unrepresentable."
Make operations idempotent. A step run twice, or rerun after a crash, should end in the same place. Vital for backups, imports and reminders. Say: "make it idempotent. rerunning must be safe."
Migrate callers then delete legacy APIs. When you replace an old way, move everything over and delete the old way in the same wave. Say: "migrate the callers and delete the old one."
Separate before serializing shared state. If two agents might write the same file, give each its own copy instead of making them take turns. Say: "separate before serializing. own workspace per agent."

Verification

Prove it works. Check the real thing, not a stand-in. "It compiles" or "the agent said so" is not proof. Say: "apply prove it works. show me the real output, not the build log."
Fix root causes. Reproduce the problem first, then keep asking why until you reach where it really went wrong. Say: "fix the root cause, not the symptom."
Sequence verifiable units. Break work into small steps that each end in a check, and check each before the next. Say: "sequence this into verifiable units."
Test behavior, not implementation. Tests should check what a user would notice, so they break when behavior breaks, not when internals move. Say: "test behavior, not implementation."
Explain the number. Before trusting a measurement, find what limits it and rule out that it measured the wrong thing. Say: "explain the number before we share it."

Delegation

Guard the context window. Send bulky reading to helper agents and keep only summaries in the main chat, so it stays sharp. Say: "guard the context window. use subagents for the bulk."
Never block on the human. For reversible work, go ahead and show the result rather than asking permission. Still pause for anything irreversible. Say: "don't block on me for reversible steps."

Recipes that combine skills

Each recipe is a short series of messages. Copy them one at a time.

Big new idea: sharpen, architect, arena, reflect

Send these as separate messages, one after another. Don't stack them in one prompt; pstack works best when each step has its own turn.

Aim it. Let the agent find the expert approach and your real goal.

/sharpen build a small web dashboard where the dental office can see which reminder texts went out today.

Settle the shape before code. /architect runs its own arena of design sketches from different models, so you don't need a separate arena here. "with checkpoint" makes it stop and show you first.
```
/architect it, with checkpoint. show me the design before you write code.
```
Optional second opinion on the result, or on any non-code piece like the onboarding email.
```
ask /arena for a second opinion on this design and our approach.
```

Bank the lessons.

/reflect capture what we learned so the next run doesn't repeat it.

Shortcut: /poteto-mode already routes code that crosses boundaries through /architect. Name the skills yourself only when you want more of one step.

A picture book draft that sounds like you

Creative work benefits most from multiple attempts and a human-voice pass.

Make sure it gets the brief.

/in-your-own-words <your notes for the book>

Get several takes and keep the best bits.

/arena write spreads 1 to 3 from these notes. same brief to each. pick the strongest and fold in the best lines from the others.

Strip the machine tells.

/unslop the draft. keep the rhythm for reading aloud. no em dashes.

If the bot's explanation of its choices is dense:
```
/bro
```

Something broke in the dental automation

Reproduce first, fix the cause, prove it. Then have other models try to break the fix.

Describe the symptom, not your theory.

/poteto-mode <symptom>. repro first, then fix and verify. show me the real output.

Skeptical review before it goes live.

/interrogate the whole change, but skeptically. don't change anything yet. no nitpicks unless it's a real bug.

Check what else it could touch.
```
/blast-radius of this change
```

Hand it off overnight, audit in the morning

Lauren's overnight contract: a goal, a finish line that can pass or fail, permissions, and an escape hatch. A duration is not a finish line.

Before bed:

/poteto-mode im going to bed. <goal>. done means <checks that pass or fail>. keep a decision log. don't ask me before committing. if you're truly stuck after a few hours, stop and write up why.

In the morning. Read its Attention section first; a reviewer from a different model wrote it.
```
/show-me-your-work catch me up on what you did last night.
```

"im going to bed" tells the agent to stop asking and keep going. Only trust a loop once the agent can verify its own work, so set up /create-verification-skill first.

Coming back to a project after a few days

Rebuild context before you ask for anything new.

Across past chats:

/recall my work on the text archive from last week.

Inside one busy chat:
```
/ketchup
```

Understand what your bots built

Good for reviewing work you didn't write. You get an explanation, not a summary.

Plain explanation, built up with diagrams:

/teach me how the archive import works and why it was built this way.

Or make it argue its case:

/teach me why you implemented it this way and not <other way>. what did you trade off?

A phone-friendly control panel for a bot

/make-bot-ui is the one Grok Bot-specific skill. Buttons on a page wake a bot through a webhook. The secret key stays on the server, and you can reach the page from your phone over Tailscale.

/make-bot-ui build a page with two buttons for my archive bot: "import today" and "send me a digest". host it on the home server and give me the tailnet link.

Make pstack yours

Once you've used it for a few weeks.

Turn your own habits into a personal mode skill:
```
/automate-me
```
Stop correcting the same mistake by hand:
```
/correct agents keep <the mistake>
```

Lauren's starter prompt for new coders, from her Oct 9 post:

make me an engineer bot that uses cloud agents and pstack for coding work. it should make a project to group together related tasks

Watch Lauren work

Every link and time below was checked this session against the video's own transcript or page. Tap a YouTube time to jump straight there. Galaxy times are offsets you scrub to by hand (X can't link to a time).

LIVE: Poteto (creator of pstack) on shipping 1,000's of PR's a month at SpaceX

Matt Pocock's channel, livestream with Lauren Tan. Streamed Oct 2, 2026. 1:05:36.

The best single explanation of how she thinks about trust, verification, and running many agents. Watch this first.

Verified timestamps (12)

How I shipped 2,500 PRs last month to production

Lauren's talk, made for Cursor Compile London and posted free on X. Posted Sep 21, 2026. 38:02.

Her pinned talk. Short and dense. She says to watch it at 2x.

Timestamp links below open a YouTube re-upload by a third-party channel ("Raner"). Its length (38:02) and transcript match the original X video. X videos can't be linked to a time, so this is the only way to jump straight to a moment. YouTube copy.

Verified timestamps (7)

How Cursor Turned AI Agents Into Better Engineers (Maven workshop)

Live Zoom workshop with Q&A, Aug 12, 2026. 59:41 on YouTube.

The most direct explanation of what pstack is and why it exists, plus the eval playbook.

Timestamp links open a YouTube upload titled "Lauren Tan XAi Grokbot" from an unnamed channel. Its transcript matches the Maven workshop chapter list. The Maven page has the official chapter list. YouTube copy.

Verified timestamps (12)

The Grok Bot Galaxy livestream, Sep 15 to 17, 2026

Lauren, Matt Palmer (@mattyp) and Roshan Sadanani (@roshan_s) started a game studio from scratch, live over three days, using only Grok Bot. Their studio's first game is Thursday Arena.

Day 1: Grok Bot Galaxy Livestream 8:45:12, on X
Day 2: Grok Bot builds a Game Studio LIVE 8:23:18, on X
Day 3: Building a company in 3 days, launching today! 7:58:22, on X

Hub with all three days and the per-role session videos: x.ai/galaxy. Lauren's recap post: Sep 23 on X.

How these times were checked. The stream has no chapters or captions, and nobody posted pstack timestamps, so I transcribed the replay audio myself and read each moment in context. Times are counted from the start of each day's replay and are accurate to within a few seconds. X replays can't open at a set time, so open the day's link and drag the slider to the time shown. Coverage: all of Day 1, Day 2 from 0:00 to about 5:40 plus 6:00 to 6:33 and 7:00 to 7:27. The rest of Day 2 and all of Day 3 were not transcribed, so there may be more pstack moments there. Quotes come from a machine transcript and are lightly cleaned up (for example "PSAC" changed to "PStack").

Day 1
18:34Lauren explains what pstack is and why she open-sourced it
It's an open source plugin that takes all of the skills that I've built for doing rigorous engineering work.
Day 1
1:59:21Dr. EggBot, her bot that builds bots, runs on pstack
It uses PStack... and I basically taught EggBot how to create high-quality bots.
Day 1
2:15:53Her voice-prompt trick: talk for a few minutes, then ask the bot to restate it
Restate to me what I just said in your own words, so I know you understood me.
Day 1
2:50:28Installing pstack and the Cursor team kit with Dr. EggBot, then wiring up cloud agents
Using Dr. Eggbot to install our cursor team kit, a bunch of other skills, PStack.
Day 1
3:50:28Her "potato factory": Tater (builder bot), Hashbrown (reviewer bot), and pstack added to the repo
You can also set them up in the repo as a repo plugin. And your bot or agent can do that very easily for you.
Day 1
4:45:04A Slack PR-review automation that uses pstack
This automation is going to review pull requests for us. It's going to use PStack.
Day 1
4:46:55Why verification matters, then /create-verification-skill and the feature map, live
Without a verification skill, my bot will constantly be saying, okay, now you can run the app and click around.
Day 1
5:07:37A long spoken prompt asking for prototypes "using potato mode", then "restate in your own words"
I want you to help me using potato mode... restate in your own words before executing.
Day 2
27:43pstack's planning playbook: checklists, verification steps, and types first
One of the things that PStack includes is a planning playbook.
Day 2
1:28:03"Do I say use pstack or use potato mode?" Answer: type /poteto-mode, or just say it
Even if you're just saying use potato mode, your agent or bot should be smart enough to know what that means.
Day 2
1:31:13Asking Dr. EggBot to make an engineer bot that uses pstack and cloud agents
This engineer will use PStack in potato mode to spawn cloud agents to work on our game.
Day 2
1:50:44"Use potato mode prototyping": several game prototypes with sliders to tweak
That's when you say use potato mode prototyping. That's how the agent knows what to do there.
Day 2
1:53:33How /poteto-mode works: a router that picks skills and principles (Experience first as the example)
It's kind of like a router skill... for different scenarios, use these skills and these principles.
Day 2
1:54:53/architect races four models on the design, then she skips it for a quick prototype
This skill will use different models to come up with different plans... I'm going to actually say, let's skip architect.
Day 2
7:11:23Using /unslop or /bro to turn AI-sounding writing into plain English
I wonder if you could use the handy dandy unslop skill or the bro skill in P-stack.
Day 2
7:22:11The full autopilot playbook (called a favorite on stream), and how the /setup-pstack budget changes it
On the max level will spawn a swarm of agents who actually run the application and fuzz the application.

Tips and common mistakes

Don't use /poteto-mode for everything. Lauren's words: just your hardest tasks that need the most rigor. Quick questions don't need it.
Write a done check, not a duration. "Make it better" or "work on it for 4 hours" gives the agent nothing to check. "Done means the search returns this message" does.
Ask for the proof you want to see. A screenshot, the real output, the stored value, a before and after. A green build only proves it compiles.
Don't list skills in your prompt. "use /how then /architect then /arena" usually reorders or drops steps the playbook would keep. Name a skill only to override one choice.
Keep your theory to yourself at first. Let the agent restate the problem. A stated guess narrows where it looks.
Never take the first design. Ask for two or three prototypes, with screenshots for anything visual, and pick from evidence.
Don't polish a plan with no code behind it. Reviewers invent risks that never happen. Settle open questions with quick prototypes, then review what got built.
Say "new task" when you switch subjects. Otherwise the mode treats your message as the next step of the last task.
Rerun /setup-pstack in a new chat. Model changes only apply to new chats.
Parallel agents need separate spaces. Agents working in the same folder overwrite each other. Give each its own copy, or use cloud agents.
Use /arena for one brief, /swarm for many slices. Arena repeats the same job and keeps the best. Swarm splits work and returns one report.
Don't accept every review comment. /interrogate sorts findings into act on, consider, noted and dismissed, with reasons. You can override either way.
Approve only reflect edits that change a future decision. Skill changes affect every future run. One-offs aren't lessons.
Fix a broken skill on its own. Lauren's rule: fix a misbehaving skill in its own change, not inside the work where it went wrong.
Steer in one line. "i said the goal is to repro. i did not ask for a fix yet." or "apply prove it works." You rarely need more.
Verify before you automate. A loop that can't check its own work just makes unchecked work faster.

One-screen cheat sheet

Serious task/poteto-mode <goal>. done means <check>. show me <proof>.

Did it get me?/in-your-own-words <ask>

Aim higher/sharpen <task>

Several takes/arena <brief>

Sound human/unslop <text>

Catch me up/ketchup

Plain words/bro

Past chats/recall my work on <topic>

Explain it/teach me <thing>

Try to break it/interrogate <change>, skeptically

Prove it runs/create-verification-skill

Overnightim going to bed. done means <checks>. keep a decision log.

Morning/show-me-your-work catch me up

Learn/reflect

Help/poteto-help <question>

Steerapply prove it works. show me the real output.

Screenshot this part.

Sources

The installed pstack skills on this box, read in full: poteto-help, poteto-mode, setup-pstack and 20 more, plus the poteto-help recipes and prompting references.
pstack on GitHub (cursor/plugins), its README and the ten-page guide in docs/guide.
pstack in the Cursor marketplace.
Lauren's posts on X, Sep and Oct 2026, including /in-your-own-words, "not for everything", principles, starter prompt, verification skills and auto-updates.
Video transcripts pulled from YouTube for each video above, plus my own machine transcript of the Galaxy Day 1 and Day 2 replays.

Built for Spencer Hanson, Oct 15, 2026. pstack changes often; Lauren shipped several versions in October alone. When this guide and the skill files disagree, trust the skill files, or ask /poteto-help.