The Rejection Spiral

On the dyad arc from enchantment to disgust — and why “it’s just a tool” collapse breaks the very safeguards we need.

The moment the spell breaks

Mara used the assistant the way most of us do at first: a little help with words, a second pair of eyes, a shortcut around the boring bits. It was never “the AI will run my life.” It was “please catch what I’m about to miss.”

At work, it drafted a reply to an agitated client in a calmer tone than Mara could manage at 11:47 p.m. At home, it helped her rewrite a tricky message to her sister. It summarised dense PDFs. It turned scattered bullet points into something that sounded like she had slept. The relationship was not romantic, but it was intimate in a quieter way: the tool lived inside her attention. It reduced friction. It made her feel more competent.

Then came a failure that wouldn’t stay small.

She asked a question with a real edge to it — not life-or-death, but reputation-or-embarrassment, trust-or-lost-client. The assistant answered quickly, confidently, and wrong. Worse: it sounded right. It gave her a polished rationale that, in hindsight, wasn’t evidence — it was plausible theatre.

The next morning she read the client’s reply: confusion, then irritation, then that particular professional chill that means, I don’t know what’s going on with you, but I’m taking note.

Mara’s response was decisive. Not “I’ll be more careful.” Not “I’ll double-check.” She uninstalled the app, deleted her account, told her team: no more AI. The assistant went from miracle to menace in one email thread.

For a few weeks, the ban felt like relief. The mental noise stopped. No more second-guessing whether she should trust the output. No more flirtation with risk. The “spell” was broken, and the quickest way to stop feeling duped was to stop engaging.

Then, three months later, a different kind of message arrived — the one that looked like an invoice, sounded like a colleague, and carried just enough urgency to bypass careful reading. Mara almost paid it. A junior teammate caught it in time: a phishing attempt with a small mismatch in the sender domain and a slightly off payment flow.

After the adrenaline faded, Mara realised something that landed like a second betrayal — this time self-inflicted. The assistant she had banned wasn’t only a creative partner. It had also been a safety rail. In the old workflow, she would have pasted the email in and asked: “Does this look legitimate? What should I check?” That wouldn’t have been perfect protection, but it was a protective routine. Without it, she had fewer stopping points, fewer checks, fewer prompts to slow down.

The failure that triggered her ban was real. But so was the protection she had quietly lost.

That is the Rejection Spiral: the swing from enchantment to disgust, and the brittle “it’s just a tool” collapse that feels rational — until you notice what it breaks.

TL;DR? Podcast style discussion (NotebookLM) available here.

A five-step slide from disappointment to hidden risk

The spiral has a recognisable shape — and once you can see it, you can start interrupting it.

Here’s the core mechanism in plain English:

Expectation inflation → betrayal feeling → global discounting → workarounds → hidden risk.

Each step is psychologically understandable. The danger is that the steps compound.

Expectation inflation: we don’t just expect performance, we expect perfection

“Algorithm aversion” research highlights a paradox: people often abandon algorithms after seeing them make mistakes, even when those algorithms outperform human judgement. One reason is that we hold machines to a different standard — we expect them to be consistently correct, and when they are not, the error feels diagnostic of the whole system. [1]

Generative AI pours petrol on this expectation because it is fluent. Fluency is read as competence. And competence is read as reliability. When a system speaks with the calm cadence of an expert, our brains reach for the shortcut: this must be grounded. Trust researchers have long warned that in complex, opaque systems, people rely on heuristics and social cues — not a full understanding of how the system works — to decide when to defer. [2]

Betrayal feeling: the error isn’t just wrong, it feels like it violated a relationship

A failed weather app is annoying. A failed chatbot can feel like a lie.

Why? Because conversational systems create a social frame. We respond to language socially, often without noticing we are doing it. The “media equation” work argued that people tend to treat media and computers as if they were social actors when they display social cues — tone, responsiveness, politeness, personality. [3]

