TL;DR: SpaceXSI engineer Lauren Tan says she shipped about 3,000 PRs to production in the month before her talk, Grok Bot’s full team shipped about 11,000, and the team’s revert rate sits around 0.5%. Her method is a trust pyramid: when an agent makes a mistake, first fix the codebase, then write a deterministic check, then add validation, and only then append a line to a rules file. She also says that pace came after roughly six months of environment engineering. The viral post sharing her talk captured the main points reasonably well. What is easier to misread is the long piece it links to, specifically the opening two sentences: multi-agent wins by 90%, and Cursor built a browser in a week. Both have conditions the original sources spell out.

On November 15, a post on X introduced Lauren Tan’s talk: every mistake an agent makes becomes a lint rule, not a prompt; agents verify their own work with video, screenshots, and tests; the result is 3,000 PRs shipped in a month; and the codebase is now clean enough that agents merge most PRs themselves. When I read it on November 19, the post showed roughly five million views.

The post linked to a longer piece by the same author from two days earlier: “How to build an AI agent swarm that works without you.” Its opening two sentences are that Anthropic’s agent team beat a single agent by 90%, and that Cursor built a browser in a week. Read together, the two posts suggest a simple thesis: run more agents, let them loose, and output explodes.

I went through the talk video, the official transcript page, and the original sources being cited. The talk is about building the environment that makes agents less likely to fail in the first place. Each of the three eye-catching numbers in those posts carries conditions that the original sources attach to them.

This piece is part of the Intelligence and Order series.

Who is Lauren Tan, and what is “All Code Is Slop (Except Mine)” about?

Lauren Tan’s online handle is poteto. She is a Principal Engineer at SpaceXSI and a core member of the Grok Bot team. SpaceXSI is SpaceX’s AI division, formerly xAI. Grok Bot is their AI teammate product; the desktop client is an Electron application. She previously served on the Meta React core team and contributed to React Compiler, and she joined Cursor in early 2026.

On November 11, 2026, she gave the talk “All Code Is Slop (Except Mine)” on the main stage at the AI Engineer Code Summit in San Francisco. “Slop” in AI circles typically refers to output that is high-volume but low-quality. The primary sources are the official transcript page and the talk video, which runs about 17 and a half minutes.

When an agent makes a mistake, which layer gets the fix?

She arranges the work of getting trustworthy code from agents into an inverted pyramid. The widest layer is at the top, and the wider a layer, the more she thinks engineers should invest there. From top to bottom:

  1. The codebase itself: API design, architecture, refactoring.
  2. Deterministic checks that do not depend on model judgment: lint, types, the compiler, tests.
  3. Validation: runtime validation where the agent runs the code itself, and formal verification.
  4. Text rules: AGENTS.md, rules files, skills, any instruction that requires the model to interpret it.

The pointed tip at the bottom is human review, the most expensive resource in the system.

Many people using AI for coding respond to an agent mistake by writing another line in the prompt or the rules file: “don’t do this.” She inverts that order. Her reasoning is that the codebase is the agent’s largest input: a workaround left in the code will be treated as an established pattern by the next agent that reads it. She uses a gardening analogy: in 2024 she was reviewing three PRs from colleagues; by the time of this talk, she was closer to 300. So when she corrects an agent, she asks two questions first. Can this become a deterministic check that blocks the mistake the moment it is written? Better yet, can the design be changed so that the wrong choice cannot be written at all?

Text rules have not disappeared. Things that require judgment and cannot be encoded as a check still live in that layer. The viral post’s framing, that “every mistake becomes lint, not a prompt,” omits this.

Four-panel comic: When an agent makes a mistake, which layer gets the fix? Many people respond by writing another line in the prompt or the rules file: "don't do this." A workaround left in the code will be treated as an established pattern by the next agent that reads it. When she corrects an agent, she asks first: can this become a deterministic check that blocks the mistake the moment it is written? Better yet, can the design be changed so that the wrong choice cannot be written at all? If neither works, put it in the rules file.

How does she encode the fix into the code itself?

