poteto worksheet

how do i trust my agents more?

the potato pyramid

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
agent writesslop code humanverifies it issues found

high trust

you look at proof, not code
agent writesgood code agentverifies it issues found

"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.

65,624 1,229 before today

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:

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

  1. /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.
  2. 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.
  3. /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.
  4. /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.
  5. /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."
  6. 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.