Separate the appeal from the decision

When someone tells you a system has an appeals process, ask one question before you believe them: who decides the appeal? Not what the button is labeled, not where it sits in the flow — who, or what, actually re-decides. Because in a large fraction of automated systems the honest answer is that the appeal is decided by the same thing that made the original call. The applicant clicks request review, the request goes back through the same model, drawing on the same inputs, applying the same thresholds, and it returns — reliably, predictably — the identical answer. The interface calls this a second look. It is nothing of the kind. It is the first look, run twice, and the second run was never in any doubt.

This is a build decision, and like most of the ones that matter it gets made by default and in the wrong direction. Appeals are expensive, so the cheapest thing to ship is an appeal that reuses everything: the same service, the same data, the same code path, perhaps with a flag set to is_appeal = true that changes a log line and nothing else. It passes every test you would think to write, because it behaves exactly like the thing it is testing. And it satisfies the letter of the requirement — there is an appeal, users can file one, filings are processed. What it does not do is the one thing an appeal exists to do, which is give the original decision a chance of being wrong.

The appeal that is an echo

An appeal is a review, and a review has a precise job: to catch errors in the thing being reviewed. Everything about how you build it should follow from that job. And the moment you look at it that way, the same-model appeal collapses, because a review that shares the reasoning of the original cannot catch the original's errors — it embodies them. If the first decision was wrong because a threshold was miscalibrated, the appeal running against the same threshold is wrong in exactly the same way. If the first was wrong because it never saw a document, the appeal that queries the same store never sees it either. The error is not a bug the second pass might notice; it is a shared premise the second pass is built on. You cannot proofread a page by photocopying it.

The failure comes in more than one costume, and some are subtler than the literal re-run. A team routes appeals to a human — good, on the face of it — but gives that human no authority to overturn, only to explain. The reviewer reads the file, confirms the system followed its rules, and affirms. That is not a review; it is a customer-service function wearing a review's clothes, and it will affirm at a rate that has nothing to do with whether the decisions were right. Another team sends the appeal to a different model, which sounds independent until you notice it reads the same features and was trained to agree with the first. Independence of hardware is not independence of judgment. What all these share is a decider that has no real capacity to reach a different conclusion — and a review that cannot reach a different conclusion is not a review at all.

An appeal decided by the system that made the decision is not a second chance; it is the same verdict, read back to you more slowly.

Independence is the point

So the directive is direct: give the appeal a decider that is genuinely independent of the original, and independence has to be earned along every axis the first decision ran on. A different person is not enough if they see only what the machine saw and are structured to defer to it. Different code is not enough if it reasons the same way over the same data. Independence means the second look can rest on information the first pass could not or did not consider, can apply judgment the first pass did not, and — this is the load-bearing part — has the actual authority to reverse the outcome. An appeal that cannot overturn is not an appeal. It is a delay before the same answer.

The strongest form is the one courts and serious institutions have always used: a human with standing and authority, looking at the case fresh, empowered to substitute their judgment for the system's. That is what makes the contest real — the person contesting is no longer arguing with the wall that turned them down; they are putting their case to someone who can move. But independence is not only about who decides. It is about what they decide on. Give the reviewer the ability to pull in facts the automated pass never had — the context the applicant supplies on appeal, the document the first pass could not read, the circumstance no feature encoded. An independent decider working from the identical inputs is only half independent, and it is the missing half that catches errors.

Whatever you build, record the original decision and the independent review as two distinct events, each with its own basis, its own decider, its own moment. Not one record amended in place, which quietly erases that a contest happened. Two accounts, so that anyone looking later can see what was decided, that it was genuinely re-decided, and by whom — the shape of a real appeal made legible in the record itself. The Decision Receipt for the appeal should stand on its own, not lean on the receipt for the decision it reviewed.

Scale the independence to the stakes

Here is the honest tension, and it is real: full independence is expensive, and not every decision can carry a human reviewer with authority to reverse. A platform making millions of low-stakes calls cannot convene a fresh judgment for each one, and pretending otherwise is how you end up with an appeals process that exists on paper and collapses in practice. So scale the independence to the stakes. For routine, reversible, low-harm decisions, a lightweight but genuinely distinct check may be proportionate — a different rule set, a different data pull, a sampling review, something that can actually diverge from the original even if it is not a person. For consequential decisions, the kind that deny someone housing, credit, care, or standing, the second look has to be a human with real authority to overturn, considering information the machine did not.

The rule that must not bend, at any scale, is the one this whole directive turns on: never let the appeal collapse into the decision it is meant to check. Proportionality governs how much independence you invest, not whether the appeal is independent at all. A lightweight check that reuses the original's logic is not a proportionate appeal; it is no appeal, dressed down. And watch the failure mode that survives even a human reviewer with authority — the rubber stamp, where the person has the power to overturn but never exercises it, because they see only the machine's summary and absorb its framing. Independence you do not use is independence you do not have. Structure the review so the reviewer can, and sometimes does, disagree — different inputs, different vantage, a genuine mandate to reach a different answer — or you have spent the cost of a review and bought the reassurance of one without the substance.

The test is simple to state and uncomfortable to run. Take a decision your system got wrong — a real reversal, or a plausible one — and trace it through your appeals path. Does anything on that path have both the information and the authority to catch it? If the answer is that the appeal would have re-confirmed the error, because it shares the decider or the inputs or the logic that produced it, then what you have labeled an appeal is a mirror. Build the second look so it can look back at you and say no.

— Dispatches · Summit Cognitive