fakenerd.ai

next level nerdingYour bot is the manager, not the coder

Your bot is the manager, not the coder

Rob Shocks runs his software from one chat bot. The bot works out what to build and checks what comes back; the writing of code goes to Claude Code, Codex or Cursor, each on its own computer. He walks through Lauren Tan's daily loop, the checks that let anything merge without you, his own setup, and how to keep bots that share a computer from sharing your keys.

Jump to the map, the trust stack, or start with one rule. Lauren's skills have their own page: pstack.

The video

16 minutes, posted Oct 31, 2026, on Rob Shocks' channel (Switch Dimension). Chapter names are his. The times are where each one starts on screen; a few in the description run late. Every timestamp on this page opens the video at that moment.

  1. 0:00 Intro
  2. 1:35 Your bot is the manager, not the coder
  3. 5:06 How Lauren runs her kitchen
  4. 7:12 The trust stack
  5. 9:24 Demo: one chat, many bots
  6. 11:51 Demo: from backlog to pull request
  7. 13:17 Lock the doors
  8. 14:29 Your first factory rule

He lays the video out as his own backlog: seven cards, from “Manager” to “First rule”, shipped one by one. The sponsor read (4:08 to 5:06) is left out here.

Fourteen signals

The whole video in fourteen boxes. Each links to the part of this page that explains it.

  1. 011:35

    The bot manages, the agents code

    A chat bot is good at deciding what to build and checking what came back. Writing the code is the job of a coding agent like Claude Code, Codex or Cursor.

    More
  2. 021:38

    First mile, last mile

    The first mile is working out what to build from everything your bot can see. The last mile is chasing the work, checking the proof and telling you what's done.

    More
  3. 032:23

    Not tied to one bot

    Rob uses Grok Bot, but says your own agents, Claude Projects or Cursor Projects work the same way. The pattern is the point.

    More
  4. 043:36

    Split the jobs, split the bill

    Coding inside the bot burns its shared usage pool fast. Rob hands the coding to his Claude Code subscription and Cursor cloud agents instead.

    More
  5. 053:54

    Every worker gets its own computer

    Each coding agent runs on its own machine with its own context and its own off switch, so one bad run can't wreck the others.

    More
  6. 065:08

    A loop that runs every day

    Lauren Tan's five steps: watch a Slack channel, file a ticket, an agent reproduces the bug, fixes it and fuzzes it, then pings her and merges an hour later.

    More
  7. 076:15

    Not every bug gets the loop

    Sort each change by blast radius. Green merges itself, yellow gets an AI review, red needs a person. Payments are always red.

    More
  8. 086:36

    Head chef, not factory owner

    Lauren prefers a Michelin kitchen to a factory. You don't cook every dish any more, but your name is still on every plate.

    More
  9. 097:08

    Trust before more agents

    How can you manage 50 agents if you can't trust one? The teams that ship this way started with checks, not with more bots.

    More
  10. 107:32

    Move the fix up the stack

    Every time you correct an agent, fix it higher up: in the code first, then a lint rule, then a rules file. Reading the code yourself comes last.

    More
  11. 119:25

    One chat, narrow bots

    Rob talks to one main bot, Chief. Behind it sit narrow bots, each with its own small set of permissions. He tries hard not to build 50.

    More
  12. 1211:51

    Score the backlog

    His bot saves every idea to a Notion backlog, then a routine ranks it by RICE (reach, impact, confidence, effort) and marks how much could break.

    More
  13. 1313:17

    All your bots share one computer

    Log in a coding tool with an API key on the bot's computer and every bot you have can use that key. Keep the rules in the environment, not in the bot.

    More
  14. 1414:29

    Start with one rule

    Don't build 50 agents. Paste one rule into your bot: hand coding to an agent with a test, check the proof, open a pull request, report back.

    More

Words on this page

32 terms, in plain words. Skip this if you already run coding agents from Slack.

