Chapter 10: Further Reading

Annotated Bibliography

1. "Writing Effective User Stories" by Mike Cohn

Resource type: Book (Addison-Wesley Professional)

Mike Cohn's foundational work on user stories remains the definitive guide to writing stories that are specific enough to implement yet flexible enough to adapt. The sections on acceptance criteria and the INVEST criteria (Independent, Negotiable, Valuable, Estimable, Small, Testable) are directly applicable to writing user stories as AI prompts. Pay particular attention to Chapter 7 on acceptance criteria -- these translate almost directly to specification-driven prompts.

2. OpenAPI Specification Documentation

Resource type: Official documentation (https://spec.openapis.org/oas/latest.html)

The official OpenAPI Specification documentation is the authoritative reference for writing API specifications. Understanding the full capabilities of OpenAPI -- including discriminators, callbacks, security schemes, and link objects -- allows you to write more complete specifications that produce better AI output. Start with the "Getting Started" guide, then reference the full specification as needed for your specific API patterns.

3. "Test-Driven Development: By Example" by Kent Beck

Resource type: Book (Addison-Wesley Professional)

Kent Beck's classic introduction to TDD provides the intellectual foundation for test-first prompting. While the book predates AI coding assistants, its core insight -- that writing tests before implementation forces clearer thinking about requirements -- applies directly to AI-assisted development. The "Red-Green-Refactor" cycle adapts naturally to the "Write tests, AI implements, Verify, Refactor" cycle described in this chapter.

4. "Domain-Driven Design: Tackling Complexity in the Heart of Software" by Eric Evans

Resource type: Book (Addison-Wesley Professional)

Evans's work on Domain-Driven Design (DDD) provides frameworks for modeling complex business domains -- exactly the kind of domains where specification-driven prompting adds the most value. The concepts of bounded contexts, aggregates, and ubiquitous language help you write specifications that capture domain complexity in ways AI can translate into well-structured code. Chapters 4-6 on domain model patterns are especially relevant.

5. "RESTful API Design" by Matthias Biehl

Resource type: Book (API-University Press)

A practical guide to designing REST APIs that follows industry best practices. This book covers the design decisions you need to make before writing an API specification: resource naming, URL structure, HTTP method selection, error response design, versioning, and pagination patterns. Having these patterns internalized helps you write more complete API specifications for AI.

6. JSON Schema Official Documentation

Resource type: Official documentation (https://json-schema.org/learn)

JSON Schema provides a language-agnostic way to define data structures and validation rules. The "Understanding JSON Schema" guide walks through every validation keyword with examples. This knowledge is essential for writing schema-driven specifications, whether you use JSON Schema directly or through tools like Pydantic and OpenAPI that build on it. Focus on the sections on object validation, array validation, and conditional schemas.

7. "Specification by Example" by Gojko Adzic

Resource type: Book (Manning Publications)

Adzic's book bridges the gap between requirements and executable specifications. The central idea -- that concrete examples are the most effective way to communicate requirements -- aligns perfectly with specification-driven prompting. The book's techniques for deriving specifications from conversations with stakeholders and then turning them into automated tests provide a practical workflow for generating the acceptance criteria and test specifications used throughout Chapter 10.

8. Pydantic Documentation

Resource type: Official documentation (https://docs.pydantic.dev/)

Pydantic is the Python library for data validation using type hints. Understanding Pydantic's full capabilities -- custom validators, computed fields, model inheritance, generic models, and serialization control -- helps you write schema specifications that serve simultaneously as documentation, validation, and AI prompts. The "Concepts" section covers the features most useful for specification-driven development.

9. "Design by Contract" by Bertrand Meyer (from "Object-Oriented Software Construction")

Resource type: Book chapter (Prentice Hall)

Meyer's formalization of Design by Contract (preconditions, postconditions, and invariants) provides the theoretical foundation for the contract-based specifications discussed in Section 10.7. While the full book is extensive, Chapter 11 on Design by Contract is self-contained and directly applicable. Understanding contracts helps you write interface specifications that give AI precise behavioral requirements beyond type signatures.

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

Resource type: Book (Addison-Wesley Professional)

The chapters on "Design by Contract," "Assertive Programming," and "Programming by Coincidence" provide practical wisdom on why specifications matter. The book's philosophy of making intentions explicit, using assertions to document assumptions, and avoiding coding by trial-and-error all support the case for specification-driven prompting over conversational guess-and-check approaches.

11. FastAPI Documentation

Resource type: Official documentation (https://fastapi.tiangolo.com/)

FastAPI is built on OpenAPI and Pydantic, making it the Python framework most aligned with specification-driven development. The documentation demonstrates how Pydantic models become both API documentation and runtime validation -- the "executable specification" concept from this chapter. The tutorial sections on request validation, response models, and dependency injection show how specifications translate into FastAPI code.

12. "Property-Based Testing with Proper" by Fred Hebert

Resource type: Book (Pragmatic Bookshelf)

While focused on Erlang/Elixir's PropEr library, this book provides the clearest explanation of property-based testing concepts that apply across languages. Understanding how to express requirements as properties rather than examples opens up a powerful form of test-first specification, especially for algorithmic or mathematical code. The Python equivalent (Hypothesis library) implements the same concepts.

13. Hypothesis Library Documentation

Resource type: Official documentation (https://hypothesis.readthedocs.io/)

Hypothesis is Python's property-based testing library, enabling the property-based test specifications discussed in Section 10.6. The documentation's guide to writing effective strategies and properties helps you create test specifications that cover input spaces far more thoroughly than example-based tests. The "What you can generate" section shows the full range of data types Hypothesis can create for testing.

14. "Software Requirements" by Karl Wiegers and Joy Beatty (3rd Edition)

Resource type: Book (Microsoft Press)

The comprehensive reference on software requirements engineering. Chapters on requirements elicitation, analysis, specification, and validation provide systematic approaches to the requirements-as-prompts workflow described in Section 10.2. The templates and checklists in the appendices can be adapted directly as specification templates for AI prompting.

15. SQLAlchemy 2.x Documentation

Resource type: Official documentation (https://docs.sqlalchemy.org/)

SQLAlchemy is Python's most widely used ORM, and understanding its model definition syntax is essential for schema-driven development. The "Mapped Class Essential Components" and "Relationship Configuration" sections show how to express the database schemas from Section 10.5 as Python code. The async extensions documentation covers the modern async patterns used in the chapter's examples.