By Jacob Verhoeks, March 2026
The cost of building software has collapsed. Claude Code ships features in minutes. Codex opens pull requests while you sleep. Cursor and Windsurf turn IDEs into conversation partners.
The cost of knowing what to build has not changed at all.
That gap is where The Art of Agents lives. Thirteen chapters mapping Sun Tzu's Art of War to the discipline of building agentic AI systems that actually work in production.
The Thesis
You don't spec then build. You build to discover the spec.
When agents can scaffold a full-stack application in an afternoon, the question is no longer "can we build this?" It's "should we build this, and how do we know if it worked?"
The answer is the specification. But the spec comes after the experiment, not before it. You build a quick version, expose it to real users, collect feedback, and then write the spec that captures what you actually learned. The spec is not the starting gun. It's the trophy you earn by running the race.
The Thirteen Chapters
Each chapter opens with a Sun Tzu principle, teaches the concept through real examples and anti-patterns, and closes with a field report drawn from actual experience.
| Chapter | Sun Tzu | Modern Application |
|---|---|---|
| I | Laying Plans | Spec-Driven Design |
| II | Waging War | Token Economics |
| III | Attack by Stratagem | Composability Over Monoliths |
| IV | Tactical Dispositions | Defence Through Schema |
| V | Energy | The Multiplier of Tool Design |
| VI | Weak Points and Strong | Observability as Intelligence |
| VII | Manoeuvring | Adaptive Orchestration |
| VIII | Variation in Tactics | Multi-Agent Patterns |
| IX | Army on the March | Deployment and Operations |
| X | Terrain | Navigating the Enterprise |
| XI | Nine Situations | Failure Modes and Recovery |
| XII | Attack by Fire | When NOT to Use AI |
| XIII | Use of Spies | Feedback Loops and Continuous Learning |
Five Principles That Matter Most
1. The spec is the cause of design, not its effect.
A prompt is a wish. A spec is a contract. The prompt tells the agent what you want. The spec tells the entire system what correct behaviour looks like. You can change the model and the spec should still hold.
AWS launched Kiro with spec-driven development at its core. The idea was sound, but early adopters reported it felt like a straitjacket. OpenSpec takes a different approach: the spec is a living document that grows with the code, not a gate you pass through.
2. Design for distrust.
What is not permitted is forbidden. Don't rely on the model to behave correctly. Define the contract. Enforce it mechanically. Tool whitelisting, schema validation, output parsing, hard limits on tokens and iterations. Your agent will improvise. Your system should not let it.
3. The model's job is to decide, not to compute.
A bad tool returns 5,000 rows of JSON and expects the model to find the answer. A good tool accepts precise parameters, does the heavy lifting in deterministic code, and returns only what the agent needs to reason about. When the tools are right, the agent appears brilliant. When the tools are wrong, no amount of prompt engineering can save it.
4. Know when NOT to use an agent.
LLMs are fire. Powerful in the right conditions, catastrophically wasteful in the wrong ones. If a SQL query will do, write the query. If a rule engine will do, write the rules. The architect who puts an LLM in every code path is the general who sets fire to his own supply lines.
5. The learning is the product.
Every experiment enriches the commons. A composted experiment produces a learning. That learning feeds the next idea. The cycle accelerates. Dead experiments are the richest soil. The code is gone, but the learning persists. And learnings, unlike code, get more valuable over time.
The Cycle
Specs drive design. Design produces agents. Agents produce traces. Traces inform evaluation. Evaluation updates specs. Each pass makes the specs sharper, the agents more capable, the tools better calibrated.
This is not continuous deployment. This is continuous learning.
Three Decisions, No Waste
Every experiment ends with a human decision:
- Promote: the idea proved out. Generate a full spec, build the production version.
- Pivot: wrong angle, but something is there. Revised hypothesis, new experiment.
- Compost: the idea did not work. The code is discarded. The learning persists.
A composted experiment with a reused learning is more valuable than a promoted experiment that taught nothing new.
The Anti-Patterns
Thirteen chapters, thirteen ways to get it wrong:
- The Vibes-Driven Agent -- no spec, no acceptance criteria. The agent guesses your intent.
- The Full-Context Agent -- loads everything into context "just in case." Slow, expensive, unfocused.
- The God Prompt -- one 4,000-word prompt handling every responsibility.
- The Trusting Orchestrator -- no validation between agents. Hallucinations propagated as fact.
- The Firehose Tool -- returns everything, lets the model sort it out.
- The Black Box Agent -- works in demo, fails in prod, nobody knows why.
- The Premature Swarm -- five agents where one would do.
- The LLM Hammer -- everything looks like a reasoning problem.
If you recognise three or more, the book is for you.
Read the Preview
The full book is in early access. The preface and Chapter 1 (Laying Plans: Spec-Driven Design) are available as a free preview.
Download the free preview (PDF) -- Preface + Chapter 1, covering the Five Constants of Agentic Design, why prompts are not specs, and the OpenSpec format.
Explore the full framework -- The interactive website with all thirteen chapters, the manifesto, the cycle, and the fundamental inversion.
Get notified when the book launches -- Visit the website, click "The Book" tab, and hit "I'm Interested."
Jacob Verhoeks is a principal engineer building data platforms and agent architectures. The Art of Agents grew out of a framework mapping Sun Tzu's 13 chapters to agentic AI principles, which became an essay, then a website, then this book.
Top comments (0)