Manager bot (orchestrator)
The one assistant you talk to. It plans, hands work to other agents, checks what comes back and tells you. It doesn't write the code itself.
Coding agent
An AI that edits code and runs commands in a project: Claude Code, Codex, Cursor. On this page it's the worker.
Cloud agent
A coding agent that runs on a computer in the cloud instead of your laptop, so it keeps going when your lid is shut.
Headless
Running an agent with one instruction and no chat window. It does the job and stops. This is how a bot starts Claude Code on your Mac.
First mile
Working out what to build at all: reading Slack, email, tickets and complaints, and turning them into a short list.
Last mile
Following the work through: chasing it, checking the proof, opening the pull request and reporting back to you.
Intent
What you and your team actually want built. Rob's point: a big part of any software factory is collecting and managing it.
Routine
A job your bot runs on a schedule (every morning) or when something happens (a new Slack message). Grok Bot's word; others call it an automation.
Backlog
The list of everything that could be built or fixed next, usually in Notion, Linear or Jira.
Ticket
One item in a tracker like Linear or Jira: a bug or a feature, with a title, a description and a status.
Pull request (PR)
A proposed change to the code, waiting to be checked and accepted. Opening one is safe; merging it changes the real thing.
Merge / auto-merge
Accepting a pull request into the main code. Auto-merge means it happens on a rule, with nobody pressing the button.
Acceptance test
A check that proves the job is done, written before the work starts. "The total can't go below zero" is one.
Proof
What the agent hands back to show the work is right: passing tests, screenshots, a short video of it working.
Reproduce (repro)
Making a reported bug happen again on purpose. If you can't make it happen, you can't prove you fixed it.
Fuzz
Throwing odd and random input at something to see what breaks: tapping minus ten times, pasting emoji, double-clicking Pay.
Swarm
Several agents working on the same thing at once. In Lauren's loop, a small swarm tries to break each fix.
Playwright
A free tool that drives a real browser from code: it clicks, types and checks the page like a person would.
Blast radius
How much could break if this change is wrong. A typo fix is small. Anything touching payments or logins is big.
RICE
A way to rank work: Reach (how many people) times Impact times Confidence, divided by Effort. Small jobs that help many people rise.
Static analysis
Checks that read your code without running it: lint rules, type checks. Cheap, fast and the same every time.
Lint rule
An automatic check for one specific mistake, like leftover console.log lines. It fails the build so nobody has to spot it.
CI (continuous integration)
A service that runs your tests and checks on every pull request, before anything is merged.
Rules file
A plain text file of instructions an agent reads before it works: AGENTS.md, CLAUDE.md. The video calls this layer prose.
Skill
A saved, named set of instructions an agent can load for one kind of job, like reviewing code or writing a test.
Revert
Undoing a change after it was merged, usually because it broke something.
Vault
Where a bot keeps your passwords and keys so it can log in for you. Rob can't see inside Grok Bot's, and that bothers him.
Scoped credentials
Keys that only open what one job needs, and read-only where possible. A key that can read logs but can't delete anything.
Sandbox
A walled-off computer or container where an agent can work without reaching the rest of your machine or accounts.
VPS
A rented always-on computer in a data centre. Rob's bot can start agents there as well as on his Mac.
Container
A sealed box on your computer with its own files and tools, so an agent inside can't touch the rest.
MCP
Model Context Protocol: a standard plug that lets one AI app call tools in another. Theo drives his machines through one.

What it is, and what it does

Not a product. A split of jobs: one assistant you talk to manages, other agents do the coding. Rob runs it with Grok Bot; his slide says it isn't tied to Grok Bot. 1:35

  1. 1 · Manager botFirst mileReads every channel, works out what to build next, writes the job up and picks a worker.
  2. 2 · Coding agentsThe diffClaude Code, Codex or Cursor writes the code on its own computer and brings back proof.
  3. 3 · Manager botLast mileChecks the proof, opens the pull request, chases what's stuck and tells you what's done.

