AI Engineer

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

Published 2026-11-14 · Duration 17:32

Summary

The presentation details how the Grok Bot team at SpaceXSI achieved high-velocity software development (shipping 11,000 pull requests in one month) while maintaining extremely high quality (a 0.5% revert rate). The core thesis is that the role of the software engineer is evolving into 'gardening'—improving the codebase's foundation—to manage the massive input volume generated by AI coding agents. High-trust environments are built by layering deterministic checks: improving the codebase with lint rules and API design, implementing runtime and formal verification (using tools like TLA+ and Lean), and finally, automating the process.

Download summary

Key takeaways

  1. The Software Factory Model

    Achieving high-volume, high-quality code generation requires building a 'software factory' focused on trust. This involves moving from manual code review to reviewing verification artifacts (e.g., videos, formal proofs).

  2. Codebase as the Primary Constraint 0:43

    Since the codebase is the largest input for AI agents, the most effective way to correct agent behavior is to make the correction a deterministic check (e.g., a lint rule or API constraint) rather than relying on prose or rules files.

  3. Verification is Key to Trust 2:13

    The process of increasing agent autonomy relies heavily on verification layers. Techniques include runtime verification (using tools like the Chrome DevTools protocol) and formal verification (using TLA+ for model checking and Lean for algorithm proofs).

  4. High Velocity, Low Revert Rate 2:13

    The team reported shipping 11,000 pull requests in one month, maintaining a low relative revert rate of approximately 0.5%, demonstrating that solid foundations enable massive scaling.

More digests on AI Coding Agents

Technical details

  • Architecture and Linting 79s

    Implemented 'organic architecture' constraints, such as banning specific anti-patterns (e.g., using `useEffect` in React) or enforcing strict directory separation (e.g., dedicated `Electron renderer` and `Electron main` directories) via lint rules, thereby eliminating classes of bugs before review.

  • Formal Verification 155s

    Utilizing TLA+ for model checking major user flows (like cross-device notifications) and using Lean to prove correctness for custom algorithms (e.g., a virtualization library) to prevent visual bugs like flickering or jittering.

  • Agent Tooling and APIs 180s

    Developed custom skills and CLIs to provide shared vocabulary (Feature Maps) and allow agents to reuse drivers, which reduces token usage and improves testability. The speaker also introduced a state chart skill in the Pstack plugin for visualizing state machines.

  • Code Quality Improvement 105s

    The general principle is that every time an agent needs correction, the fix should be codified into a deterministic check (lint rule, API design) to prevent recurrence, rather than being addressed in documentation or rules files.

Mentioned resources

  • Grok Bot (Product/System)
  • Dune (Client Framework)
  • TLA+ (Formal Verification Tool)
  • Lean (Proof Assistant)
  • Pstack (Potato Stack) (Plugin/Tool)

Channel & topics

Watch on YouTube · Back to latest

This independent, AI-assisted summary is provided for commentary and informational purposes. It may contain errors or omit important context. Please watch the original video for the creator's complete presentation. Video, thumbnail, and related copyrights belong to their respective owners.