Our earlier post on the viral "Anthropic emailed me for insulting Claude" claim covered a policy question: what consequence a lab might impose on your account for abusive language. That is not this post.
This post asks a narrower, purely empirical question: when you're mid-conversation with an AI chat or coding agent, does using hostile, insulting, or threatening language actually change the quality of what it outputs — better, worse, or no measurable difference — compared to phrasing the same request bluntly but without hostility? That question has nothing to do with what a company might do to your account afterward, and it has real, if messy, research behind it.
TL;DR
| Question | Short answer |
|---|---|
| Does rudeness reliably improve output quality? | No. Studies conflict — one 2025 benchmark found rude prompts scored higher; an earlier 2024 cross-lingual study found the opposite. No consistent winner across models and languages. |
| Does rudeness reliably hurt output quality? | Sometimes, model-dependent. Some models (LLaMA more than GPT, per research) show measurable accuracy drops under impolite framing; others show little effect. |
| Does threatening the model work (job loss, tipping)? | No significant benchmark gain, per Wharton's Prompting Science Report 3 — a direct test of the "threaten it for better answers" folk claim. |
| Does blunt, specific, non-hostile criticism work? | Yes — this is what actually drives correction and quality, independent of tone. |
| Does harsh feedback break agentic coding sessions? | Not the tone itself — but long correction loops (regardless of tone) accumulate defensive, bloated code; vague criticism wastes turns hostility wouldn't have saved. |
| Does the model's RLHF training make it react to hostile framing at all? | Yes, mechanistically — hostile-sounding prompts can pull a model toward more hedged or refusal-adjacent completions, a statistical effect of training data, not a "hurt feelings" effect. |
What the actual research says (and why it disagrees with itself)
There is a real, growing body of work testing this exact question — prompt politeness against benchmark accuracy — and it does not agree with itself, which is itself the finding worth reporting rather than smoothing over.
The 2024 cross-lingual result — politeness helps, mostly. A widely-cited 2024 study, "Should We Respect LLMs? A Cross-Lingual Study on the Influence of Prompt Politeness on LLM Performance", rewrote task prompts across multiple politeness levels in English, Chinese, and Japanese. It found that impolite prompts often produced worse performance, but that overly polite phrasing didn't reliably help either — the best politeness level varied by language and model, with GPT models showing more robustness to tone shifts than LLaMA, which was the most tone-sensitive model tested.
The 2025 Penn State result — the opposite direction. A 2025 short paper, "Mind Your Tone: Investigating How Prompt Politeness Affects LLM Accuracy", tested 250 prompts across five tone levels (very polite through very rude) on ChatGPT-4o against a multiple-choice benchmark. It found rude prompts scored higher (84.8% accuracy) than very polite ones (80.8%) — accuracy climbed step by step as politeness decreased. That is a direct contradiction of the 2024 finding, on a newer model.
The cross-model, cross-lingual follow-up — no universal answer. A subsequent multi-model study using the PLUM corpus, "No Universal Courtesy: A Cross-Linguistic, Multi-Model Study of Politeness Effects on LLMs," found the effect is neither consistent nor universal — moderate politeness tends to edge out both extremes in most conditions, but "moderate" itself shifts by language and model.
What to take from three studies that disagree: the honest synthesis is not "insults help" or "insults hurt" — it's that tone does not reliably move output quality in a predictable direction across models. Whatever effect exists is small relative to model, benchmark, and language differences, and it flips sign between papers tested a year apart on different model generations. Treat any single headline ("rude prompts score higher!") as one data point, not a rule to build a workflow on.
Threats and tipping: a direct test, and a clean null result
Separately from politeness, our coverage of Wharton's Prompting Science reports covers Report 3, which tested two specific folk techniques head-on: offering the model a tip, and threatening it with framings including job-loss language — the kind of prompt-hack publicly endorsed by Google co-founder Sergey Brin in 2025. Tested against GPQA and MMLU-Pro, neither tipping nor threatening produced a significant accuracy gain. That's a cleaner result than the politeness literature: threats specifically, tested directly, did nothing measurable for benchmark performance. If hostility were secretly a lever for better answers, threatening the model is the most aggressive version of that lever, and it came up empty.
Why tone would affect output at all — the mechanism, not the vibe
None of this is about the model being offended. Large language models are shaped by RLHF (reinforcement learning from human feedback) — training that rewards completions humans rated as helpful, safe, and appropriate, and penalizes ones that weren't. That training process is where a tone effect, if any, actually enters the system.
Hostile or adversarial-sounding phrasing statistically co-occurs, in training and fine-tuning data, with prompts that precede jailbreak attempts, harmful requests, or genuinely abusive exchanges. A model shaped by RLHF to be cautious around that pattern can shift toward more hedged, more qualified, more refusal-adjacent completions when it sees hostile framing — not because it's hurt, but because the statistical neighborhood of "aggressive tone" overlaps with the neighborhood of "requests that historically preceded a safety response." Research on refusal behavior documents this as a known failure mode: safety optimization that reduces genuinely harmful compliance can also produce exaggerated refusal on benign prompts that merely sound adversarial — over-cautious, nuance-dodging answers to requests that were actually fine.
That is the mechanistic version of "don't insult the model" — not a welfare claim, a next-token-probability claim. It's a real, measurable, testable effect on outputs, entirely separate from any question about whether a model has something like feelings. See our explainer on RLHF, scalable oversight, and constitutional AI for how that training shapes refusal and caution more broadly.
The agentic coding angle: harsh feedback vs. blunt feedback
For a practitioner audience running Claude Code, Codex, or other coding agents through multi-turn correction loops, the more relevant question isn't chatbot politeness benchmarks — it's whether telling an agent "this is garbage, fix it" produces a worse recovery than "this function has a null check bug on line 12, fix it."
Research on iterative AI code generation gives a partial, useful answer, though it points at a different mechanism than tone. A systematic study of security degradation in iterative AI code generation found that as correction loops stack up, agents accumulate overly defensive code, scope creep, and subtly incorrect security-critical logic — participants using AI assistants wrote measurably less secure code across iterations while rating it more secure than it was. Separate benchmarking work on long-horizon agent degradation documents the same shape: each turn leaves behind "defensive abstractions, explanatory residue, and local compromises" that are individually defensible but compound into bloat over enough turns.
Crucially, that degradation research ties the effect to iteration count and feedback vagueness, not to hostility specifically. A vague correction — hostile or not — forces the agent to guess at what "fix it" means, and guessing is what produces defensive over-engineering as the agent hedges against an unclear target. A specific correction, however bluntly worded, gives the agent a concrete target and skips that guessing entirely. The tone of "this function has a bug on line 12, fix it" isn't doing the work — the specificity is. Swap in "you idiot, this function has a bug on line 12, fix it" and you'd expect the same fix, plus the model possibly burning part of its next completion on a more hedged, apologetic preamble if hostile framing nudges it toward caution, per the RLHF mechanism above.
The practical distinction that matters for agentic workflows:
| Feedback type | Example | Effect |
|---|---|---|
| Vague + hostile | "This is trash, try again." | Forces the agent to guess the target; wastes a turn; hostility adds no signal. |
| Vague + polite | "Hmm, not quite — could you try again?" | Same guessing problem; politeness doesn't supply the missing specificity either. |
| Specific + hostile | "You idiot, line 12 has a null check bug." | Gets the fix; hostility is dead weight riding along with the useful part of the message. |
| Specific + blunt, non-hostile | "Line 12 has a null check bug — fix it." | Gets the same fix, no downside risk from adversarial-sounding framing. |
The row that wins is the last one — not because it's polite, but because it's specific and carries no hostile framing that could nudge a safety-trained model toward hedging on an otherwise ordinary correction.
The anthropomorphization question, answered directly
A fair objection at this point: "it's not a person, why would tone matter at all?" That objection is right about the premise and wrong about the conclusion.
The model has no feelings to hurt, and nothing in this post claims otherwise — that's a welfare question Anthropic itself has described as unresolved and separate from product behavior. But "does hostile-toned input change the statistical distribution of next tokens" is not a question about feelings — it's a question about a trained function's behavior under different inputs, the same category of question as "does prompt length change output quality" or "does including a code block change accuracy." Nobody would call that second question anthropomorphizing.
So the honest framing is: you're not being unkind to a person when you insult an agent, and you don't need to worry about that. You are, per the research above, potentially degrading the statistical quality of your own output for no measurable benefit — a purely mechanistic cost, worth avoiding for the same reason you'd avoid any other prompt pattern with a documented downside and no documented upside.
The verdict
Across the studies above, hostility toward a model does not reliably improve output quality — the 2024 and 2025 politeness studies contradict each other's direction, and the one study that tested threats specifically (Wharton Report 3) found no gain at all. Meanwhile, the mechanism that plausibly explains any negative tone effect — RLHF-driven caution around adversarial-sounding input — is well-documented and points toward hedging and over-refusal, not better answers.
Bluntness works. Hostility doesn't add anything on top of bluntness, and it carries a real, if inconsistent, downside risk. Say exactly what's broken and what you want changed. Skip the insults and the threats — not because the model's feelings are at stake, but because the data doesn't back the trade, and the one thing insults reliably cost you is nothing you were trying to buy.
Do's and don'ts for prompting and agentic sessions
- Do name the specific problem: "the retry logic doesn't back off, it loops immediately" beats both "this is bad" and "this is bad, you moron."
- Do state the target output directly, per Wharton's own recommendation to write specs, not tricks — see our Ethan Mollick / Wharton prompting research coverage.
- Do keep correction loops short and specific in agentic coding sessions — vagueness, not politeness, is what triggers the defensive-code accumulation documented in the degradation research above.
- Don't rely on tipping, threatening, or insulting a model as a performance lever — Wharton's direct test of tipping and threatening found no accuracy gain, and no politeness study found insults as a reliable win either.
- Don't confuse "no output-quality cost" with "no consequence" — see the companion post on Anthropic's documented conversation-ending policy for the separate account-level question.
- Don't assume one viral benchmark number ("rude prompts scored 84.8%!") generalizes across models — the same effect reversed direction in an earlier study on a different model generation.
Related on explainx.ai
- Did Anthropic email you for insulting Claude? Viral post vs real policy — the companion piece on account-level consequences, not output quality
- Ethan Mollick: prompting tricks are over — Wharton backs real specs — the tipping/threatening benchmark data in full
- Master prompt engineering with Claude — building specs that actually move accuracy
- Scalable oversight, RLHF, and constitutional AI — where refusal and hedging behavior come from
- Loop engineering for coding agents (Claude Code guide) — running long correction loops without degradation
- Context engineering vs. prompt engineering — why specificity beats tone as a lever
Sources
- Should We Respect LLMs? A Cross-Lingual Study on the Influence of Prompt Politeness on LLM Performance (2024)
- Mind Your Tone: Investigating How Prompt Politeness Affects LLM Accuracy (Penn State, 2025)
- Security Degradation in Iterative AI Code Generation: A Systematic Analysis of the Paradox
- Wharton Generative AI Labs — Prompting Science Reports (Report 3: tipping/threatening)
Research on tone and LLM output is active and model-specific — results measured on one model generation (e.g. GPT-4o in 2025) may not transfer to newer releases. Re-check primary sources before treating any single benchmark number as a durable rule.