Lauren Tan, an engineer on Grok Bot at xAI who previously worked at Netflix, Meta and Cursor, has publicly stated that she ships and merges between 2,000 and 2,500 pull requests to production every month with the help of autonomous AI agents. A pull request is a proposed code change submitted for review and merging, so that figure describes an unusually high volume of finished work. The habits behind that output did not start at xAI. Tan developed her core agent workflow while using Claude Code at Meta, where she paid $200 a month for a personal plan to run side projects. The same six habits carry over to Grok Bot, Claude Code or any similar coding agent, and most of them have less to do with clever prompting than with how you set up the agent's working environment.

Habit 1: Keep the bot team small and start with zero skills

The first instinct for many people is to download dozens of pre-made "skills" (reusable instruction packages that tell an agent how to perform a specific task) and spin up ten distinct bots on day one. Tan's approach is the opposite. She recommends starting with a very small team of agents and no pre-loaded skills or AGENTS.md files at all. AGENTS.md is a plain-text file in a code repository that gives an agent standing instructions about the project.

The reasoning is practical. Generic skills pulled off the internet tend to produce generic output, or, to put it bluntly, slop. Instead, give the agents real work first, watch where they fail repeatedly, and only then codify the fix into a reusable skill. Tan compares skills to a chef's personal knives: every cook works differently and needs a toolset shaped by their own hands. Adding more bots before the workflow is stable does not multiply output; it multiplies errors.

Habit 2: Onboard agents like interns with amnesia

Open a fresh chat with no context and ask for a newsletter draft, and you will likely get something that sounds nothing like your company and ignores your technical standards. Tan describes agents as new hires stuck in a permanent state of amnesia: they remember nothing from the previous session unless someone wrote it down.

The fix is to onboard them the way you would onboard a human intern:

  1. Introduce yourself and your role.
  2. Explain what the company does and what it is trying to achieve.
  3. Walk through the specific workflows the agent will handle.
  4. As you teach each task, have the agent record the steps into a skill so the next session starts from an informed baseline.

Person explaining a whiteboard workflow diagram to a small robot that writes notes into a thick binder at a desk

▲ Onboarding an agent like a new intern

Grok Bot includes features called "Teach a task" and "Learn from demonstration" that let the bot observe a workflow as it happens and log the steps for later use. With Claude Code or any other agent, the same result comes from persistent documentation and a structured set of skills the agent loads at the start of each session. Either way, the goal is the same: the agent should never again begin from zero.

Habit 3: Make the agent restate the task before it starts

Even a well-onboarded agent can misread an ambiguous or complex request, and the cost of that misreading grows with every minute of autonomous work. Tan's safeguard is a single instruction appended before any multi-step coding task:

"restate in your own words what you think my goals are and what the problem I'm trying to solve is"

The restatement exposes faulty assumptions while they are still cheap to correct. That one step can save roughly 20 minutes of agent compute that would otherwise go toward the wrong work. A useful pairing is voice mode or speech-to-text dictation: brain-dump your unorganized thoughts into the agent without worrying about structure, then let the restatement step turn that dump into a confirmed plan.

The principle is familiar from human work. Imagine someone at a video post-production house told to "mark any action" in sports footage, who then spends a full week tagging every throw, catch and dribble, only to learn the team wanted standout highlight plays. One clarifying sentence up front would have saved the week. Agents make the same kind of mistake, just faster.

Habit 4: Fix the setup, not the chat

When an agent produces a formatting error or a bad piece of code, the natural reaction is to correct it in the chat window. That fixes today's output and does nothing about tomorrow's. Tan's rule, in her words, is that "every weed you pull becomes a rule, so it can't grow back."

Gardener pulling a weed while staking a small fence in that spot, with earlier fences keeping the bed clear

▲ Every pulled weed becomes a permanent rule

She ranks the ways to make a mistake permanent history, from most to least valuable:

Priority Approach Why it ranks here
1 Better architecture and data structures Eliminates the whole category of error
2 Lint rules, tests or CI checks Catches the error deterministically, every time
3 A specialized skill or prompt rule Guides the agent but depends on it complying
4 Manual human code review Catches errors only when a person notices

A linter is a tool that automatically flags code that breaks style or correctness rules, and CI (continuous integration) is the automated pipeline that runs tests on every change. The point of the ranking is that constraints built into the repository and the environment apply to every future session without anyone remembering to repeat them. A prompt rule is a fallback, and a human reviewer is the last line of defense, not the first.

Habit 5: Require empirical proof of work

"I fixed it" is not evidence. Letting an agent self-report completion often leaves behind broken links, visual bugs and half-finished implementations. Tan's answer is to give agents verification skills so they can test their own work and prove it.

In her production setup at xAI, bug tickets arrive from Slack and go to a manager agent, which delegates fixes to worker agents. Each worker spins up the application, runs the tests and reports back with a screenshot or screen recording that shows the resolution. For a web task, that means instructing the agent to visit the live URL, click every link and capture visual proof. A landing page whose Blog, Careers, Contact and Help links all fail is exactly the kind of problem that looks finished in a chat transcript and obviously broken in a screenshot.

Tan also takes a clear position on a popular alternative: having multiple agents review each other's code adversarially. In her view this wastes tokens, often devolving into nitpicking and "You Aren't Gonna Need It" debates about hypothetical requirements. Replace abstract peer review with concrete, observable verification.

Habit 6: Keep doing your own writing

The final habit runs against the grain of full automation. Tan does not let agents write her public posts, her documentation or the core instructions that govern her agents. Her reasoning is that "writing is thinking." If you cannot write a clear instruction yourself, the agent cannot execute a clear plan, and the architecture of your agent system will drift into incoherence. Clear human writing is the input that makes every other habit work.

The caveat: 15 billion tokens a day

Tan's output comes with context that matters for anyone hoping to copy it. She works inside an AI lab and consumes an estimated 15 billion tokens per day. A standard developer on a retail plan attempting the same level of continuous automation would hit rate limits almost immediately.

Her own advice for managing usage is to avoid high-frequency scheduled routines. An automated task that fires every 15 minutes runs nearly 100 times a day and burns through a quota fast. Hourly or daily cadences preserve tokens for the work that actually needs an agent.

What to take from this

The through-line across all six habits is that shipping a high volume of code with agents depends on engineering discipline, not elaborate prompts. The agent is treated as a forgetful but capable new hire, the environment is hardened so mistakes cannot recur, and nothing counts as done until the agent shows proof.

For readers who want to apply this starting today:

  • Resist installing skill bundles. Run one or two agents on real tasks and write a skill only after you see the same failure twice.
  • Write an onboarding document that introduces you, your project and your workflows, and have the agent save new procedures as skills while you teach them.
  • Append the restatement prompt before any task that will take more than a few steps, and read the answer before approving execution.
  • When an error appears, ask which of the four tiers can stop it permanently, and reach for architecture, types and lint rules before adding another chat correction.
  • Demand screenshots, recordings or test output as the definition of done, especially for anything that touches a live web page.
  • Keep writing your own posts and core instructions.
  • Set scheduled agent jobs to hourly or daily intervals unless you have enterprise-scale token access.

The 2,000-plus monthly pull requests are a figure from one engineer with lab-scale resources, not a benchmark anyone should expect. The habits that produce them, however, cost nothing to adopt.