Last week I deleted 3,000 lines of boilerplate and shipped two full features before lunch. Not because I got smarter — because I stopped doing the parts a machine does better.
Six months ago my week looked like this: write boilerplate, wire up routes, fix the same lint errors, repeat. I measured it once and nearly cried — ~20 hours a week on work that required a pulse but not a brain.
So I rebuilt my workflow around AI agents. Not "paste into ChatGPT" — an actual setup where specialized agents do scoped jobs and I stay the architect.
Here's the exact config. Steal all of it.
The mental model: you're a tech lead now, not an IC
The single biggest unlock wasn't a tool. It was a reframe.
Stop thinking "how do I get the AI to write this file?" Start thinking "how would I delegate this to a junior who's fast but needs clear scope?"
That one shift is what turns AI from a fancy autocomplete into a team.
My setup has three layers:
- A planner — breaks a task into steps, never writes code
- Workers — each handles one scoped job (a screen, a route, a test)
- A reviewer — reads the diff and tries to break it
The setup
I use Claude Code as the harness because it supports subagents natively, but the pattern works with any agent runner.
1. Define specialized subagents
The trick is narrow scope. A generalist agent drifts. A specialist with one job stays sharp.
---
name: screen-builder
description: Builds a single React Native screen from a spec. Does not touch routing or state.
tools: Read, Write, Edit, Grep, Glob
---
You build ONE screen at a time. Match the existing component style exactly.
Never invent new patterns — grep for an existing screen and mirror it.
Return the file path and a one-line summary. Nothing else.
---
name: code-reviewer
description: Reviews a diff adversarially. Tries to find bugs, not to praise.
tools: Read, Grep, Glob, Bash
---
You are a skeptical senior engineer. For every change, ask:
"What input breaks this?" Report only real issues with file:line.
Default to "this is wrong" and make the code prove you otherwise.
2. Keep context tight
Agents get dumb when drowning in context. My rules:
- One agent = one task = one clear "done" condition
- Agents return conclusions, not file dumps
- The planner never sees raw code; the workers never see the roadmap
3. The daily loop
Me: "Add a repair-booking confirmation screen"
Planner: → 4 steps, names the 3 files to touch
Worker 1: → builds the screen (mirrors existing screens)
Worker 2: → wires the route
Reviewer: → finds 2 edge cases I'd have shipped
Me: → approve, commit
Total time: 18 minutes for something that used to eat half a day.
Real numbers (no vibes)
I tracked two weeks before and after on my side project, a repair-booking app:
| Task | Before | After |
|---|---|---|
| New screen (UI + wiring) | ~2.5 hrs | ~25 min |
| Boilerplate/CRUD | ~3 hrs/wk | ~20 min/wk |
| Code review pass | ~4 hrs/wk | ~1 hr/wk |
| Chasing lint/type errors | ~2 hrs/wk | near zero |
Add it up and it lands right around 20 hours a week given back.
The mistakes that almost made me quit
I'm not going to pretend this was smooth.
- Giving one agent the whole app. It confidently rewrote working code. Fix: scope every agent to one job.
- Trusting the diff without reading it. An agent "fixed" a bug by deleting the test. Fix: the adversarial reviewer + I always read the final diff.
- No "done" condition. Agents would gold-plate forever. Fix: every task ends with a concrete, checkable result.
The reviewer agent is non-negotiable. An agent that writes code and an agent that tries to break it catches things a single pass never will.
Would you trust this in prod?
That's the real question. My answer today: yes for scoped work, no for architecture. The judgment calls are still mine. The typing isn't.
What would it take for you to hand an agent access to your codebase? 👇
If this helped, drop a ❤️ and follow — next post is my full reviewer-agent prompt that's caught 40+ bugs before commit.
Top comments (0)