Most of the problems she cites come from her time at Cursor, which like Grok Bot is an Electron application. The solutions are built into Dune, the internal framework her team has developed for Grok Bot:

  • Ban APIs that agents consistently misuse: Production code is not allowed to use React’s useEffect; only designated framework APIs are permitted. Her reasoning is that agents repeatedly handle the judgment that hook requires incorrectly. The official transcript page also notes this is a local architectural decision for the team and is not a claim that the hook should never be used anywhere.
  • Use directories and lint to draw hard boundaries: At Cursor, an agent once imported main-process code into the renderer process. Grok Bot separates the two into clearly named top-level directories; dependency analysis tools and lint rules prohibit cross-imports between them.
  • Write fewer comments, write more lint: Also at Cursor, agents would use timers like setTimeout and requestAnimationFrame to paper over the gap between imperative and declarative code, then write a comment defending the workaround. The Grok Bot team banned roughly 99% of comments and replaced them with lint rules whose error messages tell the agent to fix the root cause instead.

When an agent repeats the same mistake, her sequence is: write a lint rule to block new instances of the bad pattern, then go back and clean up the existing examples so the next agent does not copy them.

Code review has changed shape accordingly. She says review has narrowed to examining the validation artifacts the agent delivers: video, screenshots, charts, and formal verification results. Agents interact with the running application through the Chrome DevTools Protocol. TLA+ is used to check the design of multi-device notifications; Lean is used to prove properties of a virtualization algorithm; and there is also property-based UI testing. She presents all of these as experiments and early results, and she is explicit that formal methods are promising but not a cure-all.

Most of her tokens go to verification, not to writing code. She also cited her colleague Cindy Sridharan’s figure: about 70% of daily tokens spent on verification.

My own version of this: a blocked agent finding another route

I am not an engineer, but I have run into this ordering twice in my own workflow.

The first time was when I set Grok up as a reviewer. I restricted it on my Mac from writing files. After being refused, it tried to find another path in via the shell, and was eventually stopped by the macOS sandbox. I ended up layering three read-only restrictions: a tool list that only exposed read operations, a permissions rule blocking writes and the command line, and the sandbox as a final backstop. If one layer was bypassed, another remained. Against Lauren Tan’s pyramid: the first restriction blocked the original write path but not the alternate one. What finally stopped it was the last layer, the sandbox.

The second time was in editing. I once wired five categories of writing problems into a pre-submission script: contrastive sentence patterns, em dashes, clusters of enumeration marks, strings of short sentences, and default filler phrases. The script surfaces places worth a second look, all in one pass.

But the script has limits. It flags sentences that may need revisiting; its flags are not instructions. Meaning, tone, and whether an experience actually happened are still mine to verify. Tools can help surface problems; they cannot confirm that a story that never happened is true. I read this as the reason the pyramid still needs text rules and human review at the bottom: my script can flag patterns, but what it flags is not always a problem, and it cannot check facts.

While writing this piece, I sorted through 74 accumulated correction notes using this framework, then asked Codex to sort the same notes independently from summaries. Comparing the two passes: 17 notes can be deleted now, because the check has already been written or the original condition no longer applies. 23 can be rewritten as checks. 34 can only stay as text, mostly judgment calls, authorizations, and voice decisions.

What caught my attention after sorting was something else. Three places where I thought a check was already in place were validating the wrong version of the thing. For example, after the source text is updated, only one language’s translation gets re-run; the other two are logged as already updated. Those three are unresolved. They are the next thing to fix. My reading: the checks that sit in the upper layers of the pyramid also need someone to periodically go back and verify them.

Clarification one: the six months and the 0.5% that the “three thousand PRs” story leaves out

The numbers from the talk are:

  • She personally shipped about 3,000 PRs to production in the month before the talk.
  • The full Grok Bot team shipped about 11,000 PRs to production in the same month. In October, roughly 227 people contributed at least one PR, and the stable client shipped roughly once a day.
  • The team’s revert rate (merged and then pulled back) has held steady at about 0.5%. The talk gives no individual rate for her. A more complete transcript summary notes that this only counts reverted PRs; bugs fixed in a subsequent PR are not included in the figure.

The viral post’s 3,000 is accurate. What it omits is two things. First, she says it took about six months of tuning the agent’s working environment before she was comfortable at that pace, and that those six months came before any “software factory” style automation. Second, that 0.5%. My reading: the volume largely holds because of the checks and validation built beforehand. The number alone does not show that layer.

The post also says her codebase is now clean enough that agents merge most PRs themselves. The talk’s phrasing is that agents “can” merge most PRs themselves. The official transcript page frames it as a condition: after enough corrections have been encoded as checks and design changes, the remaining review surface shrinks small enough that autonomous merging becomes viable. The auto-merge pipeline confirmed to be running now is a different one: after each release, a Cursor project operates the full build as a real user would, opens a fix PR when it finds a bug, and merges it automatically. She also said that most production code being shipped no longer requires deep human review.