Lauren Tan, who works on Grok Bot, puts the middle step in her own words: since each cloud agent has its own computer, “it frees up your bot to be more of a manager rather than write the code itself.” Her post. In another, her last mile also covers handing the build to the coding agents; Rob draws the build as its own middle step.

Why split the jobs · his three reasons

  • Cost

    3:36

    Grok Bot draws on one weekly usage pool shared with Grok and Cursor. Coding inside it burns that fast, so Rob sends the coding to the subscriptions he already pays for.

  • Isolation

    3:54

    Every worker gets its own computer, its own context and its own kill switch. One stuck agent doesn't stall the rest.

  • Attention

    2:55

    A bot that isn't busy coding can watch the channels, answer the workers' questions and keep the list. Lauren: it frees the bot "to be more of a manager."

The shared pool is Cursor's: “Agent in the editor, CLI, Cloud Agents, Grok Bot, and the Grok apps” all draw from one weekly pool (Cursor pricing, read Oct 31).

Factory or kitchen? · Lauren's framing, Rob's slide6:36

  • FactoryVolume. Machines on a line. On Rob's slide: nobody's name on it.
  • KitchenA brigade. You are head chef, agents are the cooks. You don't cook every dish, but every plate goes out under your name.

Lauren isn't a fan of “software factory”. As developers, she says, we're still responsible for the final outcome. Rob asks his viewers which framing they buy.

Three basic and three advanced, in real life · FakeNerd's, the last three from the video

  • basic

    A bug from the contact form

    A customer emails that the menu won't open on their phone. Your bot reads the email, files it, starts one coding agent with a test ("menu opens at 375px wide"), and messages you a pull request with a screenshot.

  • basic

    The Friday tidy-up

    Every Friday the bot looks for small jobs on your list that touch nothing risky (copy fixes, broken links, image sizes) and hands each to an agent. You come back to a few small pull requests to read.

  • basic

    Ask from your phone

    On the train you message the bot: "add our new address to the footer." It hands the job to Claude Code on your Mac at home and replies with the preview link.

  • advanced

    Lauren's daily loop

    Feedback lands in a Slack channel. The bot files a Linear ticket, a cloud agent reproduces it and fixes it, a small swarm fuzzes the fix, and it merges an hour after pinging her unless she says stop.

  • advanced

    Rob's ranked backlog

    Everything his main bot hears goes into Notion. A routine scores each item by RICE and blast radius, sets how it gets reviewed, and the top ones go to Cursor cloud agents.

  • advanced

    Theo's fleet from a phone

    Theo's T3 Code exposes all his machines through one MCP server. From Grok Bot on his phone he started eight coding threads on different machines with his laptop off.

Everything named

What he names or shows, grouped by job. Swap any one for another in the same group and the pattern still works. Grok Bot is listed last of the managers because it's one option, not the idea.

Manager bots · the one you talk to

  • Anything you build

    Your own agent

    Rob's first alternative: a long-running agent of your own with tools to start other agents. More setup, but you can see its memory and skills.

    2:23

  • Anthropic

    Claude Projects

    Named on his "not tied to Grok Bot" slide. A workspace in Claude that keeps your files and instructions for one area of work.

    2:23 Site

  • Cursor

    Cursor Projects

    Also on the slide. Lauren: a way to group many related cloud agents into one conversation.

    2:23 Site

  • Theo

    T3 Code

    A desktop app for running many coding agents. Its new MCP server lets another bot start threads on any of your machines. Nightly build, early.

    11:39 On FakeNerd

  • x.ai

    Grok Bot

    Rob's choice. Connects to Slack, email, X, Notion and more, runs routines, can start Cursor cloud agents, and works from phone, Mac and PC. Bots share one cloud computer. Comes with paid Cursor plans from Premium up.

    0:35 Site

Coding agents · where the diff happens

  • Anthropic

    Claude Code

    Rob runs it headless on his Mac, always with the model he picked written into the instructions. His subscription pays for the coding.

    11:04 Site

  • Cursor

    Cursor cloud agents

    Agents on Cursor's computers. Rob starts them "with my criteria". Lauren runs her whole loop on them, so they work while her laptop is off.

    10:18 Site

  • OpenAI

    Codex

    Named as one of the three coding agents that do the middle of the work. Not shown in the demo.

    2:39 Site

