For six audit rounds in a row, the same thing happened in the codebase I'm building. A ticket described one reproduction. Someone fixed it, the ticket closed, and a later audit found the same defect somewhere parallel.

One fix changed how a single endpoint handled cross-origin requests from a browser. Four other endpoints had the identical problem. It came back as a second ticket.

The totals were worse than the anecdote. In an end-to-end audit on September 25, 31 of the 48 findings were regressions of earlier fixes or fixes that had covered only one instance of a class. In a second audit the next day, all four of the highest-severity findings were siblings of earlier fixes: the right repair, applied to one of several places the same mistake lived.

None of those sets of siblings was a mystery. Each was knowable on the day the fix was written, and nobody had listed it. We did have a rule that said to sweep the whole class. It asked a person to remember, and nothing checked that the search happened.

A fix is a bet that nothing else shares the cause

A fix closes the instance that got reported. Whether it closes the class depends on whether anyone named the class. If nobody did, the fix is a bet that the cause lives in exactly one place, and the bet gets settled later, by whoever finds the next one.

AI behavior makes the bet worse. The decision that got reported is one case among everything that read the same paragraph of guidelines, called the same tool or ran on the same model version. Fix the reported instance and the others keep running on the same cause, quietly, until someone happens to notice one.

The sibling note

A sibling note is a short entry attached to a fix. It says what caused the failure, what else could share that cause, and what happened to each of those. It has three parts.

The cause, in one sentence, marked established or inferred. If you can't write it, you aren't ready to list siblings, because siblings are defined by the cause.

The siblings. Every other place the same cause could be doing the same damage, found by what they share and not by what you happen to remember.

What happened to each one. Fixed, checked and not affected (with the reason), or filed with an owner. "Not affected" with no reason is the same as not having looked.

The note works because it moves the search from the end of the process, when the next incident does it for you, to the moment you know the most about the cause.

For an AI workflow, the question that finds siblings is what the failing decision shared with the others.

If the failing decision shared

The siblings are

Instruction text

Every other decision that reads that passage, including ones in other workflows

A tool or data source

Every other decision that calls it, and what each does when it returns something bad

A model or provider setting

Every other comparable workflow running on that model or setting

A kind of input

Other phrasings, and other channels, that bring the same kind of request

A downstream action

Other decisions that end in the same action

Say a support agent approved a refund above its limit because the customer wrote "duplicate charge," and the fix is a line in the guidelines saying duplicate charges still follow the limit. The reported case is closed. The note asks what else shares the cause.

The credit and fee-waiver decisions read the same passage, so the same wording may move them. "Charged twice" and "double billed" say the same thing in different words. The chat channel may run its own copy of the guidelines that never received the line. That's three siblings, each found by something it shares with the original. Some won't be affected, and the note says which and why.

Checking them means replaying a few realistic variants, not only the one that was reported. A fix tested against the reported phrasing has been tested against the case it was written for.

What it does to a fix

On my own build, a few tests started timing out when the whole suite ran at once. The obvious patch was a longer timeout on the three that failed. The sibling list for "test timeouts" was every package's test configuration, and none of them had set a timeout at all. Raising it on three tests would have fixed three and waited for the fourth, so the fix became one rule for every package.

That's an ordinary engineering example, and the shape carries over. The list changes the size of the fix before the next incident does.

What this doesn't give you

A named list isn't a complete one. The note is only as good as how you found the siblings, and lists written from memory miss things. Lists derived from what the decisions actually share (the passage, the tool, the model) miss fewer. In that codebase, the members of each list are now generated from the code, so a new one is in the set the day it's written.

It doesn't tell you the fix was right. It tells you that you looked at the neighbors, and a wrong fix applied to every sibling is a wrong fix in more places.

It also has a cost, and the cost should scale with the consequence. A fix to a cheap, reversible decision can carry a one-line note, something like "no other reader of this text." The habit is in saying so.

One thing to do this week

Take the last change you made to an AI workflow because something went wrong. Write its sibling note after the fact: the cause in a sentence, marked established or inferred, then three siblings, each found by something it shares with the failing decision, and a status for each. Check one of them with a handful of realistic variants, not only the case that was reported.

If you can't write the cause sentence, that's the finding. A team that doesn't know why something happened can't know what else it touched.

Then make it hard to skip. Put a line for siblings wherever you record fixes, whether that's the ticket, the changelog or the pull request, so a fix with no note looks unfinished. In that codebase, the check on the decision log refuses an entry that doesn't carry one, because the prose rule alone didn't hold. A required line in your ticket template is the small version of the same gate.

Where this goes

Done by hand, this is one note per fix. Keeping sibling sets current across every decision an agent makes, while the guidelines, tools and models underneath keep changing, is the part most teams end up rebuilding for themselves. That continuous version is the direction I'm building Nalyqor toward. You don't need it to write the note.