Further Reading: Architecture Resources

This chapter introduced architecture principles specific to agentic development. To deepen your understanding and apply these concepts in practice, explore the resources below organized by topic and relevance.

Related Chapters in This Book

Part 1: Foundations

Digestible Interfaces (Chapter 4, coming soon) - Deep dive into interface design that serves both humans and AI agents. Explores API design patterns, specification formats, and contract-driven development.
New Bottlenecks (Chapter 5, coming soon) - Understand how architecture principles address the new constraints that emerge when coding velocity increases 5-10x with AI agents.

Part 2: The Playbook

Requirements to Design (coming in Part 2) - Step-by-step process for transforming EARS requirements into architectural designs. Shows how to apply the principles in this chapter during the design phase of the 6-week workflow.
Design to Implementation (coming in Part 2) - Breaking down architectural designs into implementation tasks that AI agents can execute. Bridges architecture and coding.
Testing Strategies (coming in Part 2) - Comprehensive testing approach for AI-generated code, building on the testability principles from this chapter.

Part 3: Patterns & Tools

Component Decomposition Pattern (coming in Part 3) - Detailed strategies and examples for decomposing systems into digestible components. Includes metrics, heuristics, and refactoring patterns.
Bounded Contexts Pattern (coming in Part 3) - Domain-driven design adapted for AI agents. How to identify and maintain clear context boundaries.
Interface Boundaries Pattern (coming in Part 3) - Practical patterns for designing explicit contracts between components. Covers REST, events, and data schemas.
OpenAPI for REST APIs (coming in Part 3) - Complete guide to OpenAPI specifications for defining REST API contracts that AI agents can implement.
AsyncAPI for Events (coming in Part 3) - Event-driven architecture specifications using AsyncAPI. Define event schemas and message flows.
JSON Schema Validation (coming in Part 3) - Precise data validation using JSON Schema. Ensure AI-generated code handles data correctly.
Testing AI-Generated Code (coming in Part 3) - Specific strategies for validating code generated by AI agents. Covers test design, automation, and quality gates.

Part 4: Complete Example

Architecture Design (Example Project) (coming in Part 4) - See these principles applied to a real project from idea to production. Complete architectural decisions with Claude Code collaboration.

Classic Software Architecture Books

These timeless books provide foundational knowledge that complements agentic development:

Essential Reading

Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans (2003)

The definitive guide to bounded contexts, ubiquitous language, and strategic design
Highly relevant for component decomposition and identifying natural boundaries
AI agents benefit from DDD's explicit modeling of business domains

Clean Architecture: A Craftsman's Guide to Software Structure and Design by Robert C. Martin (2017)

Explains dependency inversion, separation of concerns, and layer architecture
The "Dependency Rule" is critical for testable AI-generated code
Practical patterns for organizing codebases that AI can navigate

Building Microservices: Designing Fine-Grained Systems by Sam Newman (2nd Edition, 2021)

Service decomposition strategies and integration patterns
When to split services (and when not to)
Communication patterns that align with interface boundaries principle

Advanced Topics

Software Architecture: The Hard Parts by Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani (2021)

Modern trade-offs in distributed architectures
Data decomposition and transaction boundaries
Relevant when scaling beyond MVP

Fundamentals of Software Architecture by Mark Richards and Neal Ford (2020)

Architectural characteristics and decision-making
Component-based thinking
Excellent foundation for evaluating architecture options with AI

Design Patterns: Elements of Reusable Object-Oriented Software by Gang of Four (1994)

Classic patterns that AI agents recognize and implement well
Strategy, Factory, Observer patterns particularly useful for dependency injection
Shared vocabulary for communicating with Claude Code

API Design and Specifications

OpenAPI (formerly Swagger)

Official OpenAPI Specification

Complete specification for describing REST APIs
Version 3.1 is current (as of 2025)
AI agents can read and generate code from OpenAPI specs

OpenAPI Guide

Tutorials and best practices for writing OpenAPI specifications
Examples for common API patterns
Interactive tools for validation

Swagger Editor

Online tool for writing and validating OpenAPI specs
Real-time visualization of API documentation
Useful for prototyping APIs before implementation

