🎉 Giảm 20% cho đơn hàng đầu tiên!✦🚚 Miễn phí vận chuyển cho đơn trên 500.000₫✦⚡ Flash Sale — Số lượng có hạn!✦🎁 Quà tặng kèm cho đơn từ 1.000.000₫✦🎉 Giảm 20% cho đơn hàng đầu tiên!✦🚚 Miễn phí vận chuyển cho đơn trên 500.000₫✦⚡ Flash Sale — Số lượng có hạn!✦🎁 Quà tặng kèm cho đơn từ 1.000.000₫✦
Lauren Tan: 'Everyone else's code is AI slop, mine isn't' — 3,127 pull requests in a month by 'gardening' the codebase
Quay lại Blog

Lauren Tan: 'Everyone else's code is AI slop, mine isn't' — 3,127 pull requests in a month by 'gardening' the codebase

16 tháng 11, 202613 phút đọcVũ Khôi
English
#English
Vũ Khôi

Vũ Khôi

Tác giả tại Wotech Electronics Blog

Illustration: the codebase as a garden that AI agents tend every day

Lauren Tan: "Everyone else's code is AI slop, mine isn't" — 3,127 pull requests in a month by "gardening" the codebase

Lauren Tan, a software engineer the post introduces as being from SpaceX, once joked with heavy irony: "All code is AI slop, except mine." Behind the joke lies a structured way of working with AI agents: in a single month, she shipped 3,127 pull requests, according to a post by the page Học lập trình cho người mới bắt đầu on 15 November 2026. The attached video records a talk by Lauren Tan herself (nickname Potato), in which she presents her core thesis: the software engineer's job today is to find a way to maintain, even improve, code quality while massively increasing productivity — by investing in the agent's environment, not through blind trust. This article presents the video's content from its auto-generated transcript and the original post; some internal tool names in the transcript are unclear and are therefore presented only in general terms. Wotech previously introduced Lauren Tan's 5-layer foundation model in an article on 12 November 2026; this article presents the talk itself, with its examples and figures.

Quick answer: According to the talk, Lauren Tan (Potato) shipped 3,000 pull requests to production in one month — the post gives the exact figure as 3,127 — by investing in the agent's environment so she can trust agents to do the right thing, rather than trusting them blindly. Her thesis: the software engineer's job is to maintain or improve code quality while massively increasing productivity. She uses an inverse-pyramid model to allocate time: two deterministic layers at the bottom — the codebase itself (good API design, architecture, refactoring) and lint rules, type systems, compilers, and testing — followed by verification (runtime and formal), and on top only a little "prose" (rules, skills, AGENTS.md — things requiring judgment). The codebase is compared to a garden: because the codebase is the agent's largest input, every workaround, anti-pattern, or piece of old code will be copied by the next agent; to make agents always copy the good stuff, keep the codebase as "pristine" as possible. The whole team's results, according to the talk: 11,000 pull requests in a month, a new stable release about once a day, 227 contributors in October, a revert rate steady at about 0.5%, and application performance still improving.

AI slop is a mocking term for code generated by AI in bulk but of low quality and little thought. The inverse pyramid is the model Lauren Tan uses to decide where to spend time in the agent's environment: most time on deterministic layers (code and automated checking tools), less on verification, and least on written instructions requiring judgment.

What is the "turn slop into gold" thesis?

Opening her talk, Lauren Tan asked the audience whether anyone had ever looked at code someone else wrote and thought "that's all slop" — then promised to convince them that slop can be turned into gold. She said that last month she shipped 3,000 pull requests to production; the post gives the exact figure as 3,127.

Before agents, she said, nobody really cared about volume — except for outliers called "coding machines", like Brett Taylor, famous for rewriting all of Google Maps in a weekend. With agents, anyone can now be a coding machine. Her thesis: the job of the software engineer — the "meta" of the profession — is figuring out how to maintain or even improve code quality while massively increasing productivity.

