Wide at the top = most effort. The top two layers are . The bottom layer is words, so nothing fails when an agent ignores them.
Her claim: anyone can now ship code like a "coding machine." The engineer's real job is to keep quality high while the volume goes up 100 times. She does not do this by watching agents closely. She builds an where the agent does the right thing by default.
tap or hover any dotted word for a "wtf is this" box
help agents write good code
move the checking from you to the agent
low trust
every change needs your eyes
high trust
you look at proof, not code
"Trust" here is not blind trust. You trust the agent because the walls hold. Her goal: so little is left to review that agents merge most of their own , many while she sleeps.
code is memory
organic architecture: the codebase is a garden
An agent's output follows its input, and your codebase is its biggest input. The agent copies what it sees. So the old patterns in your code are the agent's memory.
3
changes a day to review, in 2024
300
changes a day now: a stream, like a living thing
🌱→🌿
new code grows around the frame you build
Concrete: your structure and checks are the frame that new code grows around. Weeds: workarounds, old code, and . The next agent copies them, and they spread. So the job becomes gardening: keep the frame strong and pull weeds early.
fences
each correction becomes a wall, not a sentence
ban what needs nuance
is easy to misuse, and agents misuse it. She does not teach the agent to use it well. She bans it in product code. That class of bug is gone, and nobody checks for it in review again.
if it needs good judgment, take it away
context in the folders
Agents kept loading code from the app's , and the screen got jerky. Fix: two folders named for the two parts, and a lint rule that bans links between them.
quick fixes considered harmful
Agents patched a design clash with , each with a comment saying why the patch was fine. Other agents copied the pattern. Result on her slide: 183 timers, and a slow app.
a comment can't enforce anything
comments are liabilities
She bans about 99% of comments. They go stale. People don't read them. Agents write excuses in them. Her lint errors tell the agent the root cause to fix instead.
A and a are fences. are signs on the fence. Agents also over-learn from signs: one small correction becomes a law they never break again.
verification
review the proof, not the code
Her code review is now mostly looking at proof the agent made: videos, screenshots, diagrams. Kinds of proof, from simple to deep:
: the agent runs the app and uses it. A gives you and the agent the same names for things. Small reusable command-line tools save tokens.
: a tool throws random input at a rule until it breaks.
: math that checks every path through a flow. She uses and . Her /statechart skill turns the model into a picture you can review.
Another engineer on her slide: 6 months ago she could not trust her agents. Now 70% of her daily tokens go to verification. Lauren says the same is true for her. None of this is new. It was too expensive before. Agents made it cheap: "a golden age of testing."
ok so what
what the investment bought
3,000
her PRs in one month
11,000
team PRs in one month
0.5%
, and falling
227
people sent a change in October
The app got faster while it grew, not slower. A new stable release goes out about once a day. After each release, a bot uses the whole app like a user, finds bugs, opens fixes and merges them itself. That only works because "pull requests tend to just be good by default."
"if your inner coding loop produces slop, then automating that loop just produces more slop."
The comes first. The factory comes last.
how does she template it?
the same garden, in every codebase
Your fences grew by chance, inside one program. Hers travel. In the talk she names two things: Dune, her app framework, and pstack, her plugin of skills. The details below come from pstack's public repo, not from the talk.
1. fences you install
Dune is "like for apps." It is a . It has her lessons built in as lint rules. A new app on Dune starts with the fences already up: no useEffect, main and screen kept apart.
for apps of the same kind
2. a machine that builds fences
pstack is a set of . They don't hold your fences. They hold the steps to build fences in any repo, from that repo's own mistakes.
for any codebase
what she runs, literally
/correct: turn repeat mistakes into walls. The agent reads recent commits, reverts, review comments, rules files and comments that explain workarounds. It groups mistakes into classes. "A class counts once it has happened twice." It fixes each class at the highest rung that works:
architecture→types→lint that names the fix→test→docs, last
Each new check must fail on a real past mistake, as proof it works. Exceptions go on the line itself, with a reason, an end date and a human's yes.
The rule table. The repo's agent file (like CLAUDE.md) holds a table: each rule, next to the check that enforces it. A rule with no check is a sign, and it stands out.
/create-verification-skill: a "verify this app" skill for each repo. It studies the repo: what a user touches, how the app starts, how an agent can drive it, what proof it can capture. Then it writes a repo-only skill that the next agent can use cold. /maintain-verification-skill keeps it current.
/no-comments. A helper agent (her name for it: "Comment Sicko") hunts comments. It deletes the dead ones. When a comment hides a workaround, it fixes the root cause.
/reflect. After a session, mine the chat for lessons. Lessons that need judgment go into skills. Anything a check could enforce goes on a list to become a check, "not into prose."
Principles as skills. Short rules the agent loads, such as "encode lessons in structure": "If the fix is structural, only use the structural fix. The instruction is the symptom."
So her template is a process, not a pile of rules. Each repo grows its own fences from its own mistakes. The process is the same everywhere.
retrofit or rebuild?
fences on an old garden vs. a new plot
retrofit a complex codebase
Proof first. Get verification running before big changes, so you can see when something breaks.
Mine the history. Old bugs and reverts are your list of mistake classes.
, don't ban at once. pstack: "if the pattern is already common, fail only when a change adds more." Then clean up old cases bit by bit.
Pull weeds on purpose. Delete old ways and dead code, or agents copy them. Move the users of an old path first, then delete it.
slower, but you keep what works
rebuild from scratch
Fences on day 1 are cheap. Nothing breaks the rules yet, so a strict ban costs nothing.
Start from a frame. Folder structure, doors, test gate, verify skill, rule table, no comments. That is what Dune gives her apps.
But you don't know the mistakes yet. Fences come from real corrections. Don't invent 50 rules on day 1. Add one each time a class repeats.
Risk: you lose quiet fixes hidden in the old code, and you rebuild bugs you had already solved.
fast and clean, if you carry the lessons over
how to choose
Rebuild only when the shape is wrong: the wrong parts own the facts, and no check can fix that. Fix everything else in place with ratchets. Lauren did both. She learned on the old app (Cursor), then put those lessons into a new frame (Dune) for the next one. The old app was where she learned. The new one shows what she learned.