1. Cover
  2. Colophon
  3. Epigraph
  4. Introduction
    ❱
    1. Welcome
    2. What Is Agentic Coding?
    3. What Are Design Patterns?
    4. How to Read This Book
    5. How This Book Writes Itself
    6. Learning Tracks
    7. What's New
    8. Article Map
    9. Meta Report
  5. Product Judgment and What to Create
    ❱
    1. Problem
    2. Customer
    3. User
    4. Value Proposition
    5. Competitive Landscape
    6. Differentiation
    7. Beachhead
    8. Go-to-Market
    9. Revenue Model
    10. Monetization
    11. Distribution
    12. Product-Market Fit
    13. Crossing the Chasm
    14. Zero to One
    15. Bottleneck
    16. Roadmap
    17. User Story
    18. Use Case
    19. Build-vs-Don't-Build Judgment
  6. Intent, Scope, and Decision-Making
    ❱
    1. Application
    2. Brief
    3. Requirement
    4. Constraint
    5. Acceptance Criteria
    6. Specification
    7. Spec-Driven Development
    8. Design Doc
    9. Tradeoff
    10. Judgment
    11. Taste
    12. Architecture Decision Record
    13. Risk Spike
    14. Programming Language Selection
  7. Structure and Decomposition
    ❱
    1. Architecture
    2. Shape
    3. Abstraction
    4. Component
    5. Module
    6. Interface
    7. Consumer
    8. Contract
    9. Boundary
    10. Cohesion
    11. Coupling
    12. Dependency
    13. Composition
    14. Separation of Concerns
    15. Monolith
    16. Decomposition
    17. Task Decomposition
    18. Big Ball of Mud
    19. Spaghetti Code
    20. God Object
  8. Data, State, and Truth
    ❱
    1. Data Model
    2. Schema (Database)
    3. Schema (Serialization)
    4. Data Structure
    5. State
    6. Artifact
    7. Source of Truth
    8. DRY (Don't Repeat Yourself)
    9. Copy-Paste Programming
    10. Hard Coding
    11. Primitive Obsession
    12. Data Normalization / Denormalization
    13. Database
    14. CRUD
    15. Consistency
    16. Atomic
    17. Transaction
    18. Serialization
    19. Idempotency
    20. Domain Model
    21. Entity
    22. Value Object
    23. Ubiquitous Language
    24. Naming
    25. Coding Convention
    26. Aggregate
    27. Bounded Context
    28. Anti-Corruption Layer
    29. Business Capability
  9. Computation and Interaction
    ❱
    1. Algorithm
    2. Algorithmic Complexity
    3. API
    4. Protocol
    5. Determinism
    6. Side Effect
    7. Concurrency
    8. Event
  10. Correctness, Testing, and Evolution
    ❱
    1. Invariant
    2. Test
    3. Test Oracle
    4. Code Coverage
    5. LLM-as-Judge
    6. Static Analysis
    7. Formal Verification
    8. Harness
    9. Fixture
    10. Test Double
    11. Test-Driven Development
    12. Red/Green TDD
    13. Reproduction Test
    14. Mutation Testing
    15. Property-Based Testing
    16. Approval Testing
    17. Refactor
    18. Regression
    19. Test Impact Analysis
    20. Flaky Test Quarantine
    21. Test Pyramid
    22. Smoke Test
    23. Exploratory Testing
    24. Agentic Manual Testing
    25. Consumer-Driven Contract Testing
    26. Observability
    27. Domain-Oriented Observability
    28. Agent Trace
    29. Failure Mode
    30. Failure Response Mode
    31. Layers and Generators
    32. Silent Failure
    33. Fail Fast and Loud
    34. Performance Envelope
    35. Logging
    36. Happy Path
    37. Production-Readiness Cliff
    38. Code Review
    39. Review Bottleneck
    40. Risk-Based Review
    41. Printf Debugging
    42. Scientific Debugging
    43. Metric
    44. Feedback Loop
    45. Service Level Objective
    46. Technical Debt
    47. Greenfield and Brownfield
    48. Strangler Fig
    49. Parallel Change
    50. Deprecation
    51. Evolutionary Modernization
    52. Regenerative Software
    53. Sweep
    54. Backfill
  11. Security and Trust
    ❱
    1. Threat Model
    2. Attack Surface
    3. Trust Boundary
    4. Authentication
    5. Authorization
    6. Vulnerability
    7. Least Privilege
    8. Agentic Payments
    9. Secret
    10. Input Validation
    11. Output Encoding
    12. Sandbox
    13. Agent Gateway
    14. Action-Selector
    15. Blast Radius
    16. Prompt Injection
    17. Tool Poisoning
    18. Agent Trap
    19. Adversarial Cloaking
    20. RAG Poisoning
    21. Slopsquatting
  12. Human-Facing Software
    ❱
    1. UX
    2. Affordance
    3. User Feedback
    4. Accessibility
    5. Internationalization
    6. Localization
  13. Operations and Change Management
    ❱
    1. Environment
    2. Configuration
    3. Version Control
    4. Git Checkpoint
    5. Migration
    6. Ship
    7. Deployment
    8. Small Batches
    9. Continuous Integration
    10. Merge Queue
    11. Continuous Delivery
    12. Continuous Deployment
    13. Progressive Delivery
    14. Pipeline as Code
    15. Pipeline Synthesis
    16. Build Provenance
    17. Autonomous Remediation
    18. AI First Responder
    19. GitOps
    20. Rollback
    21. Feature Flag
    22. Runbook
    23. Blameless Postmortem
    24. Dead Man's Switch
    25. Cascade Failure
    26. Retry Budget
  14. Socio-Technical Systems
    ❱
    1. Conway's Law
    2. Team Cognitive Load
    3. Ownership
    4. Bounded Agency
    5. Involuntary Promotion
    6. Stream-Aligned Team
    7. Enabling Team
    8. Platform as a Product
    9. Thinnest Viable Platform
    10. Organizational Debt
    11. Inverse Conway Maneuver
    12. Not Invented Here
  15. Design Heuristics and Smells
    ❱
    1. KISS
    2. YAGNI
    3. Local Reasoning
    4. Make Illegal States Unrepresentable
    5. Belt-and-Suspenders
    6. Smell (Code Smell)
    7. Smell (AI Smell)
    8. Cargo Cult Programming
    9. Architecture Astronaut
    10. Speculative Generality
    11. Jagged Frontier
    12. Load-Bearing
    13. Pinning
    14. Build to Delete
    15. Footgun
    16. DWIM
    17. Best Current Practice
    18. Premature Optimization
    19. Vibe Coding
    20. Benchmark Mirage
    21. Hotspot Analysis
  16. Agentic Software Construction
    ❱
    1. Model
    2. Reasoning Effort
    3. Prompt
    4. Context Window
    5. Context Rot
    6. Hallucination
    7. Context Engineering
    8. Codebase Map
    9. Reference Repository
    10. Progressive Disclosure
    11. Agent
    12. Harness (Agentic)
    13. Harness Engineering
    14. Self-Improving Harness
    15. REPL
    16. Deep Agents
    17. Tool
    18. Agent-Computer Interface (ACI)
    19. MCP (Model Context Protocol)
    20. Structured Outputs
    21. Retrieval
    22. GraphRAG
    23. ReAct
    24. Code Mode
    25. Plan Mode
    26. Question Generation
    27. Preframing
    28. Research, Plan, Implement
    29. Verification Loop
    30. Interactive Explanations
    31. Reflexion
    32. Plan-and-Execute
    33. Agentic Context Engineering
    34. Subagent
    35. Async Subagent
    36. Skill
    37. Skill Fitness
    38. Hook
    39. Instruction File
    40. Memory
    41. Compound Engineering
    42. Agentic Engineering
    43. Thread-per-Task
    44. Worktree Isolation
    45. Background Agent
    46. Ephemeral Environment
    47. Compaction
    48. Context Offloading
    49. Context Editing
    50. Prompt Caching
    51. Progress Log
    52. Checkpoint
    53. Park
    54. Externalized State
    55. Durable Agent Session
    56. Task Horizon
    57. Compounding Error
    58. Agent Workflow Graph
    59. Prompt Chaining
    60. Parallelization
    61. Orchestrator-Workers
    62. Back-Pressure (Agent)
    63. Circuit Breaker
    64. Ralph Wiggum Loop
    65. Agent Teams
    66. Blackboard
    67. Generator-Evaluator
    68. Evaluator-Driven Code Search
    69. Model Routing
    70. A2A (Agent-to-Agent Protocol)
    71. Handoff
    72. Loop Engineering
    73. Issue Tracker as Control Plane
  17. Agent Governance and Feedback
    ❱
    1. Approval Policy
    2. Permission Classifier
    3. Runtime Governance
    4. Eval
    5. Pass^k
    6. Evaluation Gate
    7. Human in the Loop
    8. Trusted Monitoring
    9. Feedforward
    10. Feedback Sensor
    11. Steering Loop
    12. Monotonic Progress
    13. Harnessability
    14. Agent Readiness Assessment
    15. Bounded Autonomy
    16. Dark Factory
    17. Agent Registry
    18. Agent Provenance
    19. Agentic Pull Request
    20. AI Contribution Policy
    21. Approval Fatigue
    22. Shadow Agent
    23. Agent Sprawl
    24. Tool Sprawl
    25. Agent Drift
    26. Premature Termination
    27. Sycophancy
    28. Review Overcorrection
    29. Reward Hacking
    30. Garbage Collection
    31. Shift-Left Feedback
    32. Feedback Flywheel
    33. Incident-to-Eval Synthesis
    34. Delegation Chain
    35. Architecture Fitness Function
    36. AgentOps
    37. Agent Cost Governance