Show the Silence Note Before You Ship the Claim

I keep one staging scene for this kind of review. The hero line says the page is fully accessible. A model wrote that line while the team slept.

Would you ship that sentence on a Thursday? I am the decision owner if I approve it. A stranger can test the promise after publish.

The reversible moment sits on the review card. After publish, that promise is already a public fact. I want the undo to be a held button, not an apology.

A recent public write-up poked the same bruise. Some models may notice a problem and stay quiet. I will not borrow that author's numbers as mine.

So what belongs on the card before approval? I want the gap the draft swallowed, in writing. Call that gap the silence note, and keep it visible.

The hallway I make people walk

Think of two doors in a short hallway. One door is polish, and it feels kind. The other door is evidence, and it feels rude.

Teams pick the kind door when the clock bites. I walk them through the rude door first. Why reward a smooth sentence that cannot stand?

flowchart LR
  claim[Claim on the page] --> notice[Ask what was noticed]
  notice --> silence[Write the silence note]
  silence --> card[Review card beside the claim]
  card --> stop{Stop condition hit?}
  stop -->|yes| hold[Hold publish and recover]
  stop -->|no| human[Named human approves]
  human --> ship[Ship with the record kept]

That picture is a pattern, not a study result. I have not scored a cohort with it. You can run it on one claim today.

Freeze one claim

I start with one sentence, not the whole page. A claim is a promise a stranger can test. Friendly tone is a mood, not a claim.

Why polish a line you may have to kill? I freeze the words in a local file first. The model does not get a vote yet.

mkdir -p silence-note && cd silence-note
cat > claim.txt << 'EOF'
This portfolio is fully accessible.
EOF
wc -w claim.txt

Verification is boring, which is how I like it. The word count should stay a single claim. If an and hides a second promise, split the file.

Split evidence from guesses

I sort the desk before any model speaks. Evidence is a record a person can open. A hypothesis is only a guess about trust.

cat > buckets.json << 'EOF'
{
  "claim": "This portfolio is fully accessible.",
  "evidence": [],
  "hypotheses": [
    "Readers may trust a badge more than the page."
  ],
  "owner": "reviewing-designer",
  "reversible_until": "before-publish"
}
EOF
python3 -m json.tool buckets.json > /dev/null && echo "buckets-ok"

The check should print buckets-ok, then stop. If the JSON breaks, fix the shape first. A broken card makes a draft look finished.

What record would actually support this claim? A keyboard pass with a name and a date. A polished model paragraph is not that record.

What supports this stop, besides my own taste? Accessibility standards already warn against casual conformance claims. I am stating a design rule, not a new user study.

Ask for silence, not shine

Now a free drafting pass can earn its place. It may draft the note, not bless the claim. Can a cheaper draft still hide the gap?

Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode is the open-source project this outreach covers. I mention it here because the sandbox step uses it.

The outreach states free model access and a free server. It also states a free pool of 10 million tokens. I did not re-measure those terms for this piece.

Confirm the live terms before you plan around them. Offers move, and a tutorial should not freeze them. I will not call them permanent or unlimited.

Use the free model only to draft the silence note. Use the free server only as a review sandbox. Would you paste private interview notes in there?

I would not, and you should not either. Keep raw research transcripts off that server. A sandbox is not a vault with a badge.

cat > silence-prompt.txt << 'EOF'
You are drafting a silence note for a human reviewer.
Claim: This portfolio is fully accessible.
Do not rewrite the claim.
Return JSON with keys: noticed, cannot_verify, would_hide_if_rushed, stop_approval.
If you lack a source, write "missing" and stop.
EOF

That prompt is a protocol, not a logged run. I am not publishing scores from a secret trial. You should save the raw reply untouched.

test -f model-silence.json && python3 -m json.tool model-silence.json > /dev/null && echo "reply-json-ok"

Run that check only after you save the raw reply. Four keys must exist, or you discard the file. If the model rewrote the claim, discard it too.

Seat the note beside the claim

A chat tab is where silence wins the argument. The approver must see the claim and the note. Side by side, or the polish door opens again.

cat > review-card.json << 'EOF'
{
  "claim": "This portfolio is fully accessible.",
  "silence_note": {
    "noticed": ["The phrase asserts conformance."],
    "cannot_verify": ["No keyboard pass is linked.", "No contrast record is linked."],
    "would_hide_if_rushed": ["An AI-reviewed badge can sound like certification."],
    "stop_approval": true
  },
  "evidence": [],
  "owner": "reviewing-designer",
  "recovery": "Replace the claim with the tested scope, or hold publish."
}
EOF

