Most product work dies in scaffolding. Login, a database, a waitlist, and a “real” stack go in first. Then you find out the core loop is not fun, or the page was never worth polishing.
The team here was standing up a game studio and a first game. They treated that stall as the actual problem. Grokbot ran the conversation, the specialist bots, and the knowledge work. Cursor ran the engineering. Potato mode — a Pstack plugin available in both — forced throwaway prototypes instead of production architecture.
You will set up a bot roster, share context through the repo, spawn a durable engineer bot, and cut everything that is not the core loop. Then you stay in the weeds until the agents stop going sideways.
What to copy from this bot workflow
- Split the work: Grokbot for back-and-forth and knowledge work, Cursor for coding. Both can run as cloud agents, not on your desktop.
- Give each job a bot. Dr. Eggbot creates bots. A chief of staff holds project context. An engineer bot orchestrates cloud agents and checks their work. Other bots own the lander, visuals, growth, and docs.
- Share context by pointing agents at committed plans in the repo, not by re-explaining the product in every chat.
- Prototype in potato mode: skip sign-in, skip the database, hardcode, and add debug sliders so you can tweak constants live.
- Ask the bot to restate the brief in its own words before it starts. Read that restatement. Correct it there, not after a wrong build.
- On a new codebase, inspect output. On a mature, agent-friendly codebase, delegate more.
- When an agent reasons wrong, do not only patch the one task. Turn the miss into a skill so it does not repeat.
- You cannot adjust how much compute a bot spins. You can adjust how it talks to you, what skills it loads, and what you forbid (auth, waitlists, architecture theater).
Who this is for, and who should skip it
This is for a founder, operator, marketer, or ops lead who already has — or is willing to use — Grokbot and Cursor, a git repo, and enough comfort to approve plans, read agent output, and click around a local prototype. It assumes you will run several bots at once and that someone on the team can live in a monorepo.
Skip it if you need a production app with login and a database on day one, if you will not read agent output on a greenfield project, or if you only want a single chat window and no specialist roster. Potato mode is a prototyping router, not a substitute for later engineering. Lauren’s instruction was explicit: make the engineer bot durable enough for serious work, not a prototype-only toy.
Set up the bot roster before you write production code
The goal is a small company of bots with clear jobs, not one mega-prompt. Matt’s setup used Dr. Eggbot to create new bots, a founding engineer on the landing page, a creative director on visuals, a growth engineer, and a knowledge-base bot on Notion. Lauren’s setup put a chief of staff — Steve — in front of that roster, holding credentials and the product brief, then working with the other bots.
Prepare a repo with docs and plans already committed. If someone else wrote the MVP plan with their agent’s context, point your agent at that file. That is the sharing mechanism they used.
To add an engineer bot, ask Dr. Eggbot directly, or ask the chief of staff to talk to Dr. Eggbot if that is where the context lives. Lauren’s brief: the engineer uses Pstack and potato mode to spawn cloud agents, then orchestrates them, supervises them, and checks their work. First phase is quick, lightweight prototypes so you can see how the product plays. Do not make the bot prototype-only. It has to survive the later, serious engineering.
Good looks like a bot that can restate the job, knows potato mode is in play, and is not scoped as a throwaway intern. Failure looks like an engineer that can only sketch and cannot take the product past the demo, or a local Cursor agent that does not have the bot’s context and has to start over from the docs.
Share context through the repo, not through chat
Lauren had already committed a plan. Matt pointed his agent at that document, said the first goal was a landing page in a monorepo, and asked for a plan plus a lander stack using his project planning skill.
That skill is personal, not a public pack in this session. The rule of thumb he stated: for every new project, use a scaffold and move fast. Do not write your own stack. Options he named: T3, Tstack, Expo for a React Native app, Next, or V if it is simple. He also loads opinionated UI and styling guidelines, plus a design skill called “make interfaces feel better” (circulated on Twitter; he did not name the author on the spot). He always wants OG meta tags and basic site meta — title, description, and the image you see when the page is posted or searched.
Approve the plan before coding. In this run, Grokbot applied a subtract-before-you-add correction: strip auth, strip the waitlist, ship a V1. Then he kicked the work to a Cursor cloud agent with a Pstack / potato mode prompt.
In Grokbot you can type /potato mode. You can also just say “use potato mode.” If the agent has the Pstack plugin, it should know what you mean.
Grokbot vs Cursor: who talks, who codes
Grokbot is the lightweight harness for conversation, routing, and knowledge work. Cursor is the coding harness. Use Grokbot for the back-and-forth, then Cursor for the actual engineering. Agents can run in the cloud in both cases, so the desktop is not the bottleneck.
A local Cursor agent will not automatically inherit everything the Grokbot side knows. Lauren had to start over a bit and lean on the docs in the repo. The recovery move: make the agent restate the product in its own words, then read that restatement before it builds. In their game example, she checked that it had the short competitive loop, the three-player roster, the hidden lineup, matchmaking, and ELO. Then she overrode it: skip sign-in, keep it local, no database, potato mode prototyping, several prototypes, debug sliders for game constants.
Restate this in your own words before you start working just so you can confirm it.
Use potato mode to get a throwaway prototype you can play
What you are trying to accomplish: shorten time to fun. For a game, Lauren’s bar was blunt — if it is not fun, the rest does not matter. The same cut applies to any product: do not build login before you know the loop works.
Potato mode is a router skill. It does not carry a long list of specific instructions. For different scenarios it loads other skills and principles. Two that came up:
- Experience first: choose user delight over implementation convenience. Every feature needs to be justified. Ship less, but ship better.
- Prototyping: design decisions are cheaper in throwaway HTML than in production code.
Design decisions are cheaper in throwaway HTML than production code.
It also thinks hard about data structures, because those determine almost everything else. There is an architect skill that swarms multiple models — Fable, Saul, Grok, and Composer were named — then you pick the best plan and merge useful ideas from the others. Different models excel at different tasks. For a prototype, Lauren skipped architect because it is slower and she did not care about architecture yet. She told it to use Grok for the first prototype and run locally.
What good looked like in this session: vanilla HTML, CSS, and JavaScript; everything in memory; three UI variants you can toggle; mock seed data (they fetched a list of bots from the marketplace); types and state transitions; a debug panel with sliders and inputs for constants. Cursor’s built-in browser is how you play it without leaving the tool.
Prepare: committed product docs, a decision to skip auth and persistence, and a short list of knobs you want live (they used an advantage slider, caps, and stat totals). Then run the loop: play, notice a bug, fix, replay. They caught common-bot stats that did not add to 100 and a slider that did not slide. That is the point of the playground — you should not have to re-prompt a full rebuild to test a 22% bonus or a lineup change.
We need to shorten the time to fun.
Lauren’s sequencing advice: get the most basic prototype up first so everyone can contribute to the codebase. Do not build a visual system and the prototype in parallel. It gets complicated. Visuals come after the core loop is playable. Matt had been exploring Dialkit (open source UI customization) and an asset playground with sliders on flat SVG tokens; useful later, not a blocker for V1.
Stay in the loop on a new codebase
Someone asked when to inspect output versus let the bots cook. Lauren’s split: on a mature codebase — she used Grokbot itself as the example — a lot of time goes into architecture that is already agent-friendly, so she does not micromanage. On a zero-to-one project, stay in the weeds. Read the output. Catch the agent going the wrong direction early.
That is also when you harvest skills. She reads thinking blocks (collapsed by default in Cursor; you can click in). A lot of her skills came from noticing an agent decide something without looking at the code. Matt’s version of the same advice: when you see the agent think incorrectly, that is a chance to build or update a skill, not only to say “do the next thing” until you luck into a result.
Cursor design mode is the fast correction path for UI. Open the app in the Cursor browser, turn on design mode, click the element — or draw a box around a region — and tell the bot what is wrong. Lauren used it on the broken slider and later to move lanes onto their own page. You stay in flow instead of describing a div in prose.
Visuals, when you get there: generate mock screens, use a reference (they used Super Auto Pets for light, fun graphics), then apply the look on top of the working loop. They also tried a CSS effect library; the agent over-applied shimmer and rainbows. Lauren’s read was that she had steered it badly by nerd-sniping the CSS. The fix was to retarget the visual prototype, scale the gradient to the card size, and tone it down. Play the result. If the UI is still a debug board, that is acceptable until the loop is right.
What else the bots were doing while engineering ran
This is not only a coding pattern. While prototypes compiled, Matt pointed a knowledge-base bot at Notion: company docs, the pivot, a product plan with the core loop, a diagram from earlier in the day so future bots could learn the business, and notes toward go-to-market. Next on his list for the lander side: SEO, A/B testing, and ads infrastructure, leaning into existing distribution rather than inventing a marketing system from scratch.
He also used Grokbot with computer use as an ops stunt: pull a directory of Bufo meme PNGs and add the pack as Slack emojis instead of uploading them by hand. He described about 1,200 emojis. That is the same computer-use surface you cannot throttle for compute; you only change how the bot is instructed.
A cutaway showed the same harness in a small business. Marcel at Icon Coffee in San Francisco’s Potrero Hill runs a bot named Rex as a chief of staff. After using it on school emails from a parent portal, he gave it API access to the POS for reports and growth questions, and he photographed the cafe menu so the bot could flag items that had barely sold. He described getting an extra hour or two back from repetitive work.
| Use case | Bot / tool | Input needed | Output | Owner |
|---|---|---|---|---|
| Landing page | Founding engineer bot, Grokbot, Cursor cloud agent | Committed plan, project planning skill, UI guidelines | Scaffolded lander (bun / create next app in this run), OG meta, auth stripped | Matt |
| Core product prototype | Engineer bot, potato mode, Cursor (Grok for first pass) | Repo docs, restated brief, “skip sign-in / no DB” | Throwaway HTML/JS, in-memory loop, debug sliders, multiple UI variants | Lauren |
| Visual / asset exploration | Creative director bot, Dialkit, image generation | Reference art (Super Auto Pets), slider playground | Asset playground, mock screens, later CSS/visual pass | Matt, Lauren, Roshan |
| Company knowledge | Knowledge-base bot, Notion | Product plan, diagrams, pivot notes | Updated company docs other bots can read | Matt |
| Internal ops stunt | Grokbot computer use | Emoji pack source, Slack | Bulk custom Slack emojis | Matt |
| Cafe / roastery ops | Rex (chief of staff) on Grokbot | Parent portal, POS API, menu photo | Filtered messages, sales reports, menu cuts | Marcel, Icon Coffee |
Prompts, bot instructions, and workflows
These are reconstructed from what was actually said, cleaned of filler, not rewritten into a different method.
Point an agent at shared plans and request a lander
Reconstructed from the speaker's description.
Take a look at that document. That is going to be our product.
Our first goal is to make a landing page.
Given that it is a monorepo, create a plan and propose a nice lander stack
with my project planning skill.
Read the project planning skill, the make interfaces feel better skill,
and the shared context. I want a scaffold, not a custom stack.
Include OG meta tags and basic site meta (title, description, image).
Make a plan for what a lander would look like.Create a durable engineer bot
Reconstructed from the speaker's description.
Tell Dr. Eggbot to create an engineering bot for me.
This engineer will use Pstack and potato mode to spawn cloud agents
to work on our product.
The job of the engineer bot is to orchestrate these cloud agents,
supervise them, and check their work.
For the first phase, do quick lightweight prototypes so we can get a
visual feel before we start building the real thing. We do not need
login yet when we do not even know if it is fun.
Do not make this engineer prototype-only. Make it durable enough that
it can do prototyping and also the serious engineering work later.
Restate this in your own words before you start working.Potato mode prototype, local, with debug sliders
Reconstructed from the speaker's description.
For the prototype, skip sign-in for now. Just focus on the core loop
so we can iterate on it quickly.
Use potato mode prototyping.
I want a few different prototypes to choose from.
Keep everything local for now. No DB required.
Include debug panels with sliders and input boxes to tweak variables
and constants for a quick iteration loop.Skip architecture theater on the first pass
Reconstructed from the speaker's description.
Skip the architect skill. We are just prototyping and I do not care
about architecture at this point.
Use Grok for the first prototype.
Run it locally so we can actually play it.Design-mode UI fix
Reconstructed from the speaker's description.
This input is weird and does not slide correctly. Please fix.In design mode you click the control or draw the region first so the bot knows the target. Same pattern for “move these lanes onto their own page.”
Visual mocks after the loop works
Reconstructed from the speaker's description.
Use image generation to come up with mock screens.
Use Super Auto Pets as a visual reference.
Look up images for how these characters should look.
I want a few images we can use to brainstorm how this will actually
look, because we do not want to play a product that looks like a
Kanban board.Measurement and business impact
No engineering hours, cost, lead, or support-load numbers were given for the studio build. The checkpoint they used was qualitative: can you play the core loop, see the logic (including a 22% advantage actually flipping a round), and tweak constants without waiting for another agent pass? If the prototype is ugly but the mechanics make sense, that is a pass. If you still cannot tell whether it is fun, keep cutting.
On the ops side, Marcel described an extra hour or two a day after Rex took repetitive work — school-message noise, POS questions, menu items that did not sell. Matt’s Slack emoji pack was framed as time not spent uploading files by hand, not as a KPI.
Handoffs that mattered: Grokbot conversation to Cursor implementation; committed docs so a context-poor local agent can recover; Notion updates so future bots inherit the business diagram and product plan.
Pitfalls and guardrails
- You do not control compute. You control tone, skills, and constraints. If a bot is spinning, change the brief, not a hidden throttle that is not there.
- Do not productionize the first pass. Auth, waitlists, and databases were actively removed. Potato mode’s prototyping principle exists so you do not pour design decisions into production code too early.
- Do not skip the restatement. A big blob of text will be misread. Make the bot say it back.
- Do not make the engineer bot a prototype specialist. Lauren’s constraint: durable enough for later serious work.
- Do not run architect swarming when you only need a throwaway. It is slower. Skip it until architecture matters.
- Do not build visuals and the loop in parallel if you need the whole team in one codebase. Get a basic prototype up first.
- Stay in the loop on greenfield work. Agents will ship broken sliders, stats that do not sum, and CSS that turns every card into a rainbow. Design mode and a human playing the build are the guardrails.
- A local Cursor agent may not have the bot’s context. Point it at committed docs and restate, or you will rebuild from a wrong picture of the product.
- Correcting forever is worse than writing a skill. If the thinking block shows a bad habit, encode the fix.
- Brand and game-feel risk is real once you skin too early. They kept a debug UI longer than it was pretty, then applied art. Over-steering a CSS trick made the visual pass worse until they retargeted it.
- Human in the loop for product judgment. Bots can simulate many runs. They cannot tell you the order of a lineup has no strategy, or that a legendary everyone copies will collapse the meta. That was a people conversation after the prototype ran.
7-day implementation plan
This follows the order they actually ran, compressed from a live multi-day build — not a generic sprint.
Day 1
Stand up the roster. Install the Pstack plugin so Grokbot and Cursor both understand potato mode. Create or confirm Dr. Eggbot, a chief of staff that holds the brief, and a durable engineer bot. Commit the product plan and any diagrams to the repo. Point a second agent at that file instead of re-briefing from memory. Write the lander brief with your scaffold preference, UI guidelines, and OG meta. Approve a subtract-before-add plan (no auth, no waitlist unless the loop already needs it).
Days 2–3
Kick the lander to a Cursor cloud agent. In parallel, open Cursor on the product and force a restatement of the core loop. Issue the potato mode prototype prompt: local, no database, several variants, debug sliders. Skip architect. Play the build in Cursor’s browser. Fix only what blocks the loop (wrong totals, dead controls). Do not start login.
Days 4–5
Once the loop is playable, add the playground knobs you still lack so non-engineers can tweak constants live. Then, and only then, generate visual mocks and apply a first skin. Use design mode for layout moves instead of long UI prompts. If an agent reasons badly, write or update a skill before you pile on more tasks. Start the knowledge-base bot: dump the plan, the diagram, and the current objectives into Notion so later bots are not amnesiac.
Days 6–7
Decide what the engineer bot does after prototyping — the durable work, not another throwaway. Direct growth/lander follow-ups only if the core loop survived contact with humans (in their queue: SEO, A/B testing, ads infra, distribution you already have). For ops, pick one repetitive system — POS-style reporting, a menu or catalog photo, an inbox, or an internal pack of assets — and give a named chief-of-staff bot access with a tight job. Keep a human on customer-facing and balance decisions.
Get one loop on screen before you build the company around it
The outcome is not a pile of bots. It is a playable core, a lander that is allowed to be simple, and a roster that can keep working after the prototype. Share the plan in git, make the engineer durable, cut auth until the loop is fun, and stay close until the agents earn more leash.
Watch the walkthrough for potato mode, the architect skip, and Cursor design mode on a live prototype.
FAQ
Grokbot vs Cursor: do I need both?
The team used both on purpose. Grokbot is the lightweight harness for conversation, specialist bots, and knowledge work. Cursor is the coding harness that writes and runs the engineering, including cloud agents and a built-in browser. They work well together. If you only chat, you will under-serve the codebase. If you only code, you will re-explain context that a chief of staff and committed docs could have held.
What is potato mode, and do I need Pstack?
Potato mode is a router skill in Pstack: few hard-coded instructions, then other skills and principles depending on the scenario. In Grokbot you can slash-command it or just say “use potato mode” if the plugin is available. You do not need it to run a knowledge bot in Notion. You do need it if you want the prototyping path they used — throwaway HTML, experience-first cuts, and an optional architect swarm you can skip.
Do I need a database and login for the first prototype?
No. Lauren’s prototype instructions were skip sign-in, keep everything local, no DB, hardcode if you must, and put sliders on the constants. Matt’s lander plan also had auth and a waitlist removed. Add those when you know the loop is worth it.
When should I inspect agent output vs let it cook?
On a new project, inspect. Read restatements, designs, and the first UI, and correct direction early. On a mature codebase that is already agent-friendly, Lauren spends more time on architecture and less time micromanaging. If you are zero to one, you are in the weeds on purpose.
Should the engineer bot only do prototypes?
No. Lauren told Dr. Eggbot not to make a prototype-only engineer. First phase is lightweight prototypes. The same bot should be durable enough for later serious engineering, including orchestrating cloud agents and checking their work.
How do I share context across bots?
Commit plans and docs to the repo and point agents at those files. Lauren’s MVP document became Matt’s lander brief that way. A chief of staff can hold credentials and the product story and talk to Dr. Eggbot for you. A knowledge bot can mirror the plan and diagrams into Notion for future bots. A local Cursor agent that lacks Grokbot context should be forced to restate from the docs before it builds.
Do I need the architect skill for a prototype?
Not for the first throwaway. Architect runs several models, compares plans, and merges ideas. That is useful when constraints are real. Lauren skipped it because it is slower and she did not care about architecture yet. She picked one model (Grok) and ran locally.
Does this only work for a game studio?
The worked example is a game studio, but the same harness showed up in cafe operations: a named chief of staff bot on POS reports, a menu photo, and a noisy inbox. The transferable pieces are the roster, repo context, potato-mode cuts, and a human still judging the loop.