Wink Pings

An Agent Factory Shipping 4,000 PRs a Month, Bottlenecked at the Approval Line

In a 1-hour course, Lauren Tan takes GrokBot from a chatbot to an agent team: assign roles, connect logins, build a minimal self-check loop, write codebase guardrails, and finally let agents merge their own PRs. The course video and 10-step tutorial are both in the article.

Four thousand PRs a month, bug fixes at 3 a.m., and agents merging their own PRs. Lauren Tan’s 1-hour masterclass covers the GrokBot agent team and autonomous loops; Hux’s recommendation leads with the results.

First, some context on what GrokBot is. It’s a desktop app; each bot has a cloud computer, can log in to tools you already use, click like a human, and keep running after you close your laptop. That’s the difference from a chat window: what you’re handing over is tasks and permissions—chat is only the surface.

The course breaks the path into several layers. First, give the bot real work: accounts, budgets, and tasks belong to it—don’t keep it as a Q&A bot forever. Only by going from one bot to a loop and then to a factory can volume reach thousands of PRs a month. The smallest and most critical loop is letting the agent run code, check results, and verify its own work. Writing codebase guardrails into the architecture and CI saves more tokens and is more reliable than repeatedly reminding it in prompts. Later, agents can merge their own PRs, and humans only review the output, not the diff.

Codez’s tutorial breaks the process into 10 steps, and a few details are worth noting:

  • Start by giving the bot a role name, such as Inbox Manager or Expense Manager. A role brings persistent memory, domain boundaries, and an accountable thread. In the charter, spell out what it owns, what “good” looks like, and what it must ask about.
  • Tool connections are account-level: connect Gmail and GitHub once, and all later bots share them. The upside is that the fifth bot can start working within seconds; the risk is that the blast radius of one connection covers every bot.
  • Logins use a handoff: when the bot hits a login wall in the cloud browser, it hands the screen to a human; after the human authenticates, the bot continues from the same session. Passwords never enter the chat box.
  • Demonstrating once is more effective than explaining ten times. Record a weekly process that spans at least two tools and has stable steps, save it as a routine, then use a schedule or trigger to let it run on its own.
  • Split multiple bots by domain, not by task size. An Expense Manager that only handles receipts will be more useful than a generalist that handles everything—and easier to debug.
  • Put the bot in a group chat and give it goals, not task lists. A task list means the human has already done the decomposition.
  • Draw the approval line by reversibility: drafting, archiving, tagging, summarizing, researching, preparing, and reconciling—let it complete these on its own and log them; sending externally, spending money, publishing, deleting, and accepting terms—stop and wait for a human. The Sales Outbound example: 36 drafts queued, 0 sent.
  • Set aside 15 minutes a week for review. Ask whether it ran, whether the output was correct, and whether you’d miss it if you deleted it. Have the bot report on itself, then manually spot-check one item. Automation rots silently.

One question in the comments is worth keeping: if the check runs inside the same agent that writes the PR, who catches the case where the check passes but the change is still wrong? The minimal self-check loop and codebase guardrails from the course can block some of it, but the question still points to a weak spot in a multi-agent factory. Writing guardrails into CI is one direction; the independence of the checker is another.

Course sources:

Manage agents like employees: roles, permissions, approval lines, and weekly reviews are all management actions. Saving tokens is a byproduct of guardrails.

发布时间: 2026-11-19 01:31