Agents are everywhere now. They write code, answer customers, process documents, make decisions. The developers building these systems — and the developers using them every day — are figuring it out as they go. Some lessons come from experience. Others come from production failures that could have been avoided.

This book is 97 of those lessons.

Each essay stands alone. No dependencies between them, no required reading order. Pick the one that matches where you are right now and start there.

Part 1 — Working with Agents covers the fundamentals: why agents are probabilistic systems rather than deterministic ones, why context matters more than capability, and how to stop anthropomorphizing failures and start debugging them. These essays are for anyone who interacts with agents and needs a clear mental model of what's actually happening.

Part 2 — Prompting as Engineering treats prompts as what they are — architecture. Versioning, testing, examples over instructions, negative constraints, system prompts as contracts. The craft of writing prompts that hold up across edge cases and model updates.

Part 3 — Building Agentic Systems gets into infrastructure: observability, evals, tool design, idempotency, state management, retry loops, kill switches, and the cost model that shapes every design decision. The essays for developers who own agent systems in production.

Part 4 — Agents in the Real World addresses the messy realities — users who break things in ways you can't predict, latency as UX, security at the context window boundary, prompt injection, and the hard question of scope. When to build one agent and when to build three.

Part 5 — Mindset is about the developer, not the system. How agentic programming changes what expertise means, why writing skills matter more now, why discomfort with uncertainty is a liability, and what it means to be responsible for output you didn't write line by line.

Part 6 — The Developer as User speaks to anyone using an AI coding assistant as a daily tool. How to give it context, how to stay in charge of architecture, how to break large projects into sessions that build on each other, and why reading every line of generated code is non-negotiable.

The principles that matter most cut across all six parts: these systems are probabilistic, context is everything, you are responsible for what they produce, and the quality of your thinking determines the quality of their output.

Start anywhere.