Lauren Tan, a principal engineer at SpaceXSI who works on Grok Bot, says her team shipped about 11,000 pull requests last month with a revert rate steady at about half a percent. She made the claim in a talk called All Code Is Slop (Except Mine) at the AI Engineer Code Summit in San Francisco.
Tan, who goes by poteto, gave the talk on the main stage on 11 November 2026. AI Engineer published the 17-minute recording on its YouTube channel on 14 November. Her argument is that the hard part of agent-written code is trust, and that the way to earn it is to put every correction somewhere harder to ignore than a line in AGENTS.md: the codebase, a lint rule or a test.
Where the talk comes from
SpaceXSI launched Grok Bot on 11 August 2026 as a team of always-on agents that have their own computer, sign in to the tools you already use and work 24 hours a day. The company says it began as an internal prototype. Tan works on Grok Bot and says in the talk that its client is still an Electron app, meaning a desktop app built with web technology. Related: Grok Bot’s access to Apple apps on the Mac and its 1.0 release for teams.
The talk is about how that client gets built. Tan says it took her six months of work on her agents’ environment before she could ship thousands of pull requests, many of them while she slept, and that others will get there faster. She opens by asking the audience whether they’ve looked at someone else’s code and thought “that’s all slop,” then says she’ll convince them they can “turn that slop into gold.”
Why she calls it a trust problem
Tan says that in 2024 she reviewed the three pull requests her colleagues had written that day, and that the number is now closer to 300. In her words, every engineer is now “a team of hundreds or even thousands of agents,” and code arrives so fast it feels like a continuous stream.
She compares the codebase to a garden. Agents copy whatever looks like the established pattern, so a workaround, an anti-pattern or deprecated code gets copied by the next agent and spreads, like weeds. Her conclusion is that the job of a software engineer is becoming gardening: keep the codebase clean so agents copy good code, and treat the constraints and guardrails as the concrete foundations new code grows around.
The pyramid: constraints first, prose last
Tan draws an inverse pyramid of where to spend time on an agent’s environment. The first two layers are deterministic, meaning they use the code itself. The first is codebase design: good APIs, architecture and refactoring. The second is static analysis and testing: lint rules (automated checks that fail the build when code breaks a rule), type systems, compilers and tests. Together, she says, they constrain what agents can do and force the right behaviour by default.
Verification sits above those: runtime and formal checks that find bugs and test whether the agent understood the goal. Prose comes last, “a little bit” of rules, skills and AGENTS.md for things that need judgment. Her working rule is that when you correct an agent, you should try to make the correction a deterministic check instead of adding another line to your rules, because it’s far more reproducible in code and lets you trust it more.

Dune: a framework that bans things
Her main example is Dune, a client framework the team created for Grok Bot. Tan says it isn’t technically interesting and that you can think of it as Next.js for Electron apps. What matters is the constraints and lint rules in it, which encode lessons the team learned building desktop applications. She gives three examples.
| Problem Tan describes | What the team did |
|---|---|
| React’s useEffect needs nuance, and agents misuse it | Banned it in product code. It’s allowed only in some places inside Dune’s own APIs. |
| Agents import main-thread code into the renderer, causing long tasks and jank (seen in Cursor) | Two top-level directories named electron main and electron renderer. A dependency graph analyser and lint rules forbid imports between them. |
| In Cursor, agents used timers such as setTimeout and requestAnimationFrame as quick fixes and wrote comments justifying them; the timers spread and the app lagged | Banned about 99% of comments. Lint rules give error messages that tell the agent to fix the root cause. |
Tan says the useEffect problem has been “categorically eliminated” and never needs catching in code review again. Her general principle is that every time the team corrects an agent, the correction becomes one of these deterministic checks, or the team finds a way to remove the problem through better API design or architecture. Do that enough times, she says, and there’s nothing left to review, so agents can merge most of their own pull requests.

Reviewing evidence instead of diffs
Tan says code review on her team has shrunk into looking at verification artifacts: videos, screenshots, diagrams and formal verification. The simplest form is runtime verification, which she describes as giving the agent a way to run the code itself and use the debugging tools human developers use, such as the Chrome DevTools protocol.
Her team’s runtime verification skills include a feature map, which works like a site map of everything the app offers from the user’s point of view, so an agent doesn’t have to guess what “the thingy in the left sidebar” means. The skills also use custom command-line tools and drivers that agents reuse each time, which she says cuts token use and makes the tooling testable.
More recently the team has started on formal verification. She says it uses TLA+, a language for modelling software above the code level that Leslie Lamport describes on his site, to model-check major user flows such as notifications across multiple devices and platforms. It also uses Lean, an open-source programming language and proof assistant, to prove properties of algorithms. Her example is the team’s own virtualization library, where Lean checks that it doesn’t flicker or jitter. Tan says this has already found quite a few bugs, isn’t a silver bullet and is treated as another layer.
The team has also begun property-based testing for interfaces, using Bombadil, an MIT-licensed tool from Antithesis. You write the properties your app should always satisfy in TypeScript, and Bombadil explores the app in a browser, checking them after each action. Tan says it has caught a few UI bugs already.
Tan also made a skill called statechart in her plugin pstack, short for “potato stack”. Per its documentation, it checks a TLA+ model of a product flow, draws it as a Mermaid statechart in the user’s terms, and gives the shortest path to each state that breaks a rule. She says it’s easier to review alongside the videos and screenshots her agents produce.
She cites another engineer who said six months ago that she couldn’t trust agent-merged code because of subtle bugs, and who now says 70% of her daily tokens go into verification. Tan says the same holds for her, and that none of these techniques is new. They were too hard to write and maintain before, she says, and agents cut that cost, so “we’re entering a golden age of software testing and verification.”
The numbers she gave
Tan says the Grok Bot team shipped 11,000 pull requests to production last month and cuts a new stable client version about once a day. She says 227 people contributed at least one pull request in October, including casual contributors who don’t always have much context. The share of pull requests reverted has fallen on a relative basis, she says, and is steady at about half a percent.

She also says performance has improved on several measures since launch, naming startup, typing, opening new chats and switching chats, and that Grok Bot, still an Electron app with the performance ceiling that implies, is already much faster than many other agent UIs.
The figures are Tan’s team’s own. AI Engineer’s write-up of the talk calls them reported outcomes, not a controlled experiment showing every repository will improve as merge volume rises. The talk doesn’t define what counts as a revert or over what window, doesn’t give a revert rate from before the team used agents, and doesn’t break the 11,000 down by size or by who or what wrote each pull request.
Foundations before a software factory
Tan’s advice for teams that want to automate everything is to sequence the work. Whenever you correct an agent, improve the codebase first: add a lint rule to stop new occurrences of the anti-pattern, then clean up the old ones, and make verification strong. She says much of that is a prerequisite for automation anyway, because if the inner coding loop produces slop, automating it produces more slop and burns more tokens.
Once those foundations exist, she says, building the outer loop is easy, and Grok Bot is a way to do it, with connectors and routines that can start Cursor cloud agents and projects. Her example is the team’s release routine. When it cuts a release, Grok Bot starts a Cursor project that fuzzes the whole application and build by running the app like a real user, opens a fix pull request for each bug it finds and automerges it. Tan says that works because “pull requests tend to just be good by default” and “most product code that we land no longer really requires deep human review.”
The talk’s description links Tan’s GitHub profile and pstack, which is public in the cursor/plugins repository and is also listed as a plugin for Grok Bot. It doesn’t link a Dune repository.
Discover more from Sulat AI & Tech News
Subscribe to get the latest posts sent to your email.




