Grok Bot Takes the Tasks, Claude Code Writes the Code: How AI Programming Is Dividing the Work

Let orchestration bots manage and programming agents execute, replacing human code-reading with layered trust.
The article synthesizes practices from a Bilibili creator, Grokbot/Cursor chief engineer Lauren, and T3 Code creator Theo, arguing that the efficiency gap among AI programming tools comes from division of labor, not model strength: orchestration bots handle requirements and verification while Claude Code, Codex, and Cursor handle coding. It details Lauren's five-step auto-merge loop, the Tao Pyramid trust model, and security practices like sandboxes and limited-permission credentials.
More and more developers are starting to use multiple AI programming tools at once, but what truly creates the efficiency gap isn't model strength—it's how the work is divided. A Bilibili creator who has long practiced the "software factory" approach, along with P-Stack project creator and Grokbot/Cursor chief engineer Lauren, and T3 Code creator and YouTube programming blogger Theo, all arrived at a highly similar answer at almost the same time: let orchestration bots be the managers, and let programming agents be the executors.

Orchestrator and Executor: Two Roles Are Separating
The core of this workflow can be summed up in one sentence—the bot should be the manager, not the programmer. Orchestration tools like Grokbot excel at the two ends of the process. At one end is the "first axiom"—figuring out what actually needs to be built, consolidating requirements from multiple channels like Slack, email, X, and Linear, and automatically tracking the progress and full discussion of each lead. At the other end is final verification—checking the work, following up on the task list, and telling you what's been completed.
The coding work in between is handed off to dedicated programming agents like Claude Code, Codex, and Cursor. They have their own runtime environments, independent contexts, and can be terminated separately. This frees up the main bot to focus on orchestration rather than writing code itself. According to public demonstrations by Lauren and Theo, the workflows the two of them figured out largely overlap with this creator's own practice—a consensus reached through cross-validation from multiple sources.
Worth noting: these tools aren't unique. If you don't use Grokbot, you can also build your own agent, or use Claude Projects or Cursor Projects to achieve similar orchestration. The method itself can be migrated into anyone's workflow.
The technical divergence between orchestration tools and programming agents
The essential difference between orchestration tools (like Grokbot) and programming agents (like Claude Code, Codex, Cursor) lies in their runtime form and responsibility boundaries. Programming agents typically run as independent processes or cloud sandboxes, with their own file systems, terminals, and context windows. They can directly read and write codebases, execute commands, and submit PRs, with their lifecycle centered on a single coding task. Orchestration tools are more like a persistent coordination layer: they don't directly operate on code, but maintain task state, aggregate information from multiple sources (Slack, Linear, email), dispatch work among multiple agents, and track results. This separation lets orchestrators stay online long-term and maintain memory across tasks, while executors can be launched on demand and discarded after use. The two communicate via APIs or message channels without blocking each other.
The Five-Step Loop: From Feedback to Auto-Merge
Lauren's daily workflow is broken into five steps. First, the team collects app feedback in a dedicated Slack channel, and Grokbot captures the information and creates tickets in Linear. Second, a Cursor cloud agent is triggered through Linear, Jira, or similar tools. Third, the agent reproduces the issue on its own machine. Fourth, it submits a "fix and fuzz testing" PR, with a small group of agents participating. Fifth, if fuzz testing finds no issues, Slack sends a notification and the code auto-merges within an hour.

