Lauren Tan built the React compiler at Meta, led teams at Netflix, and now works at Cursor building Grokbot. Last month she merged close to 1,000 PRs. Agents auto-merged most of them. She wakes up to 20+ commits in main that she didn't touch.

She pulled this off by designing her project so bad code can't survive, no matter which agent writes it.

More useful to me than any collection of Skills or prompt templates.

Where most people get stuck

You hand a task to an agent. It writes code. You launch the app to check. Something's wrong, you screenshot it and throw it back. Error in the console, paste the log. Performance issue, open DevTools yourself.

The agent writes. You verify. You never leave that loop.

Two agents running at once? Manageable. Five? You fall behind. Ten? You become the bottleneck on your own pipeline.

You outsourced writing code. You kept verifying code.

Hand verification to the agent too

Lauren does this at scale. I've been doing it on smaller projects for months.

Before:

Add search to history.

I'd run the app myself, find bugs, paste errors back, wait for another attempt.

Now:

Add search to history. Launch the dev build. Create 3 test records. Search one keyword. Confirm only matches appear. Clear the keyword, confirm the full list returns. Test Chinese, English, and empty input. If any step fails, keep fixing until all pass.

The agent writes code, runs the feature, and proves it works. If it can't prove it, it keeps fixing.

For web projects, give agents Chrome DevTools Protocol. They open pages, click buttons, read DOM, grab Console and Network traces. For CLI tools, have the agent execute commands and validate exit codes.

Give the agent a project map

Agents burn 10 minutes figuring out where a feature lives. Lauren built a feature map for Cursor's agent window. Without it, agents "just flailed around," unable to navigate to the right screen.

## History Search

Entry: Main window -> History tab
Search box: top of page
Related code: src/features/history/

Verification:
1. Create 3 records with different content
2. Search one keyword, confirm only matches show
3. Clear keyword, confirm full list returns

Known issues:
- Must be case-insensitive
- Empty keyword must not filter the list

Someone reports "search is broken." The agent opens the map, finds the code path, reproduces, fixes, and verifies. Zero orientation time.

Let CI block bad code. Stop relying on memory.

You write 50 rules in AGENTS.md. Agents forget them. You tell an agent "don't import across module boundaries" three times. The fourth time, it does it anyway.

Turn rules into hard constraints:

  • Lint rule catches it? Ship the lint rule.
  • Type system rejects it? Let the compiler say no.
  • CI can fail on it? Let CI fail.

Agents take the shortest path to complete a task. Design your project so the shortest path leads to correct code. Block wrong paths at the toolchain level.

Statically typed languages help here. A compile error teaches an agent more than 10 lines of instructions in a markdown file.

Every mistake builds the system

An agent makes a mistake. You can re-prompt and move on. Or you can ask:

  • Can I add this to a verification step?
  • Can I write a lint rule for this?
  • Can CI block this pattern forever?

One guardrail per mistake. After three months, your project rejects entire categories of bugs before any human sees the PR.

New models and tools change every few months. Guardrails you write accumulate.

Don't start by launching 100 agents

Lauren said it: if you don't trust one agent to complete a task with verification, running 100 gives you 100 PRs to review and a large token bill.

Start with one agent completing one task with full verification. Add a feature map when navigation wastes time. Add CI constraints when the same bug appears twice. Then scale.

Sources