Channels · where the work comes from

  • Salesforce

    Slack

    Where every big-company factory Rob covered manages its agents. Lauren's loop starts in a #feedback channel. Your bot can live in team threads.

    3:12 Site

  • Trackers

    Linear, Jira, Notion

    Where tickets and the backlog live. Lauren files to Linear; Rob's bot saves everything to a Notion backlog.

    5:25

  • On his "every channel" slide

    Email, X, GitHub, Sentry, Vercel

    More places intent comes from: requests, complaints, failed builds, error reports, deploys. The bot watches them so you don't.

    1:54

Checks · how you trust the result

  • Any project

    Lint, tests, CI

    Layer two of the trust stack. Cheap, the same every time, and they catch a repeat mistake without anyone reading.

    7:54

  • Microsoft, free

    Playwright

    Drives a real browser. The fuzz agents use it to click around like users and try to break the fix.

    5:54 Site

  • Rules files

    AGENTS.md, CLAUDE.md, skills, review bots

    Layer three: written guidance the agent has to choose to follow. He names Bugbot and a security bot here, and his Cloudflare security skill video.

    8:21

  • Lauren Tan, MIT

    pstack

    Her skills for rigorous engineering and verification. The "triage and reproduce" and "fix and fuzz" steps of her loop run on it.

    5:36 On FakeNerd

Where the workers run

  • Rob's setup

    Containers on a Mac

    Local, walled-off environments the bot can start agents in, each with its own permissions and rules.

    4:01

  • Rob's setup

    A VPS

    An always-on rented server. He set it up by telling the bot: connect to my VPS, and here's how I'd like it to run.

    10:20

  • Tailscale

    Tailscale

    Rob's suggestion if you want your own phone, Mac and PC to reach each other without Grok Bot in the middle.

    11:03 Site

Left out

The sponsor (Neon Realtime, 4:08 to 5:06), his course plug, and the closing tribute to Patrick Stewart. Bugbot and a security bot are named only in passing, inside the rules layer.

The map: from a message to a merge

Seven stations, from a message in a channel to a merged change. Pick a blast radius to see who holds the gate, click a station for detail, or press Start to follow one bug through Lauren's daily loop. 5:08

Pick a blast radius

Green: If the proof is clean, it merges on a rule. Lauren's version waits an hour after pinging her. Stations that need you: 0 of 7. 6:15

One change, seven stations · shaded boxes are yours at this blast radius

First milethe manager bot
The diffcoding agents, on their own computers
Last milethe manager bot, then the gate

Follow one bug through Lauren's loop

Eight beats, from a message in Slack at 9:12 to a merge at 10:55. Watch which station lights up, and count the beats where you do anything.

Station 3 of 7 · First mile

Watch at 10:18

Hand off

The bot writes the job up with a test that proves it's done, then starts a coding agent on its own computer with the model you chose.

  • Greenmanager botPicks the worker (cloud agent, Mac, VPS) and the model, and sends the brief with an acceptance test.
  • Yellowmanager botPicks the worker (cloud agent, Mac, VPS) and the model, and sends the brief with an acceptance test.
  • Redmanager botPicks the worker (cloud agent, Mac, VPS) and the model, and sends the brief with an acceptance test.

Lauren's loop

"create a Cursor cloud agent to triage and reproduce the issue on its own computer, using pstack."

Rob's setup

Chief starts either a Cursor cloud agent or Claude Code on his Mac, headless, always with the default model he specified. The bot saved those instructions as a skill.

Watch out

No acceptance test, no way to check the proof. The bot can only verify what the brief said done looks like.

The five steps of the loop are Lauren's, word for word in each station. Rob adds the triage colour and the review levels. Splitting them into seven stations and the example bug are ours. Anthropic uses low, medium and high, not colours: low merges once automated review and security checks are green, medium needs one person, high needs two. Their post.