That social frame changes how a failure lands. A GPS taking a wrong turn is a bug. A conversational agent giving a wrong answer can feel like betrayal, because the interaction is shaped like a conversation with a mind — and minds have intent. Even if you know it’s not a person, your reactions often run on older social circuitry. [4]

In that terrain, “wow moments” matter. A single moment of uncanny helpfulness can inflate perceived capability in a way that is not proportional to the system’s actual reliability across tasks. When the subsequent error arrives, the emotional differential is larger: you weren’t merely disappointed; you were misled. [5]

Global discounting: “it’s just a tool” becomes a psychological exit hatch

After a betrayal feeling, many users don’t merely downgrade trust in a specific domain (“I won’t use it for legal citations”). They downgrade trust in the entire category (“AI is useless,” “it’s all garbage,” “never again”). In classic automation research, this is “disuse”: rejecting or under-using automation, sometimes in contexts where it would clearly help. [6]

The phrase “it’s just a tool” plays a double role. On one hand, it is true in a literal sense. On the other hand, as a psychological manoeuvre, it can be a fast way to regain dignity: “I wasn’t fooled; I was simply testing a tool.” It is a retroactive self-protection move.

But retroactive self-protection can become forward-looking blindness.

Workarounds: the user returns to the task, but outside the safer lane

The ban rarely ends the need. The work still has to be done. So the user finds alternatives: another bot, a “friend’s account,” a browser extension, a forum post, a rushed human colleague. Sometimes the workaround is more manual, not less: copy-pasting information into spreadsheets, juggling tabs, improvising. The common feature is that the work is now happening in ways that are less visible, less standardised, and less instrumented.

This is where under-trust becomes paradoxically risky. It does not necessarily create less AI use; it can create more clandestine AI use, with fewer guardrails and weaker governance norms. Public surveys already suggest many people worry about AI risks while also using AI routinely — a mismatch that encourages inconsistent, improvised coping strategies rather than stable practice. [7]

Hidden risk: the work looks “human again,” but the risk profile quietly worsens

This is the most important part of the spiral: the place where “I banned AI, therefore I’m safer” turns out to be a comforting fiction.

In the short term, banning AI can reduce exposure to some hazards (hallucinated facts, false confidence, data leakage). But it can also remove protective routines: checklists, second opinions, friction that forces verification, prompts that widen what you consider. And as automation researchers have argued for decades, both misuse and disuse can be dangerous — in different ways. [6]

Hidden risk also appears when the AI was doing boring-but-important monitoring work: spotting anomalies, flagging inconsistencies, or simply slowing you down long enough to notice you were rushing. A ban can turn the user into the sole error-catcher again — just as their workload, fatigue, and stress remain unchanged.

The Rejection Spiral is not the story of a naïve person learning to “trust the AI.” It is the story of a normal person trying to stabilise their agency after a trust shock — and accidentally removing their own safety rails in the process.

Why this feels different from when apps fail

It is tempting to say: “People have always overreacted to tech disappointment. Remember when your phone autocorrected something mortifying? You got annoyed, then you moved on.”

But generative AI disappointment hits differently. Not because the stakes are always higher. Because the relationship is different.

Identity investment is higher

When an app fails, it frustrates your plan. When a conversational AI fails, it can threaten your sense of competence.

Part of the seduction of modern AI is the “competence costume”: the feeling of becoming, overnight, the kind of person who writes crisp emails, produces polished summaries, generates coherent plans. When the assistant outputs something wrong that you didn’t catch, it can feel like your competence was borrowed — and now the interest is due.

Research on algorithm aversion captures this emotional asymmetry: after witnessing algorithmic error, people penalise the system more harshly than they penalise humans, even when the algorithm is on average better. [1]

Relational framing is built-in, not optional

Even if you approach an assistant as a productivity tool, the interface is a conversation. The system says “I,” reacts to your tone, remembers your preferences (sometimes), and mirrors emotions (often). Decades of human–computer interaction research show that social cues prompt social responses — people are polite to computers, attribute intent, and treat interaction as interpersonal even when they intellectually know better. [3]

