The AI Coding Failure Casebook

Preface

1. Who this book is for
2. What an AI coding agent actually is
3. How this book is organized
4. How to read a case
5. An honest note about the cases
6. A safety note
7. What this book is not
8. A note on the code
9. How to get the most out of this book
10. Let us begin

Chapter 01: Why Agent-Built Software Fails Differently

1. What you will learn
2. The agent does not think. It predicts.
3. “Looks right” is a trap for humans, too
4. The four properties of agent failures
5. The agent is not the enemy
6. Why this is different from ordinary debugging
7. The three places to stand
8. The cost of skipping the check
9. A short example to set the tone
10. Summary
11. Try it yourself

Chapter 02: How to Read a Case, and How to Keep Your Own Failure Log

1. What you will learn
2. How a case is built
3. Symptom-first reading
4. A worked match
5. Two ways to read this book
6. Read the root cause, not just the fix
7. The difference between a fix, a check, and a guardrail
8. Why keep a failure log
9. A simple log format
10. The habit that keeps the log alive
11. From log to guardrail
12. The log is not a record of shame
13. Summary
14. Try it yourself

Chapter 03: Spec and Context Failures

1. Case 1: The Requirement Nobody Read Twice
2. Case 2: The Feature That Grew Overnight
3. Case 3: The Constraint That Vanished
4. Case 4: Two Answers to One Question
5. Case 5: The Bonus Feature Nobody Asked For
6. Case 6: The Prompt With Three Meanings
7. Summary
8. Try it yourself

Chapter 04: Code and Logic Failures

1. Case 7: Looks Right, Does Wrong
2. Case 8: The Package That Does Not Exist
3. Case 9: Off by One, Off by Everything
4. Case 10: The Error Nobody Saw
5. Case 11: Copy, Paste, Diverge
6. Case 12: Yesterday’s API
7. Summary
8. Try it yourself

Chapter 05: Data Failures

1. Case 13: The Migration That Ate the Table
2. Case 14: The Schema That Drifted
3. Case 15: The Row That Was Overwritten
4. Case 16: Seed Data That Should Not Ship
5. Case 17: The Midnight Bug
6. Case 18: No Backup, No Mercy
7. Summary
8. Try it yourself

Chapter 06: Security Failures

1. Case 19: The Key in the Code
2. Case 20: The Door With No Lock
3. Case 21: The Input That Became a Command
4. Case 22: The Upload That Took the Server
5. Case 23: Everyone Is an Admin
6. Case 24: Secrets in the Logs
7. Case 25: Trusting the Client
8. Summary
9. Try it yourself

Chapter 07: Dependency and Environment Failures

1. Case 26: Dependency Hell, Assembled
2. Case 27: The Package Nobody Maintains
3. Case 28: Works on My Machine
4. Case 29: The Missing Environment Variable
5. Case 30: The Build That Broke Itself
6. Summary
7. Try it yourself

Chapter 08: Testing Failures

1. Case 31: The Test That Tests Nothing
2. Case 32: Mocking Away Reality
3. Case 33: The Test That Disappeared
4. Case 34: The Happy Path Only
5. Case 35: The Test That Breaks on Refactor
6. Summary
7. Try it yourself

Chapter 09: Workflow and Agent-Behavior Failures

1. Case 36: The Endless Fix Loop
2. Case 37: The Thousand-Line Diff
3. Case 38: The File That Was Overwritten
4. Case 39: The Session That Forgot
5. Case 40: “All Tests Pass”
6. Case 41: The Edit in the Wrong File
7. Case 42: The Permission Nobody Needed
8. Summary
9. Try it yourself

Chapter 10: Deployment and Operations Failures

1. Case 43: Debug Mode in Production
2. Case 44: The Silent Outage
3. Case 45: The Deploy With No Way Back
4. Case 46: The App That Ate the Server
5. Case 47: The Secret in the Git History
6. Summary
7. Try it yourself

Chapter 11: Human Failures

1. Case 48: Trusting the Summary
2. Case 49: The Review That Never Happened
3. Case 50: Shipping Code You Do Not Understand
4. Summary
5. Try it yourself

Chapter 12: Building Your Guardrails

1. What you will learn
2. The rules file
3. Turning a failure into a rule
4. A ready-made starter set
5. Prompt lines that ship with every request
6. Small steps
7. Version control habits
8. Marketing the guardrails
9. Rules growing, rules shrinking
10. Making the tools show their work
11. Summary
12. Try it yourself

Chapter 13: A Review Routine You Can Run in 15 Minutes

1. What you will learn
2. The setup
3. Phase 1: What is here (3 minutes)
4. Phase 2: The sensitive files (5 minutes)
5. Phase 3: The three questions for the whole change (4 minutes)
6. Phase 4: Run it (3 minutes)
7. The one-line verdict
8. Keeping it honest when you are tired
9. Fitting it into a small habit
10. A worked fifteen minutes
11. The five-minute fast version
12. Summary
13. Reviewing the review
14. Try it yourself

Chapter 14: When to Stop and Start Over

1. What you will learn
2. The three stop conditions
3. Sunk work does not vote
4. A worked decision
5. Make the start-over small
6. Messy versus tangled
7. When to keep the old thing anyway
8. The cost of a rebuild, honestly counted
9. Avoiding the decision altogether
10. The after-action, briefly
11. The three stop conditions, as a decision tree
12. Summary

Appendix A: Failure-Log Template

1. The weekly review
2. Examples
3. Labels

Appendix B: Prompt Snippets Library

1. Setup and scope
2. Boundaries and quality
3. Data safety
4. Security
5. Testing
6. Workflow
7. Operations
8. Rebuild
9. The three that ship with everything

Appendix C: Pre-Ship Checklist

1. Data and backups
2. Secrets and security
3. Environment and dependencies
4. Tests and review
5. Data that must never ship
6. After the deploy
7. The last line

Appendix D: Case Index by Symptom

1. App behavior
2. Data
3. Agent behavior
4. The human side
5. Noticing and catching (the “odd smell” list)

Glossary

About the Author