Now live on Amazon Kindle
Claude Code: Building Production Agents That Actually Scale
Claude Code is powerful enough to change how software teams work. It is also powerful enough to make a mess if you treat it like a clever autocomplete box.
This book is for engineers, architects, and tech leads who are past the demo stage. You have seen agents write code. Now you need them to work inside real repos, real review processes, real constraints, and real production risk.
The core argument is simple: most Claude Code failures are not model failures. They are operating-loop failures.
Get the Kindle edition on Amazon Read the free production checklist Prefer LeanPub? See the two-book bundle
Who this is for
This is not a beginner prompt book.
It is for people who need Claude Code and agentic coding to survive contact with team workflows:
- principal engineers and architects introducing AI coding agents
- engineering managers who need guardrails instead of theatre
- platform teams designing internal agent workflows
- developers using Claude Code on serious codebases
- teams in regulated, customer-facing, or money-adjacent systems
If your agent can read files, call tools, edit code, run shell commands, touch secrets, or trigger CI, you are operating a production system. The book treats it that way.
The problems the book attacks
Most teams do not fail because they forgot one magic prompt. They fail because the agent is dropped into a messy operating environment with unclear boundaries.
The book focuses on the parts that demos skip:
- permission modes and per-tool blast radius
- working-directory discipline and repo boundaries
- MCP servers and tool governance
- hooks, policies, and approval gates
- evals that catch regressions before they hit the repo
- observability for agent runs and code changes
- cost controls and runaway-loop prevention
- rollback notes, review records, and audit trails
- human review that still means something
The boring controls are the product. The model is only one component.
What you will learn
By the end, you should be able to design a Claude Code workflow that answers uncomfortable production questions:
- What exactly can the agent read, write, delete, or call?
- What happens when it does the right thing in the wrong directory?
- Which actions are safe to automate, and which need a human gate?
- How do you know an agent-generated diff is good enough to merge?
- What evidence do you have when something breaks later?
- How do you scale agent use without turning review into rubber-stamping?
That is the difference between a toy agent and a team system.
Draft table of contents
The Kindle edition is live on Amazon, with the LeanPub edition still available for readers who prefer that format. The book covers:
- Claude Code is not the product: the operating loop is
- Permission modes, tool scope, and blast radius
- Working directories, repo hygiene, and safe sandboxes
- MCP as an integration layer, not a magic wand
- Hooks, policies, and approval gates
- Evals for agentic coding workflows
- Observability: flight recorders for agents
- Cost controls and runaway-loop prevention
- Human review without rubber-stamping
- Rollback, audit notes, and incident archaeology
- Team adoption patterns for real engineering groups
Why I am writing it
I have spent a long time building software where the boring parts matter: review, auditability, risk, production support, and being able to explain why a system behaved the way it did.
Claude Code changes the speed of software work. It does not remove engineering responsibility. If anything, it makes the responsibility sharper because one enthusiastic agent can now move faster than the controls around it.
That tension is where the book lives.
Start here
If you are evaluating Claude Code for real team use, start with the free checklist:
Claude Code production readiness checklist
If the problem already feels familiar, get the Kindle edition:
Get Claude Code: Building Production Agents That Actually Scale on Amazon Kindle
If you also own security or risk
If you are responsible for both engineering delivery and security review, do not treat this as two separate conversations. Claude Code decides what an agent can do in the repo. Security decides what the agent should be allowed to do around the business.
The bundle connects those halves: build the agent, secure the agent, and keep the evidence.
Related writing
- Claude Code Permissions: The Production Mistake That Bites Later
- Claude Code Agents Need a Flight Recorder
- Claude Code Is Not the Product. The Production Loop Is.
FAQ
Is this only for Claude Code?
Claude Code is the center of the book, but many of the operating patterns apply to Codex-style and other agentic coding tools: permissions, observability, evals, review, rollback, and tool governance.
Is this for beginners?
Not really. You do not need to be an AI researcher, but the book assumes you understand software delivery and want practical operating patterns for agentic coding.
Does it cover MCP?
Yes. MCP matters because it turns the agent into an operator with tools. That is useful, and it changes the risk model. The book treats MCP as part of the production surface, not as a novelty.
Is the book finished?
It is live on Amazon Kindle under ASIN B0GXL71ZPZ. The LeanPub edition remains available for readers who prefer LeanPub updates.