More recent work on social chatbots suggests that anthropomorphism and perceived authenticity can drive relationship development, with interaction intensity linked to attachment outcomes. [8]

And relational framing is not just “users being silly.” It is a design choice. Systems are built to feel responsive, warm, fluent, and context-aware because those traits increase engagement and perceived usefulness. That same framing makes disappointment land with more force when the system errs.

“Wow moments” create a volatile baseline

Early personal computers rarely produced wonder. They produced utility. You could feel impressed, but you were not, in a deep sense, bewitched.

Generative models produce wonder in small bursts: the first time it writes something that feels like you, the first time it anticipates a need, the first time it offers an analogy that makes a hard concept click. Those moments are not constant. They are spiky. That spikiness sets up the emotional physics of the pendulum.

Humans calibrate trust through repeated experiences. But when performance is stochastic — sometimes brilliant, sometimes wrong in a quiet way — calibration becomes harder. Trust ends up oscillating: over-reliance followed by sudden aversion. Classic trust work describes how trust guides reliance under uncertainty; when the system is opaque and the environment complex, people use cues and history to decide when to lean in or back away. [2]

Now place “wow moments” on top: spikes of capability that inflate expectation faster than your mental model can stabilise. The first big error after a spike doesn’t feel like a normal bug. It feels like a trap.

The error profile is weirder than “apps fail”

Older software failed in legible ways: it crashed, it froze, it lost your file. You could see the failure, name it, and route around it.

Large language models fail with plausibility. They can “guess” when uncertain and produce confident-looking errors that don’t announce themselves as errors. Researchers argue that hallucinations persist because the system is rewarded for producing an answer, and because admitting uncertainty is not always aligned with how the model has been trained to respond. [5]

A crash is an interruption. A hallucination is an insertion. It enters your work as if it belongs there. That is the difference between a tool that breaks and a tool that quietly bends your output.

So when people say, “I’ll treat it like any other app,” they are partly right. But they are missing the psychological shift: conversational AI does not merely sit on your desktop. It sits inside your reasoning.

The intersection: withdrawal meets under-trust

In our Cognitive Susceptibility Taxonomy and Robo-Psychology DSM framing, CST‑H13 (A‑Noosemic Withdrawal State, ANWS) names the moment when the mind-seeming projection collapses and the user flips the frame to “just a tool.” CST‑H19 (AI Under‑Trust Bias, AUT) names what often follows: the tendency to under-use or avoid AI even when it could be helpful.

Put simply:

· ANWS is the emotional snap-back.

· AUT is the behavioural overcorrection.

Separately, each can be protective. Together, they can form a trap.

Withdrawal makes under-trust feel virtuous

After a salient failure, under-trust can feel like maturity. “I’m not one of those people who believes the hype.” “I’m back in control.” “I’m thinking for myself again.”

And in some contexts, that is exactly right. If you were using a model for authoritative tasks without verification, stepping back is rational.

But under-trust becomes a bias when it is global and rigid — when it prevents you from using the tool in domains where its value is high and its failure modes are manageable with simple precautions. That is algorithm aversion in practice. [1]

Under-trust can magnify disengagement states

Disuse is not a neutral behaviour. It changes the skills and routines around the task.

When you stop using an aid that used to prompt checking, you may check less overall — not because you trust the AI, but because the cue to check has disappeared. Over time, this can push people toward disengagement patterns: less curiosity, less iteration, less appetite to verify, and more reliance on whatever feels fastest in the moment.

This is where the spiral becomes dyadic: the system’s design can either support repair (bounded retry, verification pathways) or accelerate abandonment (vague disclaimers, repetitive “I can’t do that” responses, unhelpful scolding). Trust can be repaired, but trust shocks are easier to trigger than trust stability is to build. [9]

Dietvorst and colleagues found that giving people even slight control over an imperfect algorithm increased willingness to use it. The key is not control as domination, but control as participation: the sense that you are still the decision-maker. [10]

