What Lauren Tan’s “All Code Is Slop” Talk Means for Teams Without Six Months to Spare
Lauren Tan ships thousands of agent-written pull requests a month, and her team reviews evidence instead of diffs. Getting there took her six months. Here is what to copy from her talk, and what you can adopt ready-made.
Yunhao Jiao9 分で読めます

At the AI Engineer Code Summit on November 11, Lauren Tan, an engineer on Grok Bot at SpaceXSI, gave a talk with a title most engineers have thought at least once: All Code Is Slop (Except Mine). She said she had shipped about 3,000 pull requests to production the month before, many of them while she slept. The Grok Bot team as a whole shipped about 11,000 in a month, with roughly half a percent reverted.
The joke in the title is the point. “Mine” isn’t her code. It’s her environment: the rules, checks and verification every change has to get through before it ships. She said it took her six months to reach the point where she could trust it.
Most teams won’t spend six months. This post is about what to take from her talk anyway: the parts you should build yourself, and the one layer you can adopt.
Trust lives in the codebase, not the prompt
Her talk is organized around an inverted pyramid. The wide base is deterministic: API design, architecture, lint rules, types, compilers and tests. Above it sit runtime and formal verification, which check how the app behaves and whether it does what was intended. The narrow top is prose, the rules files, skills and agent instructions, kept for judgment calls.
The order matters because a rule in a markdown file is a request and a lint rule is a fact. Her team removed almost all code comments, since they go stale and nothing enforces them, and turns each repeated agent mistake into a lint error whose message explains the real fix. She treats the codebase as a garden: it is the largest thing an agent reads, so every workaround left in it is an instruction to the next agent.
What review became
The line that stayed with us: her team’s code review “has now really shrunk into looking at verification artifacts.” Agents run the app themselves, through the Chrome DevTools Protocol, and hand back videos and screenshots of what they did. A feature map gives agents and people one description of what the product does. For the riskiest logic there are formal methods, model checking and proofs, which she called useful and “certainly not a silver bullet.”
That is a different job from reading diffs. A reviewer watching a recording of a real user flow can answer the question that matters, does it work, without rebuilding it in their head from the code.
The warning that’s easy to skip
Near the end, she said to harden the inner loop before automating it. Automate a loop that lets slop through, and you get more slop, faster. More agents on a weak verification layer don’t ship more working software. They ship more of whatever gets past it.
That is also why her setup took six months. It isn’t one tool. It’s a client framework with hard rules, a dependency analyzer, a custom CLI the agents reuse, the feature map, runtime verification skills, formal models and fuzzing on every release.
What to copy this week
- Turn every repeated correction into a check. If you’ve told an agent the same thing twice, it belongs in a lint rule, a type or a test, with an error message that names the fix.
- Delete the patterns you don’t want copied. An old workaround is an instruction to the next agent.
- Ask for evidence, not a summary. A pull request from an agent should show what was run and what happened, not a paragraph saying it works.
- Write down what the product should do. Her feature map is the reference that runtime verification checks against. Without one, an agent can only check the app against itself.
What you can adopt instead of building
Much of what she built is specific to her codebase, and that part is yours to build: your architecture, your lint rules, your formal models. No product replaces a framework designed around your own code.
One layer is more general: running the app the way a user would, on every change, checking it against what it should do, and bringing back evidence a person can look at. Its hard parts look similar from team to team: a written description of what the product should do, an agent that can sign in and drive the app, and a record of what it saw. That layer is what TestSprite provides.
You describe what your app should do, or hand it a PRD or a ticket, and it drafts a test plan your team approves, where every test says in plain language what it expects. On every pull request it drives your frontend in real browsers and your backend across multi-step flows, and reports a status check you can make required. Every failure comes back with a replay, the failing step, expected versus actual, and a verdict on whether it’s a real bug, a test problem or the environment. You still connect your environments and test accounts; the agent handles signing in, one-time codes included. Our 4.0 launch post shows it catching a bug that two green checks missed.

The reference also sits outside the change. TestSprite didn’t write the code it’s checking, and what a test expects changes only when someone on your team approves it, so a change can’t quietly redefine what passing means. Our guide on reviewing AI pull requests goes through the evidence to ask for, step by step.
Slop into gold
Her talk ended on turning slop into gold. We’d add one note for teams without six months: you don’t have to finish the whole pyramid before you start. Put the rules in your codebase, get a verification layer running on every change, and spend your review time on the evidence.