Auto-merge isn't unconditional. Following Anthropic's approach, risk needs to be classified into green, yellow, and red tiers based on impact scope. Changes involving critical functions like payments cannot auto-merge at this step and must have human sign-off; meanwhile, large numbers of small fixes, minor changes, and non-critical tasks can take this fast lane.
On the cost side, Grokbot, Grok, and Cursor have been unified into a single subscription plan sharing a weekly quota. The creator's advice is to route coding work to services you're already subscribed to, such as Claude Code—this both spreads out quota consumption and conveniently achieves environment isolation.
The role of fuzz testing in the agent pipeline
Fuzz testing (fuzzing) is an automated software testing technique that feeds large amounts of random or semi-random data into a program to observe whether it triggers crashes, exceptions, or security vulnerabilities. In this five-step loop, it serves as the last machine checkpoint before auto-merge: after the agent submits a "fix and fuzz testing" PR, fuzz testing repeatedly bombards the modified code paths with unexpected inputs, and only if no crashes or assertion failures are found within a set time does it trigger the Slack notification and proceed to auto-merge. Compared to unit tests that only verify known cases, fuzz testing can cover edge cases that neither developers nor agents thought of, which is why it's often used as a fallback signal for "the machine can determine on its own whether this is safe."
"Software Factory" or "Michelin Kitchen"
In the video, Lauren says she doesn't really like the term "software factory" and prefers the metaphor of a Michelin restaurant kitchen: as a developer, you're still responsible for the final result. Anthropic's Adi Azmani repeatedly emphasizes this too—with agents helping you, you're the head chef. You don't have to cook every dish yourself, but every dish that goes out still represents you.
The reality is that only a few companies currently operate fully on the software factory model, and they don't rely on constantly adding more agents. The creator observed that large companies like Stripe and Versal generally use Slack to manage agents. The real prerequisite is laying a solid infrastructure foundation and building trust in agents first—if you can't trust even one agent, how could you manage fifty?
The Tao Pyramid: Trust Must Be Built Layer by Layer
Lauren's "Tao Pyramid" has four layers, and most effort should go into the top layer.
The first layer is the codebase: more sensible architecture, stricter type constraints, clearer boundaries. Agents like to copy existing code and take shortcuts, so you need to make the right way the easiest way.
The second layer is static analysis—lint rules, tests, and continuous integration. If an agent repeatedly makes the same mistake, that mistake's check should be codified into a deterministic lint rule. The creator puts it bluntly: if you're dealing with the same kind of problem every time, the problem is your approach.
The third layer is written instructions, including rule files like agents.md and cloud.md, as well as skill modules, debugging bots, and security bots.
The bottom layer is human review. Human review is what everyone relies on most, but ultimately it can't keep up with scale. Anthropic found that from June to September, the number of PRs merged by Cloud Code more than doubled, while the share of PRs requiring rollback dropped by more than 40%—processing volume doubled while code still merged properly without causing incidents. Their position: review wasn't eliminated, but most of the code-reading work within review was handed to machines.
Alan Wells ran a more extreme experiment with a three-person team: to get the software factory to the point of submitting PRs without human code review, they paused all new product development for about six weeks to build verification mechanisms into the process. His assessment: it was painful at the time, but absolutely worth it.
Why static analysis and lint rules matter especially for agents
Static analysis is a technique for finding potential errors, style violations, or security risks without running code, by parsing the syntax tree, type information, and data flow of source code. Lint rules are the most common category—for example, banning implicit any, enforcing explicit return types, or detecting unused variables. For agents, the value of static analysis is amplified: models tend to imitate existing patterns in the codebase, and if the correct pattern isn't enforced by tooling, they'll take shortcuts. Once the same kind of mistake an agent repeatedly makes is codified into a deterministic lint rule, the error gets mechanically intercepted at the CI stage, no longer relying on human reviewers' memory—which is why the second layer of the Tao Pyramid is called the "deterministic defense line."
One Main Agent, Not Fifty
The creator has also set up bots for various parts of the company's business, but deliberately holds back from creating fifty different bots, because management costs would be too high. Ideally you only need to deal with one main agent—his own is called Chief, responsible for dispatching tasks, coordinating bots, creating groups for bots to communicate, with each bot's resource access strictly limited and shared on demand.

For a promotional website project specifically, after he talks with Chief, Chief launches a Cursor cloud agent, or runs a Claude Code instance on his Mac, also connected to a VPS. Configuration is simple: just tell Grokbot what to connect to and how you want it to run—for example, specify execution by a Cursor cloud agent, or specify the default model for a Claude Code instance. He uses the same process for video content, having Opus 5.5 help produce visual assets and launching multiple agents to record different terminal operation demo clips.
For task management, information and conversations collected from Slack go into a to-do list and are stored in Notion—Linear or Jira also work. He's also set up an automated Grokbot process that ranks items using RICE scoring—reach, impact, confidence, effort—plus an additional impact-scope score, so that "tasks with small effort that benefit many people" rank ahead of "small fixes." But he cautions against letting bots constantly suggest new ideas just to have something to do, or the to-do list will quickly get stuffed.
Lauren's improvement is similar: using automated Grokbot processes to gather context from Slack bug reports and complaints on X, then feed it into what she calls the "outer loop." But the creator specifically cautions that while this is fine for someone like Lauren with ample inference compute and huge quotas, ordinary people running it hourly would burn through enormous amounts of tokens.
The Security Door: The More Autonomy You Give, the More Control You Need
An easily overlooked detail: all Grokbot instances share one cloud computer, and files, browser, drawing tools, and command-line credentials are all shared too. If you log into a coding CLI tool with an API key on the computer Grokbot uses, all bots can use that key.

