When two implementations agree and are both wrong

The standard advice for trusting a computed result is to write a second, independent implementation and check that it agrees with the first. This is good advice and it is not sufficient by itself, because "independent" is doing more work in that sentence than it usually gets credit for.

Two programs written by different people, in different languages, on different days, still agreed with each other on a wrong answer in a real case from this program's own record. They were not independent in the way that mattered: both shared a canonicalization step neither author thought to question, and that shared blind spot produced the same wrong number from two different code paths. Agreement felt like proof. It was actually evidence that a mistake was popular, not that it was absent.

The fix was not a third implementation. A fourth agreeing program would have hit the same wall for the same reason. What actually caught it was an external authority that owed nothing to either implementation: a published invariant, a known-correct value from somewhere outside the two agreeing programs, that the shared assumption could be checked against directly.

Start today: the next time two checks agree, spend one minute asking what they share before you accept the agreement as confirmation. A shared library, a shared convention for how an edge case gets handled, a shared assumption about input format. If you cannot name something the two checks do NOT share, go find or build an external anchor that does not depend on either.