Your agent says “done.”
Make it prove it.
A field manual and working toolkit for engineers who run AI coding agents on real codebases — how to turn plausible-looking diffs into changes you can actually trust, without reading every line yourself.
Launching soon. One email at launch, occasional field notes before it. Unsubscribe anytime.
The expensive part isn’t the code anymore
An agent produces a plausible diff in four minutes. Knowing whether that diff is right — whether it does what you asked, doesn’t break what you didn’t mention, and won’t fail silently on the input you forgot to name — takes twenty. That’s not a feeling: when the METR research group measured it, experienced developers using AI assistants came out 19% slower on real tasks — much of the lost time going to reviewing and correcting the output.
And the failures repeat. You corrected the agent on Tuesday. On Friday — different session, same agent — it makes the same mistake with the same confidence. Everything you taught it lived in a conversation that no longer exists.
More model, more autonomy, more parallel agents — none of it fixes this. The only thing that raises your ceiling is making verification cheaper. That’s a learnable, buildable skill, and it’s the entire subject of this book.
One idea from inside — free
An agent of mine pushed over a CI bot’s commit. Nothing exotic happened. A CI job with write access had committed to the same branch, my local ref was behind, and when the agent hit the conflict it kept “ours”, writing the older files back over the newer ones. Checking the remote was something I was supposed to remember. Nothing was checking it: no rule, no guard, nothing written down.
So I stopped relying on remembering. Now a guard sits in front of my agent’s shell: before any push it fetches the target branch, and if the remote is ahead of my local HEAD it blocks the command and tells the agent to integrate first. The comment at the top of that file reads: “Memory alone did not hold this — so it is enforced here.” A guard can exit 1. An instruction can only ask. It doesn’t close every way to the same damage. I went looking, and I found one that gets around it. It’s a narrower promise than “this can’t happen again”, and it’s the one I can keep.
That’s the shape of the whole system: stop asking the agent to remember, and put the check in front of the command. The playbook maps where that’s possible, where it isn’t, and what to do in the gap — with the working files included. (A version of that guard ships in the toolkit, as a git pre-push hook.)
What you get
The book — 8 chapters
Five disciplines — postmortems, the independent judge, behavioral proof, risk gates, durable knowledge — plus the wiring and the graveyard. The complete verification loop around every unit of agent work: what to check before, during, and after, and the calibration tables for when heavy checks pay off and when they’re a tax on your velocity. None of the five depends on which CLI you run. No tool tutorials, no prompt tricks.
The toolkit — 13 working files
Three guard hooks, three adversarial reviewer prompts, incident and knowledge templates, pre-ship checklists, and a weekly one-pager for a 5–10 hours-a-week budget. Plain bash and plain text — drop into any repo.
The graveyard chapter
Three things I built to check agent work, then stopped running: per-task acceptance contracts, an instruction file with forty-odd rules in it, and gates on every change. Why each made sense, what went wrong, and what replaced it.
“Couldn’t I just prompt this out of a chatbot?”
The ideas are public — feedback loops, reviews, guardrails. Any model will happily list them. What it can’t give you is the calibration: which checks pay for themselves on which kinds of change, which ones fail quietly, which ones die of their own overhead after a month. That knowledge isn’t reasoning — it’s scar tissue. It only comes from burning real diffs on real codebases and writing down what actually held.
This book is that record, organized into a system you can install in an afternoon. You could rebuild it yourself from first principles. The cover price is cheaper than the incidents.
Who this is for
For you if: you run a coding agent — any of them — on code that matters, and you’ve shipped at least one “done” that turned out not to be. You want more autonomy from your agent without paying for it in review time and 2 a.m. surprises.
Not for you if: you’re still learning to drive an agent (the vendors teach that well, for free), or you want a promise of hands-off autonomy. The honest promise is better: a ceiling you raise deliberately, instead of discovering it in production.
“Generation is solved. Verification, judgment, and direction are the new craft.”
That craft is this book.
Get it at launch
- The full book — PDF plus plain markdown files you can grep and keep in your repo
- All 13 toolkit files, ready to drop in
- Buy once — every future edition free
- 30-day no-questions refund
Priced as a book: read it in a weekend, install it in an afternoon.
Questions
- Which agents does it cover?
- The disciplines are about the loop around the agent, not the agent itself, so they do not depend on one CLI. The adapters that ship with it are for Claude Code and
AGENTS.md; the rest is plain markdown you adapt yourself. - What format is it?
- PDF for reading, plus the same content as plain markdown — greppable, diffable, yours to keep in a repo. Buy once and every future edition is free.
- How is this different from the free guides?
- Free material teaches you to drive the agent, and teaches it well. This is the layer they stop at: how to verify what it did, cheaply enough to do it every time — with the working files, and the failures included.
- I already use agentscar — is this the same thing?
- agentscar (free, open source) captures incidents — one discipline of five. The playbook is the full system around it, plus the toolkit and the calibration tables.
- Refunds?
- 30 days, no questions asked. Payments and refunds are handled by Paddle, the merchant of record.