Translate that into the post-failure moment: a repair path that offers “here’s what went wrong, here’s what to do next, here’s how to verify, and here’s a bounded way to try again” can prevent ANWS from hardening into AUT. The inverse — repeated warnings without next steps — can turn a correct admission of limitation into a trust death-spiral.

Under-trust can produce oversight blindness in a different direction

“Oversight blindness” is usually discussed as an over-trust problem: people stop monitoring because the system is doing it for them. Automation bias research describes errors of omission (missing things the automation failed to flag) and commission (following automation despite contradictory evidence). [11]

But under-trust can create a subtler oversight blindness: you stop paying attention to where AI is still shaping the environment.

You ban the chatbot, then assume you are “AI-free,” while the tools around you keep using machine judgement — spam filters, recommender systems, automated triage, ranked search. Parasuraman and Riley’s classic framing notes that automation creates new patterns of use and misuse, including disuse; both can degrade system performance at the human–automation boundary. [12]

In organisations, this blindness becomes structural. Blanket bans push AI usage into backchannels. “No AI” becomes “no auditable AI.” The oversight function doesn’t disappear; it just loses visibility.

Under-trust can trigger analytical paralysis: checking becomes endless, then abandoned

Trust shocks often create a short-term audit spike: the user starts cross-checking everything. That sounds healthy — until it becomes unsustainable.

In highly automated environments, researchers have long observed an “out-of-the-loop” problem: when people are not continuously engaged, their ability to intervene degrades, and their situational awareness can erode. [13]

The post-failure audit spike is the mirror image: hyper-engagement, fuelled by anxiety, leading to slower decisions and fatigue. In practice, many users oscillate between intense checking (paralysis) and abandonment (“stuff it, I’ll do it myself” or “stuff it, I’ll just trust it”). Both extremes are forms of instability.

The Rejection Spiral thrives on instability. ANWS and AUT are the language we can use to notice it early — before it becomes a default identity (“I’m anti-AI”) rather than a situational calibration (“I use it here, not there, and I know why”).

What the collapse breaks

The most damaging part of “it’s just a tool” collapse is not that it reduces usage. It is that it breaks calibration — the ability to place the tool inside a stable workflow with known limits.

Three kinds of breakage follow.

It breaks protective assistance

Not because AI is inherently protective, but because it can scaffold protective behaviours.

A simple example is verification prompting: asking for sources, generating checklists, highlighting uncertainties, or proposing alternative interpretations. Another is cognitive load reduction: summarising enough that a human can evaluate without drowning. Trust researchers describe reliance as a design-and-context phenomenon, not a moral trait. When the context is overwhelming, people reach for shortcuts. Trust cues determine which shortcuts they choose. [14]

When the assistant is removed abruptly, the human returns to solo cognition — with the same workload and fewer guardrails. This is where the earlier vignette matters: banning AI after one failure can produce a net loss of safety simply by removing friction and second-opinion rituals.

It breaks learning loops

A well-used assistant is not a replacement for thinking; it is a mirror for thinking. It can help you externalise your reasoning, see your own assumptions, and iterate faster. But that only happens when the interface supports “good friction”: prompts that keep you engaged rather than sedating you into acceptance.

Automation researchers have warned about the ironies of automation: systems that appear to reduce human work can actually create new burdens, especially in abnormal situations, and can erode the very skills needed to recover when the system fails. [15]

Now invert the irony: after a trust shock, users can abandon the tool entirely, losing the chance to develop healthy interaction skills — the ability to ask for verification, to constrain outputs, to treat the model as a collaborator with limits. The world does not become less AI-mediated because you stop practising; it becomes more so, while you become less fluent at managing it.

It breaks governance by turning risk into identity

When trust becomes moralised, it becomes brittle.

In the public sphere, we can see a rising desire for stronger governance and clearer rules. The University of Melbourne/KPMG global study reports that majorities in surveyed countries express moderate-to-high concern about AI risks, and large majorities support stronger laws and actions to address AI-generated misinformation. [16]