The trust stack

“How can you manage 50 agents if you can't even trust one?” The teams that ship this way built trust first. Lauren's answer is an inverse pyramid: most effort at the top, least at the bottom. 7:08

One mistake, fixed at each layer · an agent keeps leaving console.log in the code

  1. 1Codebasearchitecture · types · boundaries7:39 What it isChange the code so the mistake can't happen. "Agents love to copy what exists and take the shortest path, so make the easy thing the right thing."The fix hereAdd one small logger the whole app uses, and remove the stray console.log lines so there's nothing left to copy.
  2. 2Static analysislint · tests · CI7:54 What it isChecks that run on every change, cheap and the same every time. If the agent makes the same mistake twice, it becomes a lint rule.The fix hereTurn on the no-console lint rule and fail CI if it trips. Now nobody has to spot it.
  3. 3Proserules · AGENTS.md · skills8:21 What it isAnything written down that the agent has to choose to follow: rules files, skills, review bots. Use it, but less than the two above.The fix hereOne line in AGENTS.md: "Use lib/log, never console.log." It helps, but the agent can still skip it.
  4. 4Human reviewyou, reading code8:35 What it isThe one we lean on hardest and the one that doesn't scale. Effort here should be the smallest.BeforeBefore: you comment "remove the console.log" on PR #231, #238 and #244. Three times, by hand.

The four layers and the quote are from Lauren's Oct 16 post; the console.log example is on Rob's slide; the fix at each layer is ours. Her full prompt for reworking a codebase this way is on the pstack page.

The habit · move the fix up the stack14:51

  1. Code first
  2. Then a lint rule
  3. Then a rules file
  4. Review comes last

If you tidy up after the agent on the same thing every time, Rob says, you're doing something wrong. Program it in so it can't happen again. 8:05

Proof it works · Anthropic's Claude Code team, June to September 20268:42

  • 2×+Merged pull requestsTo Claude Code's codebase, June to September 2026.
  • −40%+Share revertedThe share of merged changes that had to be undone fell by more than 40 percent.
  • 3Risk tiersLow merges once automated and security checks are green. Medium needs one person, high needs two.
“We didn't remove review. But we did move most of the reading to machines, optimized for human time and attention.” Addy Osmani, Morgan Westlee Lunt and Qing Wang, Anthropic, Oct 15, 2026.

What it costs to get there · Alan Wells, team of three9:11

To ship pull requests without human code review, his team “had to stop all new product development for ~6 weeks and just focus on getting the validation systems working.” Painful at the time, he says, and worth it. A week later that factory carried them through a live attack on one of their products. His post.

One chat, many bots

Rob has a bot for each area of his company, but talks to one. He works hard not to build 50, because managing them becomes its own job. 9:25

His bots, read from the slide

Chiefmain agent · the one he talks to

+ a group chat where bots talk to each other

  • SD Marketing Site
  • Molten OS
  • News
  • Memory
  • Personal
  • Accelerator
  • Social
  • Sponsors
  • Video Production
  • SD Finance
  • Pers Finance
  • Sales

Each narrow bot has its own small set of connections, so he can share one with someone else without sharing everything.

What he can't see9:51

  • MemoriesWhat the bot has decided to remember about him and his work.
  • SkillsThe saved instructions, like how to start Claude Code with his model. It works, but he can't find the file.
  • VaultWhere his logins and keys are kept and how they're used. On his slide: "not sure".

Grok Bot hides this to keep things simple. To keep trusting it, he wants to see more. If that bothers you, build your own manager agent; you keep the files.

One project, start to finish · his marketing site

  1. 110:26

    Connect by asking

    He set up the VPS by telling Chief: "connect to my VPS, and here's how I'd like it to run."

  2. 210:32

    State the worker and model

    Run it on Cursor cloud agents with his criteria, or Claude Code headless on his Mac. He always names the default model. The bot saves this as a skill.

  3. 311:04

    Rules live in each folder

    Every project folder or environment has its own permissions and security rules, whichever agent runs there.

  4. 411:23

    The bot unblocks the workers

    When a sub-agent stops with a question, the bot answers from Slack and the docs it's connected to. His channel's visuals run the same way, on Opus 5.5.

