For working software engineers
Stop re-explaining your codebase to a coding agent.
A 104-page field manual for running AI coding agents on production work, covering Claude Code, Codex CLI and OpenCode: what to put in the prompt, what to put in the memory file, and how to give the agent a check it can run so you are not the verification loop.
A paid digital book, not software: one 104-page PDF, sold once for $79. Independent publisher, not affiliated with Anthropic or OpenAI.
Instant access after checkout, plus a link emailed to you. Payment is handled by Stripe. 60-day refund, no questions asked. Or read chapter nine first, no email needed.
- 104 pages, 12 chapters
- 51 paste-ready prompts
- Verified against the vendor docs, July 2026
- Edition updates included
What's in the box
One PDF. Five things you will actually use.
"104-page PDF" undersells it. Here is what the file contains, in the order you will meet it.
The field manual 12 chapters
From first run to production habit: the context you owe the agent, the anatomy of a prompt that works, the core loop, tools and permissions, cost and models. Each chapter names the decision, shows the artifact, and states the failure mode it prevents.
The prompt library 51 prompts
Organised by the job you are doing: bootstrapping, debugging, refactoring, review, migrations. Every prompt is copy-pasteable as written, with a note on the one line you should change for your repository.
Weak and strong, side by side 40+ annotations
Every prompt is printed next to the weaker version of the same request, with an explanation of what the difference buys you. The contrast is the teaching; the prompt is the artifact.
The failure-mode index 28 entries
The recurring ways agent sessions go wrong, each with the tell that lets you spot it, the cause underneath, and the fix. Built to be searched at 11pm, not read cover to cover.
The quick reference Appendix
The prompt template, the commands by tool, the verification script, the memory-file test, five-minute triage, the prompt finder and the ten rules, gathered so you can print it.
Edition updates included Permanent
These tools change monthly. Updates to this edition are included in the price and arrive by email at the address you check out with, with a changelog that records what moved and when.
Real pages, not a mockup
This is what the inside actually looks like.
Every image below is a render of the real PDF at full resolution. Typeset in Source Serif on a 126mm measure with a wide margin for asides, so it reads like a book rather than a slide deck exported to paper.
The problem
The agent is not the bottleneck. The setup around it is.
You have a coding agent open in three panes. You have spent forty minutes describing the module boundaries it could have read for itself. It produced something plausible, touched a file you did not ask it to touch, declared the work done, and the test suite says otherwise. So you read the diff line by line, which is the work you were trying to delegate.
Nothing in that sequence is a model problem. It is a missing project memory file, a prompt that named a symptom instead of a reproduction, and a session with no check the agent could run on its own. Those three gaps produce most of the bad sessions engineers report, and all three are fixable in an afternoon.
What it is
An operating manual, not a prompt pack.
Prompt packs go stale the week the tool ships a new flag. This book is organised around the parts that have not changed since the first CLI agent shipped: context is finite, specificity beats phrasing, and an agent is only as good as the feedback loop you hand it.
Each chapter names the decision, shows the artifact (a prompt, a
CLAUDE.md, a hook, a subagent definition), and states the failure mode it
prevents. Where the three tools differ, there is a comparison table rather than a
paragraph of hedging.
Read the top-level layout of this repo, the package manifest, the CI config, and the three most recently modified source files. Then write CLAUDE.md containing only what a competent engineer new to this codebase could not infer in five minutes: the build and test commands that actually work, the module boundaries, the two or three conventions we enforce that are unusual, and anything load-bearing but surprising. Do not restate the directory tree. List uncertainties at the bottom under "Open questions".
One of fifty-one prompts printed in full. Copy it, run it, keep the output in version control.
What's inside
Twelve chapters, 104 pages.
The full table of contents. Nothing here is a placeholder, and nothing is padded to hit a page count.
- 01
What actually changed
You have used autocomplete. You have used a chat window. An agentic coding tool is neither, and the habits you carried over from both are why your first week feels worse than it should.
- 02
Pick your cockpit
Four tools, three of them terminal coding agents and one of them something else entirely. The differences that matter are not the ones the marketing pages lead with.
- 03
Your first hour
Set up, sign in, and get one real, reviewed, committed change out of the agent before lunch. Then the two keystrokes that get you out of trouble, because you will need them today.
- 04
The context you owe the agent
A project memory file is not documentation. It is a tax you pay on every request for the life of the project, so the only things that belong in it are the ones that change what the agent does.
- 05
Anatomy of a prompt that works
Four components appear in every prompt that reliably produces work you can merge: a goal, the constraints, the verification, and the output contract. Miss one and you can predict which way it goes wrong.
- 06
The core loop
Explore, plan, execute, verify, commit. Five phases, one of which most people skip, and the skipped one is why their diffs are unreviewable.
- 07
The prompt library
Fifty-one prompts organised by the job you are doing. Every one is copy-pasteable as written, and every one has a note on the line you should change for your repository.
- 08
Tools, permissions, MCP, and hooks
How to give the agent more reach without giving it more rope. Decide what it may touch, then what it can reach, then what must happen every time regardless of what it decides.
- 09
Verification
The one habit that separates a session you have to watch from one you can walk away from. Everything else in the book is optimisation; this is the load-bearing wall. Readable in full on the web.
- 10
Scaling up
Subagents, worktrees, headless runs and parallel agents. Two of these pay for themselves immediately; the other two pay off in specific circumstances and are theatre everywhere else.
- 11
Pitfalls
Twenty-eight named failure modes, each with the tell that lets you spot it, the cause underneath, and the fix. Most of these will happen to you; the point is to recognise them in minutes rather than weeks.
- 12
Making it a habit
Model choice, the money, getting a team onto this without a mandate, the things you must never hand over, and how to avoid becoming an engineer who can only work with an agent.
- App.
Quick reference
The prompt template, the commands by tool, the verification script, the memory-file test, five-minute triage, the prompt finder and the ten rules. Print it and keep it next to your keyboard.
One technique, in full
Describe the symptom, not the fix.
This is a complete guideline from chapter five, printed here exactly as it appears in the book. If it is useful on its own, that is the point.
The most common weak prompt is a summary of a conclusion you have already reached. "Fix the login bug" hands the agent your diagnosis without the evidence that produced it, so it either accepts a wrong theory or spends its first ten tool calls rebuilding context you already had.
Weak
fix the login bug
Strong
users report that login fails after session timeout. check the auth flow in
src/auth/, especially token refresh. write a failing test that reproduces the issue,
then fix it
Three things changed. The symptom is stated as an observation rather than a verdict, so the agent can disagree with your theory. A likely location is supplied, which bounds the search without forbidding it from looking elsewhere. And "write a failing test that reproduces the issue" converts an open-ended request into one with a checkable finish line: if the test does not fail before the change and pass after it, the work is not done, and the agent can determine that without asking you.
The same three moves generalise. Scope the task by naming the file and the scenario. Point at the source that can answer the question, including git history. Reference an existing pattern in the codebase by filename instead of describing it. None of this is prompt phrasing; it is supplying the four facts the agent would otherwise have to guess.
The nuance
Vague prompts still have a place. When you are exploring and can afford to course-correct, "what would you improve in this file?" surfaces things you would not have known to ask about. Specificity is for work you need to land, not for every message you send.
The alternatives
Four ways to learn this. Three of them cost more than $79.
| Option | Cost | Time to useful | The catch |
|---|---|---|---|
| Vendor docs and YouTube | No cost | Weeks of digging | The facts are all there, unordered and undated, with no failure modes and nobody telling you which paragraph changed last month. |
| Cohort courses | $500 to $1,000 | Scheduled weeks | Credible names charge this for a cohort. You get community and deadlines, and hours of video you cannot grep at 11pm. |
| Prompt dumps | Under $30 | Minutes | The sub-$30 tier is AI-generated prompt lists with no sourcing and no ratings. Stale on arrival, and nobody stands behind a refund. |
| This playbook | $79, once | One evening | It is still a book. It cannot run the sessions for you, and it makes no outcome promises. You do the work; it makes the work shorter. |
Fit check
This will not suit everyone, so here is the honest split.
Buy it if
- You already write software professionally and ship to production.
- You have used a CLI coding agent at least a few times and it has been uneven.
- You want the habits and the artifacts, not a list of prompts to paste blindly.
- You are the person on your team who will set the conventions everyone else inherits.
- You would rather read 104 dense pages in one evening than watch nine hours of video.
Skip it if
- You are learning to program. This assumes you can read a diff and run a test suite.
- You want a no-code or vibe-coding path to shipping an app without understanding it.
- You are looking for career or income advice. There is none here.
- You need step-by-step video. This is a PDF, and it is dense on purpose.
- You want coverage of model internals, fine-tuning, or building your own agent framework. Different book.
Before you decide
Read the verification chapter first. It is the full chapter, not a teaser.
Chapter nine, on verification, is published in full as a web page: no email required, no gate, nothing to dismiss. It is roughly nine pages of the book. If it does not change how you run your next session, do not buy the rest.
Pricing
One payment. Yours permanently.
No subscription and no recurring charge. Updates to this edition are included in the price and arrive by email. One honesty note: if you buy this guide, we will offer you the other playbook exactly once after checkout, at the bundle difference. That is the complete upsell; there is no third thing.
This guide
$79 one-time
The Agent Playbook for Software Engineers.
- 104-page PDF, 12 chapters
- 51-prompt library, weak and strong versions
- Failure-mode index and command reference
- Updates to this edition included
- Instant access plus emailed link
Both guides
$149 one-time
Both playbooks: engineering and ecommerce operations. $9 less than buying them separately.
- Everything in the engineering guide
- The Agent Playbook for Ecommerce Operators
- Updates to both editions included
- Useful if you build the tools other teams operate
Buying for a team? Five seats of both playbooks on one invoice:
Each guide is a paid digital book: one PDF, sold once. It is not software, and this page sells nothing else. Prices are in US dollars and shown before checkout. Payment is processed by Stripe; we never see your card details. Sales tax or VAT, where it applies, is calculated at checkout and shown before you pay.
Sixty days, no questions asked.
Email support@anodizelabs.com within 60 days of purchase and we refund you in full. You do not have to explain why, you do not have to delete the file, and there is no form. Refunds are issued to the original payment method and typically clear in five to ten business days.
The full policy is on the refunds page.
Not buying today
Take the five-day email course instead.
One technique from this book per day for five days, by email. The same techniques you just saw on this page, in full. On day five we make the case for the book, once, and then the emails stop. No weekly newsletter, and the unsubscribe link works from the first message.
- Day 1 Describe the symptom, not the fix
- Day 2 Give the agent a check it can run
- Day 3 Pay the memory tax once
- Day 4 The phase everyone skips
- Day 5 The failure modes have names, and the offer
Questions
Answers, including the awkward ones.
What exactly do I get?
One PDF file, 104 pages, 12 chapters plus a command reference appendix. It is not a video course, not a Notion template, and not a members' area. After checkout you land on a page with your file, and the same link is emailed to you.
Is this a subscription?
No. It is a single payment of $79. There is no recurring charge and no trial that converts. After checkout we will offer you the other playbook once, at the bundle difference; declining costs nothing and changes nothing about your order.
Which tools does it cover?
Claude Code, Codex CLI and OpenCode, with comparison tables where their behaviour differs. The reasoning chapters apply to any CLI coding agent. It does not cover IDE autocomplete tools or browser-based chat assistants.
Will it be out of date in three months?
Parts of it, yes. Flags change. That is why the book is organised around the mechanics that hold across tool versions, and why version-sensitive details live in margin notes rather than in the body. Updates to this edition are included in the price, and the changelog records what changed and when.
Is any of it just the official docs reworded?
Where a primary source says something well, it is quoted, attributed and set apart from our own text. The value is in the ordering, the failure modes, the artifacts you can copy, and the places where the documented behaviour and the observed behaviour differ.
Do I need an expensive plan to use any of this?
No. Everything in the book works on the standard paid tier of any of the three tools, and chapter eleven is specifically about spending less.
Can I expense it?
Yes. Stripe emails a receipt with your name and, if you enter one at checkout, your company details and tax ID. For a proper invoice, email support@anodizelabs.com with your order reference.
Can I share it with my team?
The individual licence is for one person. The team tier covers five people. Sharing one copy across a team is not permitted, and each purchased PDF carries the buyer's licence line on every page.
What if I buy it and it is not what I expected?
Ask for a refund within 60 days and you get one. No questions, no form. See the refund policy.
Are you affiliated with Anthropic or OpenAI?
No. Agent Playbooks is independent and has no affiliation with, endorsement from, or sponsorship by Anthropic, OpenAI, or any other tool vendor named in the book.
Read chapter nine, then decide.
If the sample chapter is useful, the other eleven are built the same way. $79 once, instant access, and 60 days to change your mind.
104-page PDF · one-time payment · instant access · 60-day refund