Silent Wiring: The Hidden Failure Mode in AI-Generated Code

THE BOOK

Silent Wiring

The Hidden Failure Mode in AI-Generated Code

A book about integration code that compiles, passes review, keeps its dashboards green, and moves nothing at all. I shipped four of them into my own production system, and between them they covered every shape the book describes. I found the first at eleven o'clock at night, while poking at data for no particular reason. A different one had been writing convincing fakes for two months before I looked closely enough to notice.

The first half is what happened and why it happens. The second half is the field manual: the checks, the thresholds, the false alarms you will hit in the first week, and the code to run them.

  • 10 chapters
  • 28 field manual units
  • 49,000 words
  • 113 code blocks

AVAILABILITY

Not out yet. Here is exactly where it stands.

The manuscript is finished and sealed: ten chapters and twenty-eight field manual units, all locked. What is left is publishing, not writing.

It goes on Leanpub, priced pay-what-you-want: $18 suggested, $0 minimum. If eighteen dollars is not worth it to you, take it for nothing; I would rather it was read.

In the meantime the field notes are free, ungated, and cover the same ground in shorter form. The four failure types are all there.

Read the field notes

Told once, when it lands

The manuscript is done. The publishing is not. Leave an address to hear on the day it goes up. The same email carries the companion prompt pack, free.

Two emails, total. One now to confirm it is really you, and one when the book launches, carrying the pack: two kits for AI coding assistants, one for building integrations that cannot hide a dead edge, one for auditing code you already have. Not a newsletter, and no sequence. Your address is used for that and nothing else, and every email carries an unsubscribe link.

WHAT IS INSIDE

Five parts. The first four argue it; the fifth hands you the tools.

Chapter titles below are the book's own.

Part One: The Problem

  1. Preface
  2. 1. The Lies Your Dashboard Are Telling You
  3. 2. The Four Ways Code Lies to You
  4. 3. Nobody Got an Error Message

Part Two: Why It Happens

  1. 4. The Physics of Faster Wiring
  2. 5. Why Your Tools Won't Catch It

Part Three: The Fix

  1. 6. Declare and Defend Your Expected Flows
  2. 7. Verify Behavioral Liveness
  3. 8. The Test Your Tests Can't Pass

Part Four: The Proof

  1. 9. What Happened When We Pointed This at Ourselves
  2. 10. Getting Started Monday Morning

Part Five: The Field Manual

Twenty-eight units. Topology declarations, liveness verification, mutation testing, and the triage pass that decides where to aim first.

  1. Topology declarations: writing every wiring edge down as something a machine can check
  2. Liveness verification: the /liveness endpoint, canary events, handler freshness, event bus audit, dead letter queues, meta-liveness, and calibrating thresholds so it does not cry wolf
  3. Mutation testing: the four core operators, the runner, picking three flows to start with, and handling false kills
  4. Living with it: wiring coverage as a team metric, what to do when a flag is real, and when to stop running a check that has nothing left to say
  5. Going further: extended operators, shadow execution, confidence scoring
  6. A research bibliography and a quick reference card

WHO IT IS FOR

The person paged when the numbers are quietly wrong

Staff-plus engineers, tech leads and SREs who own correctness on a team shipping AI-generated code. If you have ever looked at a table full of rows and concluded a system was healthy, this is written for you.

It assumes you can read Python and TypeScript, that you have an event bus or a queue somewhere in your stack, and that nobody has to sell you on the idea that tests can pass while the system does nothing.