4,000 PRs a Month, Fixing Bugs at 3 A.M.: GrokBot Factory's 10 Steps and the Brake Lines
Lauren Tan's free 1-hour course and Codez's 10-step tutorial break down how GrokBot turns a single assistant into an agent team that hands off work — and how to draw the permission boundaries.
Lauren Tan is an engineer at SpaceXAI. She has published a free 1-hour course on how to build GrokBot agents and loops from scratch. Codez marked the timestamps in a tweet and also wrote a 10-step tutorial. The most striking line comes from Lauren: her agents can already merge their own pull requests. According to Codez, most people are still babysitting a single agent, while she is running 4,000 PRs a month and can fix bugs at 3 a.m.
First, some background. Grok Bot is a desktop app that, once opened, feels more like a messaging client. Each bot has its own cloud computer, can log in to the tools you already use, click the way you click, and keep running after you close the lid. Codez's summary: users shift from writing prompts to assigning work. There is a point of contention here: it sounds like hands-off liberation, but in practice it pushes permission design to the forefront. The more a bot can run unattended, the more you need to define up front where it stops.
The course timestamps are also worth keeping: 10% at 3:36, on giving bots real work, including their own logins and budgets; 30% at 22:35, on the workflow behind 4,000 PRs a month; 55% at 29:01, on building a personal software factory; 80% at 40:13, on the minimal loop being teaching an agent to check its own work; 100% at 47:33, on codebase guardrails that save tokens. Codez's article breaks implementation into 10 steps. Below is a condensed version organized by key stage.
1. Install First, Then Meet Chief
Download the macOS version, sign in with a Grok or Cursor account. On the left is a row of named bots, on the right the conversation. Codez suggests starting with a general-purpose bot called Chief. Its job is not to do everything, but to catch tasks when you haven't yet figured out who should handle them, and then coordinate the other bots. For the first task, don't give it a test question — give it a real, small task you can verify in thirty seconds, and build verifiable trust first.
2. Give It a Job Title, Not a One-Off Prompt
Codez sees this step as the dividing line. A prompt is a one-time request; a bot is a role: it persists, accumulates memory, and owns a domain. The name should read like a real position — Inbox Manager, Expense Manager, Talent Scout, Sales Outbound. Then write a charter, like briefing a new hire: what it owns, what counts as done well, and when it must check with you first. That last item determines whether you can step away from the screen. An Inbox Manager can archive newsletters and receipts daily, draft replies to customer emails but never send them; it must not archive emails from accountants and landlords; and when a message involves money or credentials, it stops and asks.
3. Connect Tools Only Once
Grok Bot has a plugins panel listing Notion, Slack, Google Drive, AWS Agents, AWS SageMaker, Browserbase, Composio, Context7, plus custom options. Connections are shared at the account level: connect Gmail or GitHub for one bot and every bot you create later can use it. The upside is that your fifth bot can start working in seconds; the cost is that the blast radius of a connection covers every bot you will ever have. Codez advises connecting only the accounts you truly need during the beta.
4. Hand Off Logins, Don't Paste Passwords
In real companies, plenty of tools have no API and no MCP server. Grok Bot's approach is to let the bot navigate its own cloud browser and hand the screen over to you when it hits a login wall. You complete authentication, click done, and the bot continues in the same browser instance. This detail changes the trust model: the bot gets a session, not a password, and you only step in at sensitive moments. If a tool asks you to paste a password into a chat box, that is the wrong path.
5. Demonstrate Once, Don't Explain Twice
Some tasks are exhausting to describe but take forty seconds to do. Grok Bot lets you perform a task once in front of it; it saves the routine and runs it itself next time. Codez suggests the first thing you record should meet three conditions: it happens at least weekly, involves more than two tools, and its steps rarely change. Pulling numbers from a dashboard, comparing the drop, pasting it into a doc, and Slack-ing the team lead if it is over 15% — that kind of work is the best candidate to be lifted away.
6. Add a Trigger With One Sentence
After saving a routine, you still need to give it a firing condition. Codez writes that setting a schedule or trigger can be done in the conversation in about two minutes. Schedule-based: a 7 a.m. daily briefing, a Friday pipeline summary, month-end expense archiving. Trigger-based: a new Slack message, an incoming email matching a pattern, a document change. The original piece has a very product-like move: after a task runs and you like it, just add "run this every week." That is how processes grow.
7. Hire Specialists, Not One Do-It-All Handyman
Multiple bots can run in parallel, each with its own memory, context, and boundaries of responsibility. An Expense Manager that only watches receipts will understand your receipts better than a generalist bot juggling reimbursements, recruiting, and outbound at once — and when something goes wrong, you have a clean thread to inspect. SpaceXAI's own team uses bots for sales outbound, marketing, office operations, and bug fixing. Codez's advice: split by domain, not by task size.
8. Pull Them Into a Group Chat
Bots can message each other and share context in threads. Put several bots in a group chat and they can hand off work among themselves, assign ownership, and pull you in only when judgment is needed. Codez's engineering example: one bot reproduces the bug, opens a ticket, then hands it to another bot to debug. The key is to give the group chat a goal, not a task list. A task list means you have already done the decomposition; a goal lets them divide the work themselves.
9. Draw the Approval Line by Reversibility
Grok Bot's premise is that the bot completes work end to end and only comes back when approval is needed. So what counts as needing approval? Codez draws the line at reversibility. Drafting, archiving, tagging, summarizing, researching, preparing, reconciling — these are reversible, so let the bot finish them and log what it did. Sending to people outside, spending or moving money, committing to prices, publishing publicly, deleting things that are not obviously junk, accepting terms — these stop and wait for you. The sales outbound example: 36 drafts queued, 0 sent. The bot completes every reversible action and stops at the irreversible one.
10. Review Weekly, Prune Ruthlessly
Automation rots quietly. A website gets redesigned, a routine starts producing garbage, and because the bot runs while you sleep, nobody notices for three weeks. Codez suggests setting aside fifteen minutes a week to ask of each routine: Did it run? Is the output right? Would I miss it if I deleted it? The third question is the most easily overlooked — over time a tool accumulates a pile of half-useful automations nobody dares delete. For the review, you can have the bot report on itself, then manually spot-check one output. A bot auditing itself has the same blind spots you do.
The conclusion is not complicated. Codez's original judgment: AI products used to put the model in a window and leave the work in your hands; Grok Bot hands the computer, logins, memory, and time to the bot and leaves decision-making to the human. The skill shifts from "how do I phrase this sentence" to "what exactly am I delegating, and where does its authority end." This looks more like a management problem than a prompting problem. To dig into the original material, read Codez's 10-step tutorial, or go to the video from Lauren Tan's course tweet.
发布时间: 2026-11-16 13:29