New Book — March 2026
How software engineers learn to build with agents
AI agents don't just autocomplete your code. They read your codebase, reason about it, make changes across files, run your tests, and iterate. This book is your practical guide to the transition — from writing software to engineering it.
The Agentic Crew
We're moving from writing every line by hand to directing, orchestrating, and collaborating. Less typing, more thinking. Less editor, more engineering.
The tools showed up fast — Copilot, then Claude, then agents that run entire tasks autonomously — and we're all figuring it out in real time.
Systems thinking, taste, judgement, knowing what to build and why — those matter more now, not less. This book shows you how to wield them.
— From the ForewordI've been a software engineer for a long time. I know what it feels like to have a codebase in your head — to open an editor, navigate to the right file, and just write the thing. That muscle memory, built over years of keystrokes and debugging sessions, is real. It's earned.
And now the ground is shifting under our feet.
16 chapters covering the shift, the tools, and the engineering practices that make agentic work actually work.
The fundamental loop of software engineering is breaking. What it means to go from writing software to engineering it — with a crew of agents at your side.
The single most important skill in agentic engineering isn't prompting — it's context management. Learn to curate what your agents see.
Placing AI tools on a spectrum from autocomplete to autonomous systems, and understanding the captain-crew relationship that makes agentic work effective.
Lessons from spending 100+ hours building a multi-agent control plane — sessions, handovers, permissions, and worktree isolation.
The trust gradient, permission scoping, approval gates, and environment-specific rules. How to give agents power without giving them the keys to production.
Small commits, descriptive messages, branch-per-task, and worktrees for parallel agents. Git as your undo button and review interface.
Giving agents the freedom to be wrong. Worktrees, containers, and ephemeral environments that make failure cheap and experimentation free.
Tests become the agent's eyes. TDD as a superpower, fast test suites as agent infrastructure, and the virtuous cycle of better tests and more autonomous agents.
Why consistent file naming, formatters, project layouts, and CLAUDE.md files make agents dramatically more effective.
Privacy, cost, and capability trade-offs. The practical hybrid approach of matching the model to the task.
How to write effective agent prompts — task decomposition, constraint specification, the prompt-as-spec pattern, and anti-patterns to avoid.
Running agents in parallel, the handover pattern for sequential work, branch-per-agent isolation, and knowing when more agents isn't better.
War stories from the field — the eager refactorer, the hallucinated library, the infinite loop, and other failures that teach you how to work better.
The overhead tax, architecture decisions, security-critical code, and the craft argument. Knowing when to put the agent away.
How agent-assisted development changes code review, the junior engineer question, knowledge distribution, hiring, and team rhythms.
The craft isn't dying — it's shedding its skin. What endures, what changes, and why the captain still matters.
Get the book
How software engineers learn to build with agents
30-day money-back guarantee. No questions asked.