Goal
The path to "Building Applications with AI Agents"
Here is the reading path leading up to this book, derived from its dependencies and ordered from the fundamentals.
The path so far (15 books)
Why read this first: Once you can use an AI coding agent like Claude Code effectively, you start wanting to build one yourself to see what's happening inside. Building AI Agents walks through implementing everything from LLM calls to tool execution and Git/GitHub integration, shifting your perspective from using such a tool to building one.
Sources
- Tsukutte Manabu AI Agent (Learning AI Agents by Building One) - Gijutsu-Hyohron
- Kaihatsu Koritsu o Up Suru! Claude Code Jitsuyo Nyumon (A Practical Introduction to Claude Code for Boosting Development Efficiency) - Mynavi Publishing
- Jissen Claude Code Nyumon (A Practical Introduction to Claude Code) - Gijutsu-Hyohron
Why read this first: Once you've reframed Claude Code as an 'agent that executes agreements' and internalized the spec-driven development pattern, you naturally want to see with your own hands what happens inside such an agent. Building AI Agents pushes you from being a user to a builder by having you implement the reasoning loop and tool calls in TypeScript yourself.
Why read this first: Having understood concurrency within a single process, you extend to a world where multiple processes—services—coordinate asynchronously. Microservices Patterns provides coordination patterns for distributed systems—messaging, sagas, event-driven design—extending the idea of concurrency across the network.
Why read this first: Once you grasp how LLMs process input and generate responses, plus the fundamentals of prompt design and context construction, you can see what abstractions a framework like LangChain takes off your hands. This book's insights on issues like Lost in the Middle and the volatility of conversation history give you criteria for designing context when building agents with LangChain.
Why read this first: Having built a coding agent from scratch in TypeScript, you internalize the inner workings of the reasoning loop and tool integration. Practical AI Agent Development builds on that implementation sense, broadening the view from a single agent to multi-agent systems and production operation.
Why read this first: Enterprise Integration Patterns organizes messaging channels, message construction, routing, transformation and endpoints with a vocabulary and a visual notation that do not depend on a product. Microservices Patterns takes up the problems that appear once a monolith is decomposed into services: interprocess communication between them, and transactions that span them, handled with sagas. With the messaging vocabulary of the first book in place, the second book's discussion of asynchronous communication can be followed from the ground up.
Why read this first: Having gone through the basic design and implementation patterns of agents with LangChain, you start to see the design challenges of multi-agent systems that go beyond a single agent. Practical AI Agent Development builds up production-facing perspectives—orchestration, evaluation, monitoring, security—that framework learning alone doesn't cover.
Why read this first: Once you can build applications with Spring, you start to feel the limits of framework-driven design centered on the database or the framework. Clean Architecture provides the Dependency Rule that keeps business rules independent of the framework, letting you choose a structure resilient to change over the long term.
Why read this first: Once you can design boundaries inside a system, you face the next decision: whether to split those boundaries into separate processes—services. Monolith to Microservices, guided by the pragmatic 'monolith first' principle, systematizes the motivations, methods, and pitfalls of decomposition.
Why read this first: Once you can decide whether to split a monolith, you stock up on the implementation patterns needed after the split. Microservices Patterns catalogs the established practices for service decomposition, data management, communication, and deployment, bridging from 'how to divide' to 'how to build.'
Why read this first: Learning microservice implementation patterns, you inevitably hit the hard problem of keeping data consistent across services. Designing Data-Intensive Applications supplies the theory of distributed-data consistency, replication, and transactions, underpinning why those patterns work.
Why read this first: Having understood the design of a single relational database, you broaden your view to the big picture of large-scale systems involving multiple data stores. Designing Data-Intensive Applications systematizes the fundamentals of data systems—replication, partitioning, consistency, faults—without being swayed by passing trends.
Why read this first: The first part of Understanding Distributed Systems works through TCP, TLS and DNS and ends with a chapter that describes implementing a RESTful HTTP API; the later parts are about scaling a web application with such an API and keeping it running through failures. With HTTP methods, status codes and resource design already familiar, you can read the communication part as review and spend your time on coordination, scalability and resiliency.
Why read this first: The author of Understanding Distributed Systems says himself that the book favors breadth over depth and may not suit readers with years of experience. Replication, partitioning, transactions and consistency models each get a chapter or a section. Designing Data-Intensive Applications spends a whole book on those subjects, and is easier to enter once the first book has given you the vocabulary and a sense of where each piece sits.
Why read this first: Having grasped the theory of consistency, reliability, and scale in large-scale data systems, you see it as the foundation for putting AI agents into production. Practical AI Agent Development bridges the robustness principles learned in data-intensive systems to designing agent state management and tool integration.