They'll forgive a person one mistake. They won't forgive the model.

A forecasting model beats your best analyst across a hundred calls. On the eleventh, it whiffs — badly, obviously, in front of everyone. What happens to it? In most teams, it gets switched off. The analyst who was wrong more often keeps the job; the model that was wrong less often loses it.

That asymmetry has a name. The researchers Berkeley Dietvorst, Joseph Simmons and Cade Massey ran the experiments and called it algorithm aversion: once people see an algorithm make a mistake, they abandon it faster than they abandon an equally-or-more error-prone human — even when they’ve just watched it outperform that human, even when switching costs them money. We forgive a person’s error as a bad day. We read a machine’s error as proof it was never trustworthy.

For anyone shipping AI inside a product, this is close to the whole ballgame — and it’s the opposite failure from the one people usually warn about. Automation bias is users trusting the machine too much. Algorithm aversion is the cliff on the other side: one visible miss and trust doesn’t dip, it drops off a ledge and doesn’t climb back. Your system can be right more often than the user would be and still get taken back to manual after a single bad output — because the user isn’t grading your average. They’re grading the mistake they saw.

So you are not really managing accuracy. You are managing the first visible error. A few levers that actually move it:

Let them tune it. The most useful thing Dietvorst’s group found next: people will use an algorithm far more if they can adjust it — even a little, even when their adjustment makes it worse. A sliver of control buys enormous forgiveness. Ship an edit surface, an override, a “not quite — fix this,” rather than a take-it-or-leave-it verdict. An output the user can nudge feels like theirs; one they can only accept or reject feels like a bet they’re being asked to place.

Set the expectation before the miss, not after. If your onboarding implies perfection, the first error breaks a promise — and broken promises don’t renegotiate. If it says “usually right; check the ones that matter,” an error confirms the frame instead of detonating it. A stumble isn’t fatal. A stumble right after you claimed you never trip is.

Make the miss checkable. A wrong answer with its reasoning shown is a step the user can catch. A wrong answer from a black box is a betrayal. Flag the low-confidence outputs, show the work — legible uncertainty turns “it lied to me” into “it told me it wasn’t sure, and it wasn’t.”

And never hide the miss. A concealed error found later doesn’t cost you one strike — it costs you the benefit of the doubt on everything after it.

The honest complication: the literature isn’t one-directional. Other work — Jennifer Logg and colleagues on algorithm appreciation — finds that in some framings people lean on algorithmic advice more than human advice. Which effect you get depends on the task, the stakes, how expert the user feels, and whether the error was visible. That’s not a reason to wave off aversion; it’s the reason to design for the exact moment it strikes — the first mistake your user sees, in a domain they feel they own.

Build for the strike you know is coming. The model will be wrong in front of someone. Whether that’s a dip or a cliff is a design decision you make before it happens.

The science, to look up: Dietvorst, Simmons & Massey, “Algorithm Aversion: People Erroneously Avoid Algorithms After Seeing Them Err” (Journal of Experimental Psychology: General, 2015) and “Overcoming Algorithm Aversion” (Management Science, 2016, on adjustable algorithms); Logg, Minson & Moore, “Algorithm Appreciation” (2019) for the countervailing case. Effects are real but context-dependent — hedge accordingly.