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 pushed over a CI bot’s commit and resolved the conflict with “keep ours” — silently discarding newer build artifacts. A written rule about checking the remote existed. It had even been read that session. It didn’t hold, because written rules compete for a model’s attention, and attention loses as the context grows.
The fix wasn’t a sterner rule. It was a small pre-push hook that fetches the remote and refuses to push while the branch is behind. Its header comment reads: “Memory alone did not hold this — so it is enforced here.” The mistake has been impossible ever since.
That’s the shape of the whole system: stop asking the agent to remember, and build the thing that makes forgetting impossible. The playbook maps where that’s possible, where it isn’t, and what to do in the gap — with the working files included. (That hook ships in the toolkit.)
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. Tool-agnostic: works with any agent CLI, survives model rotations. No tool tutorials, no prompt tricks.
The toolkit — 13 working files
Three guard hooks (pre-push guard, destructive-operation confirm, evidence gate), 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. Every hook in it was born from a named incident; the rest is what those incidents distilled into.
The graveyard chapter
The part nobody publishes: three verification systems that died in production — why each made sense, how it failed, and what replaced it. Negative results are the most expensive knowledge there is. They’re included so you don’t pay for them twice.
“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?
- Any agent CLI — Claude Code, Codex, Cursor, OpenCode, whatever ships next. The disciplines are about the loop around the agent, not the agent itself; the toolkit is plain bash and plain text.
- 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.