My AI-native dev loop: agents build, I decide
Most of the code I ship now is written by agents. That didn't make the job smaller. It moved it. Less typing, more deciding.
Here is the loop I run on every change.
1. Spec (me)
I write down what done looks like before an agent touches anything: the behaviour, the edge cases, what must not change. A vague spec gets you confident, wrong code, faster than ever.
2. Build (agents)
Claude Code does the implementation: the boilerplate, the wiring, the first pass at tests. For anything big I split it into tickets and run agents in parallel, each in its own git worktree.
3. Review (me)
I read the diff like I'd read a teammate's PR. Does it solve the right problem? Did it touch more than it needed to? Is there a simpler version? This is where most of my time goes now, and it should.
4. Test gate (agents)
Tests, lint and type checks run before anything merges. Agents are good at fixing what the gate catches. They are bad at noticing what nothing checks, which is why the gate has to exist.
5. Ship (me)
A human decides it goes out. Every time.
What changed for me
- Scope per engineer went up. I can carry a backend, a frontend and an integration at once, because the slow part, writing it all out, is not mine anymore.
- Taste matters more. When code is cheap, knowing what not to build is the skill.
- Small diffs win. Agents will happily write 400 lines where 40 do. Pushing back on that is half of review.
The tools change every few months. The split, where machines do the volume and people own the judgment, is the part I expect to last.