He has it on his phone, his Mac and a PC, all working together; Tailscale can do the same for your own machines. Theo does it from the other side: T3 Code's new MCP server lets Grok Bot start eight threads on different machines, and with his laptop off he still drives them from his phone. Rob says Theo isn't affiliated with Grok Bot.

From backlog to pull request

Everything Chief picks up goes into a Notion backlog. A second routine ranks it, and every item gets a blast radius that sets how it's reviewed. 11:51

RICE, as on his slide12:02

R × I × C ÷ E

  • R · ReachHow many people it helps
  • I · ImpactHow much it helps each one
  • C · ConfidenceHow sure you are about R and I
  • E · EffortHow big the job is

A small job that helps a lot of people rises above a minor fix. Ask the bot to be proactive and it will suggest new work too, but don't let it fill the backlog just because it can. 12:25

His board, read from the screen · the review each item gets12:59

  • Store UTM and short-link source on waitlist signupsHuman
  • Track checkout and scroll eventsAI Level 1
  • Launch-day Buy switch for Agent SprintAI Level 2
  • Fix mobile hero readabilityAI Level 2
  • Add an Instructors section driven by dataHuman
  • Add Course, Organization and FAQ structured dataAI Level 1
  • Move the Glitch Dimension game below the final CTAAI Level 1
  • Inline newsletter signup on blog postsAI Level 2

The agent sets the blast radius and the review level, and the levels differ in how much Playwright and security testing they run. He says “AI level one, two or three”; only one and two are on the board, and he doesn't say what each one runs.

Why the first item is “Human” · Chief's report on PR #4110:40

The change stores which campaign a visitor came from with every signup. Before merging, Chief lists two jobs for Rob: add the new fields in his email tool, and update the privacy policy, which doesn't yet say a campaign source is stored with the email address. Code an agent can write; that second call is a person's.

Lauren does it bigger · and a warning12:35

She uses routines “to farm context for me: bug reports on Slack, user complaints on X, generating new feature ideas,” which feed her outer loop, where she decides what to point her factory at next (her post). Rob's warning: on an hourly schedule that burns a lot of tokens, and most of us don't have her budget.

Lock the doors

All your Grok Bots share one cloud computer: files, browser sessions and command-line logins. Log a coding tool in with an API key on it and every bot you have can use that key. 13:21

Shared by every bot on one account · from Grok Bot's docs

  • Browser cookies and signed-in sessions are shared
  • Files are visible to every Bot
  • Command-line credentials are shared
  • One Bot can continue from work another Bot saved

The docs say it straight: “The screens are separate work surfaces, not separate security boundaries.” Logins can go in its Vault or through 1Password, so the bot fills a password without seeing it. Computer and apps.

Controls live in the environment · Docker's reference, as Rob draws it13:52

Identity and access
Supply chain
Network
Sandbox

Agent

The central idea of the paper: “the more autonomy you give an agent, the less you can rely on it to police itself.” Written by people from Keycard, Socket, Docker, Tessl, Tracebit, Browserbase and Tailscale. Docker's post.

His three rules · until you trust the stack14:11

  1. 01

    Run agents in a sandbox

    A container, a VPS or a cloud agent, never loose on your own laptop with everything logged in.

  2. 02

    Scoped credentials, read-only where you can

    A key per job that opens only what that job needs. Read logs, yes. Delete the database, no.

  3. 03

    Open pull requests, don't merge

    Let agents propose. A person or a trusted check accepts. Until you trust the stack.

A manager bot won't make these choices for you. Make them for each codebase, by how much it matters if it breaks. 14:22

Try it, smallest version first

