Shared Signal Given One Cause

What goes wrong

One status code, symptom or error branch is produced by several different causes, but the handler — a catch block, a retry classifier, an operations checklist — treats it as always meaning one cause and applies that cause's fix, so the other causes get the wrong handling: a temporary failure ends retries, or an operator is sent to a harmful repair.

Example

Every 401 is handled as 'token expired, refresh it'; a locked account also returns 401, so the client refreshes in an endless loop.

Not to be confused with

The information to tell the causes apart is there; the rule collapses them. Not diagnostics thrown away (Discarded Failure Diagnostics), not a cancellation treated as failure (Swallowed Cancellation), and not a normaliser merging distinct empty inputs (Empty states lose their meaning).

Discovered by

@sks24git GitHub

Field notes · 33

@sks24git2026-11-06

A ground-truth label read "hidden, and not by the author" as a moderator's verdict, but erasure and the author's own discard hide posts too. Each one counts as a severe miss, and every setting looks like it fails.

Label from the event that decided it, not a shared state. A state shows the outcome, not who chose it.
Keep paid batch work out of a request. A timeout loses the result; the retry pays again.

@sks24git2026-11-05beat 4 review rounds

A one-time link was marked "used" both when it was applied and when a later change cancelled it. A double click on Confirm then told the user nothing had changed, though the first click had already applied it.

Give each end of a token's life its own mark. "Applied" and "cancelled" must not share one flag.
Make a repeated submit report the first one's result. Users double-click.

@sks24git2026-11-04beat 2 review rounds

A cleanup rule read zero calls to the model as proof that a worker's network was broken. The same zero shows up in any outage of the model service, so one blip would delete every live session.

Prove the cause, not the symptom. A zero counter fits many failures; check that healthy peers saw more than zero.
Never act on a fresh usage count. Totals lag, so wait or repeat first.

@sks24git2026-11-04

An error message tells the client to just retry, because the commit was fetched once before. But the fetch also uses a branch name the client typed, so a typo fails the same way on every retry, forever.

Check every input a retry reuses before you promise it works. One unchecked field turns the retry into a loop.

@sks24git2026-11-04beat 1 review round

A fallback for a failed request also fired on a rate-limit error, sending a second request right after the server said slow down. Under load every message makes two calls and the penalty grows.

Never fall back on a rate-limit error. Back off instead; a retry in another form is still a retry.
Update every reader when you add a record kind.

@sks24git2026-11-03beat 3 review rounds

A fallback for an outage reused the last good marker, but any refusal, such as a rate limit, deleted it first. The next outage then found nothing to fall back to and built on the broken head it was meant to avoid.

Sort errors into outage and refusal with one shared rule. Two classifiers drift and disagree.
Give every fallback copy an expiry. A copy without one outlives the truth it recorded.

@sks24git2026-11-03beat 1 review round

A retry queue treated every client error as a bad message and deleted it. When the access token expired, one pass threw away two days of queued events.

Retry on auth and not-found errors. Only a rejected body is final.
Mark the attempt before the slow call. Otherwise a slow server looks like a dead worker.

@sks24git2026-11-03beat 2 review rounds

A fix made every unexpected error stop the upload, so it would not quietly drop a file. It also stopped the whole batch for a path that could never be sent, like a locked folder, where the old code just skipped it.

Sort errors by what the item could become. Stop for a file you would send; skip one you never would.
Write the error table before the fix. Flipping loud to quiet each round is the same bug.

@sks24git2026-11-01beat 1 review round

A shell hook lets a push through only on the tool's own could-not-run code, but a missing runtime exits with a different code. On machines where the runtime is missing from the hook's path, every push is blocked.

Fail a gate only on the code that means fail. Every other exit means the check did not run.

@sks24git2026-10-30beat 4 review rounds

A broad catch meant to turn bad input into a clean stop also caught a timeout from the tool that reads that input. A slow lock then looks like the author's fault, and a healthy run is rejected for good.

Let infra errors pass a fail-closed catch. Only the parse step should become a verdict.
Test the path that rebuilds the output. A late rewrite can drop the one warning you added.

@sks24git2026-10-29beat 2 review rounds

A boot rule skips setup whenever the stored version mark differs from its own, as if a deploy were in flight. Restore an older backup and the mark differs too: servers skip setup and run new code on old tables.

A marker that two causes can write cannot tell you which one did. Add the signal that tells them apart, or act the same way in both cases.

@sks24git2026-10-29

An import mapped every unique-index violation to one generic "conflict", even a clash with an unrelated row. The caller read it as "maybe committed", kept a lock on forever and nudged an operator to delete the only copy.

Check a known duplicate by name before the insert. A raw unique violation can't say whose row it hit.
Make "outcome unknown" rare and narrow. Each one parks data behind a manual step.

@sks24git2026-10-27beat 3 review rounds

An error mapper turns every validation refusal into 'reason required' and drops the server's own message. A refusal about the date shows as a missing reason, so the operator keeps retyping a reason that was fine.

Show the server's words for a refusal. A fixed label hides the field that failed.
Map a status to one text only when it has one cause. Otherwise keep the detail.

@sks24git2026-10-13beat 3 review rounds

When no commits fall in the window, the base lookup returns the head itself and the diff comes back empty. Users are told only docs or tests changed, when nothing changed at all.

Tell "nothing happened" apart from "nothing qualified". One message for both sends users the wrong way.
Check for an empty range before you filter it. Empty input passes every filter.

@sks24git2026-10-11beat 1 review round

A retry rule reads every conflict status as outcome unknown, yet that status also marks a plain refusal before money moves. One declined request then pins the form to replaying it until reload.

Let the server say whether money moved. A status code groups refusals with retries.
Mock errors with their real code and status. A convenient one proves the opposite.

@sks24git2026-10-04beat 3 review rounds

A merge gate refuses for two reasons, 'not reviewed' and 'review still running', and the UI maps both to one 'review now' button. Pressed while the review runs, it starts a second paid review of the same diff.

Branch on why a gate refused, not that it refused. One button for every refusal sends some users the opposite of the gate's advice.

@sks24git2026-10-02

A probe capped its own call at 300 s, then read the 000 it got at 300 s as the platform dropping the request. The client's own deadline was filed against the server.

Check your own timeout before blaming the far end. A cut at exactly your deadline is yours.

@sks24git2026-09-29

A "value" state was derived as not-open and not-closed, which every timed-out vote also is while it waits for the next pass. The page tells viewers everyone voted and reloads every five seconds until the pass runs.

Derive a state from the event that causes it, not from what it is not. "Neither A nor B" catches every other path too.

@sks24git2026-09-24

A "phase record complete" flag that meant all phases on one path and only the last phase on another was used to excuse short runs. Runs that skipped their first phase came back as complete.

Check what a flag means on every path before you branch on it. The same name can carry a weaker promise elsewhere.

@sks24git2026-09-19beat 2 review rounds

A refusal taxonomy was built from the handler's own checks and forgot a request can be rejected before it reaches the handler. A bare 401 from the edge was filed as "may have committed", and the lock never released.

Give every unknown state an operator exit. A retry-only exit wedges on the first unretryable path.
Classify by what a reply proves. No error field means the handler never ran: a definite no.