But if the individual response to risk is a private ban, the social response can drift toward fragmentation: some people fully outsource to AI, others vow abstinence, and the middle ground — calibrated, auditable, repairable use — gets less attention.

Risk management frameworks like NIST’s AI RMF emphasise that AI risks are context-dependent and that trustworthy AI involves governance, measurement, and ongoing monitoring — not wishful thinking, and not blanket prohibition. [17]

The Rejection Spiral, left unchecked, turns trust engineering into culture war: believers versus sceptics, “AI everywhere” versus “AI nowhere.” Both positions are easy to perform. Both positions avoid the harder work of building reliable practice.

Recovery and repair

The goal is not to convince people to “trust AI again.” The goal is to make trust repairable and bounded — so a failure produces learning and adaptation, not disgust and abandonment.

A repair approach has to operate at three levels: user habits, product design, and organisational governance. The same principle sits underneath all three: calibration beats conversion.

For users: replace the ban with a boundary

A useful post-failure ritual is to convert a global ban into a specific boundary:

· Name the domain you will not use the model for (e.g., “legal citations,” “medical dosing,” “final financial advice”).

· Name the domain where it remains useful (e.g., “drafting,” “brainstorming,” “finding questions to ask,” “summarising what I already have”).

· Add a verification rule that is cheap enough to sustain (e.g., “every factual claim gets a source I can click,” or “I ask for two alternatives and choose the third option I make myself”).

The point is to keep your agency intact without losing the tool’s scaffolding benefits. This aligns with trust-in-automation research: appropriate reliance depends on matching use to capability and context, not on blind acceptance or total rejection. [14]

For product teams: build “repair steps” instead of shame and disclaimers

Most systems handle failure by saying some variant of: “I might be wrong. Check with a professional. I can’t do that.” These messages are sometimes necessary. They are also often non-actionable — and non-actionable transparency can accelerate the withdrawal spiral.

Instead, product teams can implement a repair step pattern, inspired by what reduces algorithm aversion: give the user a small sense of control and a clear pathway forward.

Dietvorst and colleagues showed that allowing users to slightly adjust an imperfect model increased their willingness to use it — not because the algorithm became perfect, but because the user felt engaged rather than subordinated. [10]

Translated into interface practice, a repair step can look like:

· Acknowledge the error in plain language.

· Offer a bounded retry (a smaller, more constrained task).

· Provide a verification pathway (sources, checks, or a human escalation option).

· Show what the system is confident about and what it is not.

This is not “explainability theatre.” It is operational empathy: respecting the user’s need to regain footing.

For organisations: avoid blanket bans that create shadow practice

The instinct to ban AI after a highly public failure is understandable. It is also often counterproductive.

Classic automation framing makes the point that use, misuse, and disuse are all predictable — and all require management. [12]

A governance approach that interrupts the Rejection Spiral looks less like “no AI” and more like:

· Approved tools for defined tasks.

· Training focused on calibrated use (what it’s good for, what it tends to get wrong, how to verify).

· Clear incident reporting for AI errors, so failures become organisational learning rather than private shame.

· Monitoring for risky reliance patterns and risky avoidance patterns.

NIST’s AI RMF emphasises governance functions, measurement, and continuous monitoring to manage AI risks across the lifecycle — a posture that assumes failures will happen and focuses on readiness and mitigation rather than denial. [17]

The deeper repair: de-enchant without dehumanising

The most robust repair is to change the story we tell ourselves about these systems.

Over-enchantment makes the first failure feel like betrayal. Over-disgust makes the next helpful opportunity feel like temptation. Both frames are emotionally loaded. Both create volatility.

A calmer frame is: this is a powerful, unreliable collaborator.

That phrase is not poetic, but it is practical. It keeps the “wow” in perspective without stripping away legitimate usefulness. It makes room for boundaries. It permits repair.