AsyncAPI

Official AsyncAPI Specification

Standard for defining event-driven and asynchronous APIs
Covers message brokers, WebSockets, and streaming protocols
Essential for architecting event-based systems with AI

AsyncAPI Studio

Visual editor for AsyncAPI specifications
Generates documentation and code from specs
Helpful for designing event flows

JSON Schema

Official JSON Schema Documentation

Complete reference for JSON Schema validation
AI agents excel at implementing schema-based validation
Critical for data contract enforcement

Understanding JSON Schema Guide

Comprehensive tutorial for JSON Schema
Examples for common validation scenarios
Patterns for complex data structures

Testing and Quality

Test Driven Development: By Example by Kent Beck (2002)

Foundation of test-first development
Principles apply to validating AI-generated code
Red-green-refactor cycle works beautifully with AI agents

Growing Object-Oriented Software, Guided by Tests by Steve Freeman and Nat Pryce (2009)

Test-driven design at the architectural level
Mock objects and test doubles (critical for AI-testability)
Outside-in development complements AI's top-down generation

Working Effectively with Legacy Code by Michael Feathers (2004)

Refactoring untestable code into testable architectures
Seam models and dependency breaking
Useful when retrofitting AI-friendly architecture to existing systems

Tools and Standards

Diagram and Documentation Tools

Mermaid

Text-based diagramming for architecture, flows, and ERDs
Integrates with Markdown and version control
AI agents can generate Mermaid diagrams from descriptions
Used throughout this book for visualizations

PlantUML

Alternative text-based diagramming tool
Supports UML diagrams and architecture diagrams
Can generate diagrams from code

Structurizr

C4 model for visualizing software architecture
"Architecture as code" approach
Excellent for communicating architecture to AI and humans

Linting and Validation

Spectral

Linting tool for OpenAPI and AsyncAPI specifications
Validates specs against style guides
Ensures consistent API design

AJV (Another JSON Schema Validator)

Fast JSON Schema validator for JavaScript/Node.js
Runtime validation of AI-generated data structures
Integrates with TypeScript for type safety

AI-Friendly Development Tools

TypeScript

Typed superset of JavaScript
Type system provides explicit contracts AI agents understand
Catches integration errors at compile time

Pydantic (Python)

Data validation using Python type annotations
Explicit schemas for data structures
Excellent for validating AI-generated Python code

Articles and Blog Posts

Hexagonal Architecture by Alistair Cockburn

Ports and adapters pattern
Isolating business logic from infrastructure
Foundational pattern for testable architecture

The Twelve-Factor App

Methodology for building modern applications
Configuration, dependencies, and deployment best practices
Relevant for architecting production-ready systems with AI

Martin Fowler's Architecture Blog

Microservices, event-driven architecture, bounded contexts
Patterns and anti-patterns explained clearly
Continuously updated with modern practices

AWS Architecture Blog

Real-world architecture patterns and case studies
Scalability and reliability patterns
Cloud-native architectures

Community and Discussion

Software Engineering Stack Exchange

Q&A for architecture and design questions
Search for "architecture patterns," "component design," "API design"

DDD Community

Domain-Driven Design resources and tools
Starter modeling kits and workshops

Continuing Your Learning

Apply These Principles

The best way to internalize these principles is to apply them:

Start a project - Use the 6-week playbook (Part 2, coming soon) to build something real
Refactor existing code - Apply digestibility and testability to current projects
Review with AI - Ask Claude Code to review your architecture against these principles
Share learnings - Contribute your experiences to the community

Next Steps

Continue your journey through the book:

Next Chapter: Digestible Interfaces (Chapter 4, coming soon) - Deep dive into interface design
Jump to Playbook: Part 2: The 6-Week Journey (coming soon) - Apply principles in practice
Reference Patterns: Part 3: Patterns & Tools (coming soon) - Detailed implementation patterns

Remember: Architecture for agentic development isn't fundamentally different from good architecture in general. These principles—digestibility, decomposition, explicit contracts, separation of concerns, and testability—have always led to maintainable systems. AI agents simply demand that we follow them more rigorously. The result is better software, whether built by humans or AI.