Rob's advice: don't go building 50 agents. Start with one loop. Steps 1 to 4 need nothing beyond the coding agent you already pay for. 14:29

  1. 01

    Pick your manager

    Whatever chat assistant you already use that can start other agents or run commands: Claude Projects, Cursor, Grok Bot, or a Cloudroom or bb (getbb.app) thread. For a first try it can even be a second terminal window.

  2. 02

    Paste the first rule

    Rob's one rule, word for word, goes into the manager's instructions. It stops the manager from writing code and makes it hand off, check and report instead.

    The first rule
  3. 03

    Give it one worker

    Claude Code or Codex, run headless in your project folder. Try it by hand once so you know what the manager will be doing. The worker works on a new branch and opens a pull request; it never merges.

    Give it one worker

    # Claude Code, one job, no chat window
    claude -p "Fix: the share button does nothing on Safari. Done when a Playwright test opens /share in WebKit, clicks Share and finds the page URL on the clipboard. Work on a new branch, run the tests, open a pull request, and reply with the PR link and the test output."
    
    # Codex, same job
    codex exec "Fix: the share button does nothing on Safari. Done when a Playwright test opens /share in WebKit, clicks Share and finds the page URL on the clipboard. Work on a new branch, run the tests, open a pull request, and reply with the PR link and the test output."
  4. 04

    Run one small, green job

    Pick a fix nobody would lose sleep over. Write the acceptance test as one sentence. Ask your manager to hand it off, check the proof and report back with the pull request. You merge it yourself.

  5. 05

    Every correction moves up

    When you have to fix the same thing twice, don't just comment. Ask the agent to turn it into a lint rule or a code change. This one stops stray console.log lines in a JavaScript project.

    Every correction moves up

    // eslint.config.js: add to the rules of your existing config
    rules: {
      "no-console": "error",
    },
  6. 06

    Lock the doors before you add a bot

    Give the worker its own keys, read-only where possible. Keep payment and admin keys off any computer your bots share.

    The door rules
  7. 07

    Add a channel, then a colour

    After a week of clean pull requests, let the manager watch one channel (a Slack channel or a Linear view) and add the triage starter. Only then let green jobs merge on a rule.

    Triage starter

The first rule, and three more

Rob's rule is his, as said. Lauren's loop is hers, from her post. The last two are FakeNerd starters built on what Rob describes. Fill in the brackets.

Rob's first factory rule · paste into your bot

For anything more than a short question, don't write the code yourself. Hand it to a coding agent with an acceptance test. Check the proof. Open a pull request and report back.

Then, every time I have to correct an agent, move that fix up the stack: code first, then a lint rule, then a rules file. Review comes last.

Spoken at 14:38 . The slide shows only the first two lines, so this is his spoken wording.

Fill-in · the same rule, with your tools

