# All Code Is Slop (Except Mine) — Lauren Tan, SpaceXSI

- Channel: [AI Engineer](https://www.youtube.com/channel/UCLKPca3kwwd-B59HNr-_lvA)
- Published: 2026-11-14
- Source video: [Watch on YouTube](https://youtube.com/watch?v=O_zcc6Xl12g)
- Read on ReadTube: https://www.read.tube/p/videos/O_zcc6Xl12g
- Language: Original (source language)

## Summary

**Turning Agent Slop Into Gold**

AI agents make extreme software productivity possible, but only when teams build an environment that makes high-quality behavior the default. The most reliable safeguards are code-level constraints such as architecture, APIs, lint rules, and dependency checks, supported by extensive runtime, property-based, and formal verification. By turning repeated agent corrections into deterministic checks and keeping the codebase clean, the Grokbot team increased shipping velocity dramatically while maintaining performance and a low revert rate. Tan’s main warning is that automation magnifies the quality of the development loop, so strong foundations must come before building a large-scale software factory.

The central challenge of AI-assisted software engineering is increasing productivity without sacrificing quality. Lauren Tan argues that the solution is not blind trust in agents, but investment in an environment that makes correct behavior the default. After six months of refining this approach, she was able to ship thousands of pull requests, including many while away from the keyboard.

The codebase itself should provide the strongest guardrails because it is one of an agent’s largest inputs. Good APIs, architecture, refactoring, type systems, compilers, lint rules, and tests are more reliable than repeatedly adding instructions to prose files. Tan compares the codebase to a garden: deprecated patterns, workarounds, and technical debt spread quickly when agents copy them as established practice, while clean foundations encourage better code. At Grokbot, examples include banning React’s `useEffect` in product code, enforcing separate Electron main and renderer directories, and using dependency analysis to prevent harmful imports.

Deterministic constraints are more trustworthy than comments and written rules. Agents can use Markdown explanations to justify workarounds, turn a one-time correction into an overly rigid rule, or preserve architectural mistakes through comments. Grokbot therefore bans most comments and converts recurring corrections into enforceable checks with useful error messages that direct agents toward root causes. Repeating this process reduces the number of issues humans must inspect until agents can merge much of their own work.

Verification is the other major foundation for autonomy. Instead of reviewing every change line by line, the team examines artifacts such as videos, screenshots, diagrams, runtime tests, and formal proofs. Feature maps give agents a shared vocabulary for navigating the application, while custom command-line tools make repeated testing cheaper and more consistent. The team uses TLA Plus for model checking, Lean for algorithmic proofs, and property-based UI testing with Bombadil; these methods have already found bugs, though Tan emphasizes that formal verification is an additional layer rather than a complete solution.

These investments enable high velocity without proportional chaos. The Grokbot team reached 11,000 pull requests in a month, released stable client versions roughly daily, and involved 227 contributors in one month, while the relative revert rate stayed around half a percent and important performance measures improved. Tan’s advice is to improve the codebase and verification loop before automating it: otherwise, automation simply produces more slop at greater cost. Once those foundations are strong, an outer orchestration layer can run hundreds or thousands of agents, fuzz entire applications, generate fixes, and merge routine changes with limited human review.