She does not call it a "software factory" but keeps things simple: it is all about trust. Not blind trust, but investing in the agent's environment so you can trust that agents will do the right thing. She said it took her six months to reach the point where she could ship thousands of pull requests, many of them in her sleep — but it will take others much less time than it took her.

What layers make up the inverse pyramid?

Layer (bottom to top) Contents Nature
Codebase Good API design, architecture, refactoring — using the code itself to constrain agents Deterministic
Checking tools Lint rules, type systems, compilers, kinds of testing — forcing agents to do the right thing by default Deterministic
Verification Runtime verification and formal verification — finding bugs, checking the properties the system must hold, checking whether the agent understood the goals Additional layer
Prose Rules, skills, AGENTS.md — things requiring judgment Least, only a little

The principle she emphasizes: whenever you correct your agent, think about how you can turn that correction into a deterministic check instead of adding another line to your rules or AGENTS.md — because a check in code is far more reproducible and more trustworthy.

Why is the codebase compared to a garden?

Lauren Tan uses an analogy: the codebase is like a garden. Code used to arrive a few pull requests at a time — she remembers going to work in 2024 and reviewing three pull requests her colleagues wrote; today that number is more like 300. Every engineer is now a team of hundreds or even thousands of agents, and code arrives so rapidly that it feels almost like a continuous stream, almost organic, like a living thing.

Because the codebase is the biggest input for agents, any workarounds, anti-patterns, deprecated code, or tech debt are likely to be copied by the next agent, since they look like the established pattern in the codebase — like weeds or pests spreading through a garden. So, she advises, make the codebase as pristine as possible so agents always copy the good stuff. The constraints imposed on the codebase — the "guard wheels" the team puts up — are the concrete foundations the new code agents write grows around, like the building in her illustration photo. In many ways, the software engineer's job is becoming like gardening.

What real examples are given in the talk?

She gives several examples from Dune — the client framework her team created for their Electron application, which she describes as roughly "Next.js for Electron apps", though the interesting part lies in its many constraints and lint rules encoding lessons learned building desktop applications:

  • Banning useEffect in product code: anything requiring nuance to use well — the classic example being useEffect in React, often misused — tends to lead to slop, because agents are not good at using things that require nuance. The team's solution was to ban it outright in product code, allowing it only in some places inside Dune APIs. The problem was categorically eliminated, never to be caught again in code review.
  • Context through directory structure: the team saw an anti-pattern where agents imported main-thread code into the render thread in an Electron app, causing long tasks and jank. The team made it very conventional: two top-level directories literally called electron-main and electron-render, with imports between them forbidden by a dependency graph analyzer and lint rules.
  • Banning 99% of comments: agents use markdown — documentation, code comments, rules, skills — as a place to write justifications for not doing the right thing, or over-rotate on a small correction and treat it as a hard rule that can never be broken. The team once had agents overusing imperative timers (setTimeout, requestAnimationFrame) as quick fixes patching over an architecture clash, with code comments explaining why the quick fix was justified — then timers spread everywhere and app performance suffered. The team decided to ban 99% of comments, because comments are not enforceable: something well-intentioned like "telling the next agent not to do something" never ends up being anything trustworthy. Instead, the team uses lint rules with helpful error messages telling the agent to fix the root cause rather than patch around it.

The general principle: every time you correct your agents, turn it into a deterministic check, or think about how to categorically eliminate that problem in the code through better API design and architecture. Do that enough times and there are fewer things to look out for in code review — and at some point, you realize there is nothing left to review, and you can let agents merge most of their own pull requests.

What role does verification play?