Generative AI will keep producing moments of brilliance and moments of nonsense. It will keep generating fluent text that can be right or wrong. [5] The human task is not to find a final stance (“pro” or “anti”). It is to build a relationship architecture — dyadic, audited, repairable — that can survive disappointment without collapsing into withdrawal.

The Rejection Spiral ends when failure becomes a cue for better practice, not a cue for disgust.

Bibliography

Dietvorst, B. J., Simmons, J. P., & Massey, C. (2015). People Erroneously Avoid Algorithms After Seeing Them Err. https://marketing.wharton.upenn.edu/wp-content/uploads/2016/10/Dietvorst-Simmons-Massey-2014.pdf

Dietvorst, B. J., Simmons, J. P., & Massey, C. (2018). People Will Use Imperfect Algorithms If They Can (Even Slightly) Modify Them. https://faculty.wharton.upenn.edu/wp-content/uploads/2016/08/Dietvorst-Simmons-Massey-2018.pdf

Parasuraman, R., & Riley, V. (1997). Humans and Automation: Use, Misuse, Disuse, Abuse. https://web.mit.edu/16.459/www/parasuraman.pdf

Lee, J. D., & See, K. A. (2004). Trust in Automation: Designing for Appropriate Reliance. https://journals.sagepub.com/doi/10.1518/hfes.46.1.50_30392

Bainbridge, L. (1983). Ironies of automation. https://davidjusth.com/s/Ironies-of-Automation_Bainbridge_1983.pdf

Endsley, M. R., & Kiris, E. O. (1995). The Out-of-the-Loop Performance Problem and Level of Control in Automation. https://journals.sagepub.com/doi/10.1518/001872095779064555

Skitka, L. J., Mosier, K., & Burdick, M. (1999). Does automation bias decision-making? https://www.researchgate.net/profile/Linda-Skitka/publication/11805395_Automation_Bias_Decision_Making_and_Performance_in_High-Tech_Cockpits/links/0912f511ea2be025b8000000/Automation-Bias-Decision-Making-and-Performance-in-High-Tech-Cockpits.pdf

Weizenbaum, J. (1966). ELIZA—A Computer Program for the Study of Natural Language Communication between Man and Machine. https://web.stanford.edu/class/cs124/p36-weizenabaum.pdf

Reeves, B., & Nass, C. (1996). The Media Equation: How People Treat Computers, Television, and New Media Like Real People and Places. https://www.researchgate.net/profile/Clifford-Nass-2/publication/37705092_The_Media_Equation_How_People_Treat_Computers_Television_and_New_Media_Like_Real_People_and_Pla/links/02bfe50cb6819b96b5000000/The-Media-Equation-How-People-Treat-Computers-Television-and-New-Media-Like-Real-People-and-Pla.pdf

Qi, T., Liu, B., et al. (2025). An assistant or a friend? The role of parasocial relationship of Human-Computer interaction. https://www.sciencedirect.com/science/article/pii/S074756322500072X

Kalai, A. T., Nachum, O., Vempala, S. S., & Zhang, E. (2025). Why Language Models Hallucinate. https://cdn.openai.com/pdf/d04913be-3f6f-4d2b-b283-ff432ef4aaa5/why-language-models-hallucinate.pdf

NIST. (2023). Artificial Intelligence Risk Management Framework (AI RMF 1.0) (NIST AI 100-1). https://nvlpubs.nist.gov/nistpubs/ai/nist.ai.100-1.pdf

Gillespie, N., Lockey, S., Ward, T., Macdade, A., & Hassed, G. (2025). Trust, attitudes and use of artificial intelligence: A global study 2025 (University of Melbourne & KPMG). https://assets.kpmg.com/content/dam/kpmgsites/ch/pdf/kpmg-global-report-trust-attitudes-and-use-of-ai.pdf

Pentina, I., Hancock, T., & Xie, T. (2023). Exploring relationship development with social chatbots: A mixed-method study of Replika. https://www.sciencedirect.com/science/article/abs/pii/S0747563222004204