The creator admits that connecting all the tools and opening all workflows to agents is genuinely thrilling in terms of efficiency, but sooner or later you'll pay for it. The software factory security reference architecture jointly published by Docker and several security companies offers this core idea: the more autonomy you give an agent, the less you can rely on it to self-restrain—control must be enforced by the runtime environment. Specific practices include running agents in sandboxes, issuing credentials with limited permissions, and only allowing pull requests to be opened rather than merged—at least until you trust the tech stack enough to loosen merge permissions.
As an orchestrator, Grokbot can't solve all these security issues either. Codebases vary in importance, and policies need to be defined by you.
Common implementations of sandboxes and limited-permission credentials
A sandbox is an isolated runtime environment for an agent, restricting its file read/write, network access, and system calls to a controllable scope, so that even abnormal agent behavior won't affect the host machine or other services. Common implementations include containerized sandboxes (Docker, Firecracker microVMs), language-level sandboxes, and cloud-hosted sandboxes. Limited-permission credentials refer to issuing short-lived, least-privilege tokens: for example, only allowing reading specific repositories, only allowing creating branches and opening PRs but not merging directly, with tokens expiring automatically. Combined, the agent's autonomy is constrained within the boundary of "can propose, cannot finalize," keeping ultimate merge authority in the hands of humans or verified automated processes.
If You Want to Get Started, Begin Here
The creator's advice is not to build fifty agents right away—get one loop working first. His basic rule: unless it's a simple Q&A, don't let the orchestration bot write code itself. Instead, hand the task and acceptance tests together to a programming agent, verify the results, open a PR, and report back. Every time you correct an agent, codify it into the system—first fix the code, then add static check rules, then write it into rule files, and only rely on review as the last line.
This process can be further refined, and there's room to improve how each stage connects, but the core direction is clear: elevate human review to a higher level rather than keeping people stuck reading code. For developers using multiple AI programming tools at once, figuring out who plans, who executes, and who verifies may change the efficiency curve more than switching to a stronger model.
One-line Summary
Let orchestration bots be managers and programming agents be executors, replacing human code-reading with layered trust.
Paragraph Summary
The article synthesizes practices from a Bilibili creator, Grokbot and Cursor chief engineer Lauren, and T3 Code creator Theo, arguing that the efficiency gap among multiple AI programming tools comes from division of labor rather than model strength: orchestration bots handle requirement consolidation and verification, while programming agents like Claude Code, Codex, and Cursor handle coding. Lauren's five-step loop goes from Slack feedback through Linear to trigger a Cursor cloud agent, reproduce the issue, submit a fix-and-fuzz-testing PR, and decide on auto-merge based on green/yellow/red risk tiers. The author uses the "Tao Pyramid" to show that trust should be built first on the codebase, static analysis, and written instructions, with human review at the bottom layer, supported by Anthropic's data showing merge volume doubling while rollback rate dropped over 40%. On security, it emphasizes sandboxes and limited-permission credentials, and recommends getting one loop working first.
Related articles

AI Writes Your Code—Do You Still Need to Learn Git? Five Reasons
AI coding agents handle Git operations automatically—is it still necessary to learn Git? Five reasons: team communication, reviewing agent PRs, monitoring code changes, fallback when AI goes down, and the joy of learning—plus how the focus of learning Git is shifting in the agent era.

Anthropic Reportedly Prices IPO at $83 Per Share, Valuing Company at $1.5 Trillion
Anthropic reportedly prices IPO at $83 per share, above the expected range, with a fully diluted valuation of $1.5 trillion. This article analyzes the signal significance of the pricing and its impact on the AI industry's financing environment.

Open-Source Code Hosting Platform Codeberg Suffers Outage, Sparking Debate in Developer Community
Open-source code hosting platform Codeberg.org suffered an outage, sparking Hacker News debate over nonprofit platform stability and open-source infrastructure dependency risks.