Agentic Coding: Building Reliable Software with AI Agents

AI can already write, and rewrite, an entire feature while you get coffee. That's not the hard part anymore. The hard part is knowing whether to trust what it just did — and building the engineering discipline that lets you find out.

Agentic Coding: Building Reliable Software with AI Agents is a systematic guide to that discipline. It isn't a tutorial for any one tool, and it won't walk you through a particular CLI's flags — those change every few months. Instead, it gives you the mental models and engineering mechanisms that stay useful no matter which coding agent you're driving: how to turn a vague requirement into a task an agent can actually execute and you can actually verify; how to manage a limited context window as your most contested resource; how to decide what an agent may do on its own, what it must escalate, and what it must never touch; and how to keep an entire codebase, a whole team, and a production pipeline governable once agents are doing real work inside them.

The book is built around a simple, recurring worry: agents are eager, confident, and occasionally wrong in ways that look exactly like being right. To make that worry productive rather than paralyzing, the book develops its own working vocabulary — the Four Paradoxes of AI collaborators, Trust Engineering's four pillars of delegation, safety, accountability, and compliance, and evidentiary thinking as the core habit of mind a developer needs once code itself is no longer scarce. These aren't abstractions for their own sake; each one comes with the failure mode it's meant to catch and the concrete mechanism — a Mission Brief, an Autonomy Envelope, a Structured Decision Request, an N-version Exploration — that catches it.

Every mechanism is grounded in IoTFlow, a fictional but fully worked-through IoT platform that runs through all twenty-four chapters. You'll watch the same gateway module get a feature scaffolded, then break in production, then get refactored, then get migrated — so every technique is shown solving a real problem in a real codebase, not floating free as a slide-deck principle.

The book moves from the fundamentals of what an agent is and isn't, through the full working loop of intent, context, tools, and verification, into harder terrain: multi-agent pipelines, codebases built to stay legible to humans and agents alike, delivery and governance at production scale, and the open research questions the field hasn't answered yet. Four appendices — a glossary, a set of engineering templates, a prompt-engineering quick reference, and a full map of the IoTFlow example — turn the book into something you'll keep open on a second monitor, not just read once.