For anything more than a short question, don't write the code yourself.
Hand it to [Claude Code on my Mac / a Cursor cloud agent / Codex] using [MODEL].
Every hand-off includes an acceptance test: one sentence that proves the job is done.
Check the proof that comes back: [tests pass / a Playwright run / a screenshot].
Open a pull request. Never merge it yourself.
Report back in [this chat / #CHANNEL] with: what changed, the proof, and anything I must do before merging.
Every time I correct an agent, propose where that fix belongs: code, a lint rule, or [AGENTS.md / CLAUDE.md].

Lauren Tan's daily loop · her words

1. watch this slack channel for feedback about our app
2. create a ticket for this in Linear
3. create a Cursor cloud agent to triage and reproduce the issue on its own computer, using pstack
4. if the issue clearly reproduces, put up a fix and fuzz the pull request with a small swarm of agents
5. if the fuzz has no issues, ping me on Slack, and rebase and auto-merge the PR after 1 hour unless i request changes

From her Oct 6 post. Steps 3 and 4 use pstack; without it, describe the steps in plain words like the fill-in does.

Fill-in · the loop with a blast-radius gate

1. watch [#CHANNEL] for feedback about [APP]
2. create a ticket for this in [Linear / Jira / Notion / GitHub Issues]
3. start [a coding agent] on its own computer to reproduce the issue. Stop if it doesn't reproduce.
4. if it reproduces, open a pull request with the fix and a test, then have [N] agents try to break it with Playwright
5. if nothing breaks and the change is green, ping me in [#CHANNEL] and merge after [1 hour] unless I say stop. Yellow or red: ping me and wait.

FakeNerd starter · a daily triage routine

Every [weekday at 8am], go through the backlog in [Notion / Linear].

For each open item:
1. Score it by RICE: Reach (how many people), Impact (1-3), Confidence (0-100%), Effort (days). Score = R x I x C / E.
2. Give it a blast radius: green (small, non-critical, easy to undo), yellow (shared code or a bigger feature), red (payments, logins, personal data, anything hard to undo).
3. Set the review: green = auto-merge after checks pass, yellow = AI review, red = I review.

Then send me the top three with their scores and colours, and one line on why each is worth doing now.
Don't add new items unless I ask. Don't start any work until I reply.

FakeNerd starter · the hand-off brief

Hand this to a coding agent. Write the brief in this shape:

Job: [one sentence]
Why: [the ticket or message it came from]
Done when: [the acceptance test, one sentence]
Blast radius: [green / yellow / red]
Don't touch: [payments, auth, anything outside FOLDER]
Proof to bring back: the test output, and a screenshot or Playwright run if it's on screen
Finish by: opening a pull request on a new branch. Never merge.

Next to the others

The software factory pages on this site, and where this one sits among them.

FakeNerd's take

The split is the idea, not the bot

One assistant that plans and checks, workers that code on their own machines. You can build that with Claude Projects and Claude Code today. Grok Bot is one way to get there, made by the people Rob is quoting.

Trust is the real work

The manager bot is the easy part. The six weeks Alan Wells' team spent on checks, and the lint rules you add after every correction, are what let anything merge without you.

Most of us aren't there yet

Jellyfish's October data: fully automated factories opened 0.0% of pull requests even at the 90th-percentile company. Start with one loop and read every pull request for a while.

Watch the doors and the bill

Bots that share a computer share your keys. Routines that run every hour share your budget. Rob says both out loud, and he's right on both.

A fair pushback, from a post Rob links: is this just cloud agents hooked to a few webhooks? Mostly, yes. The plumbing is simple. What isn't is the checks that let you stop reading every change, and Jellyfish's numbers say almost nobody has those yet.

Attribution

  • “Grok Bot + Claude Code, Why is Everyone Switching to This?” by Rob Shocks (Switch Dimension, posted Oct 31, 2026). The manager-not-coder split, the three reasons, the traffic light, his bots, the backlog, RICE with blast radius, the door rules and the first rule are his, in our words. Slide labels, his bot list, the backlog board and its review labels are read from the screen; where captions garbled a name, the screen won.
  • Lauren Tan's loop, first and last mile, manager line, inverse pyramid and routines are from her posts on X and LinkedIn. She works on Grok Bot; Rob notes her job is to promote these tools. The Grok Bot guide credits her with 2,000+ pull requests in a month (x.ai).
  • Disclosures: the video is sponsored by Neon (left out here). Rob sells the Switch Dimension course and community, plugged near the end, and is on a combined Grok and Cursor plan. Theo makes T3 Code; Rob says he isn't affiliated with Grok Bot.
  • Checked on Oct 31, 2026: Anthropic's figures and quote, Docker's central idea, the Grok Bot shared-computer list, Cursor's shared pool, and the posts by Lauren, Theo, Alan Wells and hunvreus. Rob's green, yellow and red are his own framing; Anthropic's tiers are low, medium and high. Not checked: what Rob's AI review levels run, and his own results.
  • The seven-station map, the example bug, the console.log fix at each layer, the basic examples, the try-it steps, the fill-ins, both starters, the sibling list and the takes are FakeNerd's. Not sponsored by anyone on this page.
↑↓ move enter openBrowse every card