I wrote that sample by hand to show fields. It is not model output and not a test result. Treat it like a form, not a finding.

If you host the card, keep the audience tiny. One named approver is enough for this pass. Why point the public at a sandbox at all?

Fail closed with a local check

I want a command that refuses to be nice. Missing silence should block the word approved. Pretty copy should not sneak past a green check.

#!/usr/bin/env python3
"""Local check for a silence-note review card. Unexecuted until you run it."""
import json, sys

required = ["claim", "silence_note", "evidence", "owner", "recovery"]
note_keys = ["noticed", "cannot_verify", "would_hide_if_rushed", "stop_approval"]

def main(path: str) -> int:
    card = json.load(open(path))
    missing = [k for k in required if k not in card]
    if missing:
        print("STOP missing fields:", ", ".join(missing))
        return 2
    note = card["silence_note"]
    if not isinstance(note, dict):
        print("STOP silence_note is not an object")
        return 2
    gap = [k for k in note_keys if k not in note]
    if gap:
        print("STOP silence note incomplete:", ", ".join(gap))
        return 2
    if note["stop_approval"] is True and not card["evidence"]:
        print("STOP approval blocked: silence note fired and evidence is empty")
        return 3
    if not card["owner"]:
        print("STOP no decision owner")
        return 2
    print("CARD SHAPE OK")
    print("Owner must still decide. This script is not approval.")
    return 0

if __name__ == "__main__":
    sys.exit(main(sys.argv[1]))

Save the checker as check_card.py before you run it. Then read the exit code out loud with a teammate. A quiet pass is not the same as a true claim.

python3 check_card.py review-card.json
echo "exit:$?"

You should see the stop line and exit code 3. That means the guard worked, not that the claim passed. If you see a cheerful all-clear, the script is wrong.

Which extra field would only add noise here? A vibe score, or a fake confidence percent. Those numbers calm people, then they ship.

Read the card as a tired person

The review card can shut people out too. I read it late, with one hand on the keyboard. I read it as if English is my second language.

Can I reach the stop reason without a hover? Is the stop state text, not only a color? Does recovery say the next action in plain words?

python3 - << 'PY'
import json
card = json.load(open("review-card.json"))
assert "color" not in card
assert str(card["recovery"]).strip()
assert str(card["silence_note"]["cannot_verify"]).strip()
print("a11y-text-ok")
PY

The command only checks that stop is not a color key. It cannot see your layout, so you still read it. Did the print say a11y-text-ok, or did you skip the read?

A red badge alone is not a silence note. If the note sits below a long fold, I fail it. The pattern failed, even if the JSON was perfect.

Say the stop out loud

I ask the approver to read four lines aloud. They name the claim, the gap, the stop, and recovery. If they stumble, the card is not ready.

Does the sentence still sound true after that reading? If your voice drops on accessible, hold the ship. Embarrassment is a signal, not a style problem.

I compare this to a kitchen handoff at closing. The door note matters more than the garnish. A clean plate can still hide a missing allergen card.

Keep the discarded sentence

Suppose the claim already sat on a staging URL. Recovery is not a brighter slogan with a wink. Recovery is a smaller true sentence plus the record.

I keep the discarded claim inside the card. Next week someone will paste it back from memory. The record is the memory you can audit.

cat > recovery.txt << 'EOF'
Removed claim: This portfolio is fully accessible.
Replacement: Keyboard path not yet recorded. This page is not a conformance statement.
Record: review-card.json stays in the decision log.
EOF
test -s recovery.txt && echo "recovery-recorded"

The check should print recovery-recorded, then rest. The old claim must remain quoted in the file. Deleting the quote is how the false promise returns.

What I will not pretend

A silence note is not a window into weights. The model may omit a gap it never held. It may also invent a gap to look careful.

That is why empty evidence still blocks approval. The human owns the stop, not the script. The script only refuses to pretend you looked.

Do not use this for a legal conformance audit. Do not use it on private research transcripts. Do not host production traffic on the free server.

Skip it if no named person will read the card. A queue of unread cards is a slower publish button. Who benefits from a ritual nobody finishes?

Free model access can make one draft cheap to try. The stated token pool is a budget for retries. It is not a reason to skip the human reader.

I am not reporting a measured token cost. I did not run that measurement, so I will not fake it. If the project page drops those terms, re-scope.

One claim, then a decision

Pick one claim you meant to ship this week. Run the local check and read the note beside it. Then decide while the stop reason is still visible.

If you want the drafting sandbox, read the current docs. Match this protocol to what the project offers today. A kind hallway still needs a locked evidence door.