Chapter 13: Further Reading

An annotated bibliography for deeper exploration of the concepts covered in this chapter.

1. "The Pragmatic Programmer" by David Thomas and Andrew Hunt (2019, 20th Anniversary Edition)

The definitive guide to professional software development practices. Chapters on orthogonality, decoupling, and code organization provide the architectural foundations that make multi-file AI-assisted development possible. The concept of "tracer bullets" (building thin end-to-end slices first) maps directly to the hybrid generation approach discussed in Section 13.5.

2. "Clean Architecture" by Robert C. Martin (2017)

Martin's work on dependency rules and the separation of concerns across architectural layers is essential background for Section 13.7 (Import and Dependency Management). Understanding the Dependency Inversion Principle and the concept of stable abstractions helps you design codebases that are easier for AI assistants to work with, because the interfaces are well-defined and the dependency direction is clear.

3. "Working Effectively with Legacy Code" by Michael Feathers (2004)

Despite its age, this book remains the definitive resource for understanding and modifying existing codebases. The strategies for characterization tests, seam identification, and incremental refactoring directly apply to the legacy code scenarios in Section 13.10. The book's concept of "sensing variables" is particularly useful when asking AI to analyze unfamiliar code.

4. "Monorepo Handbook" by Nrwl (available at monorepo.tools)

A comprehensive online resource covering monorepo strategies, tools, and best practices. It covers workspace management, dependency graphs, task orchestration, and incremental builds. Essential reading if you work in a monorepo environment and want to understand the tooling ecosystem (Nx, Turborepo, Bazel) that complements the AI-assisted strategies in Section 13.8.

5. "A Philosophy of Software Design" by John Ousterhout (2018)

Ousterhout's concepts of "deep modules" (simple interfaces hiding complex implementations) and "information hiding" directly support the interface-first context strategy from Section 13.3. A codebase designed with deep modules is naturally easier to work with using AI, because the interfaces are informative while the implementations can be safely hidden from the context window.

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

Covers the tradeoffs involved in distributed architectures, service decomposition, and data management across boundaries. The chapters on coupling analysis and component identification provide frameworks for deciding how to scope AI sessions and where to draw the boundaries between holistic and file-by-file generation.

7. "Prompt Engineering for Developers" — Anthropic Documentation (docs.anthropic.com)

Anthropic's official documentation on prompt engineering provides techniques specifically optimized for Claude models. The sections on system prompts, structured output, and multi-turn conversations complement the context management strategies in this chapter with model-specific optimization techniques.

8. "Building LLM-Powered Applications" by Valentina Alto (2024)

Covers practical patterns for integrating large language models into development workflows. The chapters on context window management, retrieval-augmented generation (RAG), and chain-of-thought prompting provide technical depth on the mechanisms underlying the strategies discussed in Sections 13.3 and 13.4.

9. "Designing Data-Intensive Applications" by Martin Kleppmann (2017)

While focused on data systems, Kleppmann's treatment of system boundaries, API design, and schema evolution is directly relevant to multi-file code generation. Understanding how data flows through a system (Chapter 13.9's data flow tracing) requires the mental models this book builds. Particularly relevant for the database and service layer integration patterns common in multi-file projects.

10. "The Art of Readable Code" by Dustin Boswell and Trevor Foucher (2011)

Focused specifically on code readability and naming conventions. The principles in this book underpin the consistency strategies in Section 13.6. Readable code is not just easier for humans to understand; it is also easier for AI to maintain consistency with, because clear naming conventions and patterns are more likely to be correctly replicated.

11. "Refactoring: Improving the Design of Existing Code" by Martin Fowler (2018, 2nd Edition)

Fowler's catalog of refactorings provides a vocabulary for the kinds of changes you will ask AI to make across multiple files. Understanding patterns like "Extract Class," "Move Function," and "Replace Conditional with Polymorphism" helps you give AI assistants more precise instructions when restructuring code.

12. "Code Complete" by Steve McConnell (2004, 2nd Edition)

McConnell's comprehensive guide to software construction includes detailed treatment of naming conventions, code organization, and module design. The chapters on variable naming and routine design provide the foundation for the style guides discussed in Section 13.6.

13. "AI-Assisted Software Engineering" — IEEE Software Special Issue (2024)

A collection of research papers examining how AI tools are changing software engineering practices. Includes empirical studies on code generation quality, developer productivity with AI tools, and the challenges of maintaining consistency in AI-assisted development. Provides academic grounding for the practical strategies in this chapter.

14. "Large-Scale Software Architecture" by Jeff Garland and Richard Anthony (2003)

Though predating AI coding tools, this book's frameworks for managing complexity in large systems remain relevant. The concepts of architectural views, component interfaces, and system decomposition map directly to the context management tiers and scoping strategies needed for enterprise-scale AI-assisted development.

15. Aider's Repository Map Documentation (aider.chat)

Aider, an open-source AI coding tool, pioneered the concept of automatically generating repository maps using tree-sitter parsing and ctags. Their documentation explains the technical approach to building efficient codebase summaries for AI context. Understanding their approach provides practical insight into how the repository mapping concepts in Section 13.2 can be automated.