Spoon-feed the judge

 

"Spoon-feed the judge" The best personal advice I ever got about high-stakes work. It became part of my professional practice: don’t make the decision-maker swivel their chair, open another book, or go hunting for context. Put the proof next to the claim. Make it one-and-done.

In regulated healthcare software, the “judge” might be an auditor, security reviewer, change approver, incident responder, future-you at 2 a.m., or future-you three years later in a deposition—but the rule stays the same:

If it isn’t easy to verify, it isn’t easy to defend.

I didn’t fully appreciate how universal this principle was until years later, when my roles included conducting audits and being subject to them.

As an auditor, “spoon-feed the judge” is exactly what I want. I trust, but verify. This is transparency at its best.

As the person under audit, it makes my position easier to defend because the evidence travels with the claim.

Bonus (worth its weight in gold): over time, this approach has kept me out of many audits entirely - because the work was naturally verifiable without a live explanation. More than once I’ve been told: “No—this answered all our questions. We don’t need to call you.”

What “spoon-feeding” looks like in systems work:

1. Make it readable

   Short, structured, and complete. If verification requires a scavenger hunt, you did not spoon-feed your judge and your risk rises.

2. State assumptions upfront

   Identifiers, timing windows, source of truth, and what “acceptable” looks like.

3. Locate proof next to the claim

   Your claim was clear. Now provide the proof right next to it. If proof cannot be adjacent, keep the ordering parallel and easy to follow.

4. Make cross-system truth explicit. For transitions, prove each of the following:

   • Sent
   • Received
   • Applied

   Acknowledged is not the same as true.

5. Leave an audit trail that survives time

   Links, IDs, timestamps, and artifacts that let anyone re-verify without tribal knowledge.

This is not “more documentation.” It’s high-quality evidence—delivered where it’s needed, when it’s needed.

Where do you still see scavenger hunts in your high-stakes work? Consider how you, too, can "Spoon-feed the judge".

The most critical defects often exist between systems rather than within them

 

 

Would you like to quickly find where some of your most critical system defects? 

Take a lesson from healthcare: transitions in care are well-documented high-risk times. This is not a one-off issue but a repeatable pattern.

Software systems exhibit the same pattern during transitions:

• You might say, “System A did its job,” but “System B holds the truth.” It's essential to prove it.

Consider this real-world example:

Your doctor says they sent the prescription. The pharmacy claims they don’t have it. Ultimately, you still don’t have your medication. The gap lies in this hand-off: sent ≠ received ≠ applied.

To address this, lean into testing transitions:

• Define what “done” means on both sides of the transition.
• Trust, but verify: don’t stop at “sent.” Confirm it was received and actually applied.

Test both acceptable and unacceptable outcomes:

• Acceptable: slowdowns, retries, short delays.
• Not acceptable: missing, wrong, late, duplicates.
• If you exceed a limit, log it as beyond tolerance - don’t mask issues behind a green check.

Why is this important? Testing these hand-offs provides evidence where it matters most and can make the rest of your test suite feel surprisingly simpler. Your customers will thank you for it.