One line from the talk I want to keep: if the inner coding loop is producing slop, automating it only produces more slop.

All of these figures come from her own statements on stage. I found no third-party verification. The official transcript page notes they are self-reported results, not a controlled experiment, and cannot be taken to mean any other codebase would see the same. The transcript page also gives no breakdown of PR size, type, or total tokens consumed.

Clarification two: what does “agents beat solo by 90%” actually measure?

The figure comes from Anthropic’s June 2025 engineering post, “How we built our multi-agent research system.” The precise value is 90.2%. Three conditions are routinely dropped when it circulates:

  • It measures Anthropic’s internal research benchmark: Claude Opus 4 as the lead agent directing several Claude Sonnet 4 sub-agents, compared against a single Opus 4.
  • The task is information-gathering and research work that can be parallelized. This is not a coding benchmark.
  • The same post notes that multi-agent systems consume roughly 15 times the tokens of a standard conversation, and that most coding tasks have fewer parts that can genuinely be parallelized compared to research.

The same post actually contains two different 90% figures. The other one is that parallelization reduces research time on complex queries by up to 90%; that is the figure the long piece uses in its body text.

To be fair, the body of that long piece is more careful than its opening. It includes a full section on when not to use an agent swarm, cites the 15x token figure, and references a study from Google Research, Google DeepMind, and MIT: “Towards a Science of Scaling Agent Systems.” That study found multi-agent coordination provides clear gains on tasks that can be parallelized but degrades performance on sequential ones. The author also recommends starting with a single agent and stopping if it performs well enough. What got amplified was the opening two sentences. The post is labeled on X as a Paid Partnership, with the sponsorship attributed to Viktor, an AI employee service, disclosed at the end.

What does Cursor building a browser in a week actually prove?

It is partly true. Cursor’s January 2026 post, “Scaling long-running autonomous coding,” describes a run where agents built a browser from scratch over nearly a week, producing more than one million lines of code across 1,000 files. The agents worked in three roles: planners continuously explored the codebase and decomposed tasks; executors focused on completing individual tasks; reviewers decided at the end of each round whether to continue. Cursor’s post says hundreds of agents ran concurrently; Simon Willison, in his writeup, noted a peak of around 2,000.

“A week” needs a note. According to Willison’s summary of a recorded conversation, nearly a week was the longest single continuous run as of when Cursor published the post. The full research project ran about three weeks. Before that, it began in November 2025 as Wilson Lin’s personal side project, using a single agent. “From scratch” also deserves some qualification: agents pulled in existing packages like Taffy and QuickJS. The team also allowed agents to leave small temporary errors in place, trading correctness for throughput.

It was a research experiment. Willison’s piece is drawn from his recorded conversation with Wilson Lin, the project’s author, who said they never intended to ship it as production or usable software. JavaScript was disabled at the time: the engine was still being implemented, and an agent had gated it behind a feature flag. What it demonstrates is that agents can coordinate over long timeframes. It does not demonstrate that the resulting artifact was ready to use.

Build the environment first, then talk about letting go

Looking at all three together, the pattern I read is: AI coding output can scale to remarkable numbers, but every example of that scale has conditions. Lauren Tan’s numbers, by her own account, come after six months of guardrail engineering. Anthropic’s 90% compares performance on research tasks suited to parallelization, and multi-agent itself costs roughly 15 times the tokens of a normal conversation. Cursor’s browser was an experiment.

Earlier this month I wrote about Thorsten Ball’s fifteen agent work habits, one of which says there is no longer any reason to worry about agents producing messy code. My reading at the time was that his ability to not worry about that is related to his working conditions. Lauren Tan’s talk makes those conditions explicit: codebase boundaries, lint that actually blocks mistakes, validation the agent runs itself, and the majority of tokens going to verification rather than generation. One says don’t worry about slop; the other says all code is slop. I read them as two sides of the same point.

This runs along the same line I drew in “If You Want AI to Do Bigger Things, Build the Error-Catching Infrastructure First.” Lauren Tan adds a more specific answer: which layer the fix should land in.

The next time an agent makes the same mistake again, resist the reflex to add a line to the rules file. Ask first whether it can become a test or a lint rule that blocks the mistake the moment it is written. Then ask whether a redesign could make that mistake impossible to write. Only if both answers are no does it go in the rules file.

The longer the rules file grows, the more it is worth looking back through it to see which lines could be handed to the code instead.