Verification is also a big part of how her team makes agents more autonomous and increases confidence in their work. The team's code review process has shrunk into looking at verification artifacts: videos, screenshots, diagrams, and formal verification.

  • Runtime verification: giving the agent a way to run the code — the team's runtime verification skills include something called a "feature map", basically a site map of all features available in the application from the user's point of view, creating a shared vocabulary so agents do not have to guess what "the thingy in the left sidebar" is; plus custom CLIs agents can reuse, cutting token usage and being testable.
  • Formal verification: the team uses TLA+ for model checking major user flows such as notifications across multiple devices and platforms, and Lean for proving certain algorithms — for example a custom virtualization library, checking for flickering or jittering problems. The team is still experimenting with this approach, has already found quite a few bugs with it, but stresses it is not a silver bullet — just another layer in the agent's environment.
  • Property-based testing for UIs: the team uses a library (whose name is unclear in the auto-generated transcript) that has already caught a few UI bugs.

She retold a post on X by Cindy: six months ago Cindy said she could not trust her agents because of subtle bugs getting merged; what was missing was the verification process. Six months later, Cindy says 70% of her daily tokens go into verification — and Lauren Tan says that tracks with what she sees: most of her own token usage goes to verification. According to her, none of these techniques is new; they are just good software engineering tools that used to be prohibitively expensive to use, while agents have drastically cut that cost — we are entering a "golden age of software testing and verification".

What results were achieved?

According to the talk, the team's velocity is taking off: last month the team shipped 11,000 pull requests to production, the pace of releasing the client increased — a new stable version about once a day — and there are many more casual or drive-by contributors with less context who still contribute; in October alone about 227 people contributed at least one pull request.

Despite the accelerating velocity, the number of reverted pull requests has fallen on a relative basis and is steady at about 0.5%. Application performance has stayed not just stable but improved on multiple dimensions compared with launch: startup, typing, opening new chats, and switching chats all got faster.

The team also automated the outer loop: whenever a new release is cut, the system automatically spins up a new project that fuzzes the entire application, finds bugs by using the app like a real user, opens fix pull requests for each bug, and auto-merges them — because the codebase is good enough that pull requests tend to be good by default, and most product code no longer requires deep human review.

The lesson: where to start?

Before jumping into building a software factory and automating everything, Lauren Tan advises: whenever you correct your agent, start by improving your codebase first — add a lint rule to prevent new occurrences of anti-patterns, then clean up the old patterns too — and make sure the verification story is really strong. Much of this work is a prerequisite to automation anyway: if the inner coding loop produces slop, automating that loop just produces more slop and throws more tokens at the problem, which everyone knows is very expensive. Once the investments are made in the codebase, static analysis, and runtime and formal verification, many things become possible — and you can build your own factory on those foundations. With solid foundations and good organic architecture, you can turn slop into gold: shipping with high quality and high velocity without compromising on quality.

Frequently asked questions

1. Who is Lauren Tan, and what did she achieve? According to the post, Lauren Tan (nickname Potato) is a software engineer at SpaceX; she shipped 3,127 pull requests in one month, according to the post, and presents her way of working with AI agents in the attached video.

2. What is the talk's main thesis? The software engineer's job is to maintain or improve code quality while massively increasing productivity — by investing in the agent's environment so agents can be trusted, not through blind trust.

3. What layers make up the inverse pyramid? From the bottom up: the codebase, deterministic checking tools (lint, types, compilers, testing), verification (runtime and formal), and on top only a little prose (rules, skills, AGENTS.md).

4. Why did her team ban useEffect and 99% of comments? Because things requiring nuance to use well are used poorly by agents, and comments are unenforceable — agents use comments to justify not doing the right thing. The team replaced them with lint rules and designs that eliminate problems categorically.

5. What results did her team achieve? According to the talk: 11,000 pull requests in one month, a new stable version about once a day, 227 contributors in October, a revert rate of about 0.5%, and improved application performance.

This article was rewritten from a video (reel) by the page Học lập trình cho người mới bắt đầu on 15 November 2026, recording a talk by Lauren Tan (Potato). The content follows the video's auto-generated transcript and the original post; some internal tool names in the transcript are unclear and are therefore presented only in general terms. The figures follow the talk and the post and have not been independently verified.