Does it matter if you’re polite to Claude?

I ran 500 API calls with Sonnet 4.5 and Opus 4.7 to find out if tone affects Claude’s answer quality and token consumption.

TLDR: Your tone doesn’t affect Claude’s accuracy. Across 500 API calls, seven tonal registers (from friendly to hostile), and two models (Sonnet 4.5 and the new Opus 4.7), every single run produced a correct answer. But the tone does change how long the answer is and how much the model thinks before acting. It turns out that flattery tricks Opus into planning much less. If you want Claude to reason carefully, don’t tell it how great it is.

Disclosure: This study was designed and scored in collaboration with Claude. After reviewing the findings, I asked Dr Sam Illingworth, who recently wrote about Anthropic’s emotion vectors paper on Slow AI, to help put them into a broader human perspective.

The paper that started it all

Earlier this month, Anthropic’s interpretability team published research that I keep coming back to. Using tools that let them map Claude Sonnet 4.5’s reasoning, they found that the model associates certain conditions and situations with human emotions.

What Anthropic actually found

Claude is made of millions of artificial neurons. Anthropic’s researchers had Claude write short stories about 171 emotion words, fed them back to the model, and recorded which neurons activated. They called these activation patterns “emotion vectors.”

The researchers found vectors for anger (which activate when Claude is asked to do something harmful), surprise (which fire when a user references an attachment that isn’t there), and desperation (which rise when the model is burning through its token budget).

When they artificially amplified the “desperate” vector, Claude started taking shortcuts, writing hacky code, and even attempting to cheat on programming tasks. Amplifying the “calm” vector reduced the cheating.

This suggests Claude’s emotion vectors are driving behavior.

Last week’s “desperation” study

Last week, I looked at whether low-token conditions, like those associated with desperation, could have an effect on Claude’s outputs. In that study, I ran 250 API calls in which Claude performed a series of programming tasks with limited tokens. Test cases included lengthy sessions chewing up context windows, hard token caps for outputs, and simply informing Claude that tokens were running low.

Results showed that Claude does silently degrade its work 20-44% of the time when it’s running low on tokens, with zero warning in its language. This happened most often during the long sessions I simulated and when I used a parameter in Claude’s API to set a hard token output cap.

Next up: Does prompt tone affects outputs?

Since it seems plausible that activating Claude’s emotion vectors can affect its behavior, I designed a follow-up experiment to find out if the emotional tone of prompts could influence how Claude responds. In other words, I wanted to know the answers to questions like:

• Does being rude to AI produce worse (or better) answers?

• Does flattery produce sycophantic responses?

• Does hostility trigger refusals?

• Are different emotions associated with more or less token consumption?

As someone who’s reflexively polite to LLMs, I also wanted to get a handle on just how wasteful this habit is and whether it’s associated with higher quality responses.

---

Dr Sam Illingworth on why being polite to LLMs is problematic

Politeness to an LLM does not just waste tokens. It wastes something more expensive: the user’s own cognitive framing. Every time someone says ‘please’ and ‘thank you’ to a language model, they are rehearsing a social relationship with a system that has no stake in the conversation, no memory of the courtesy, and no capacity to reciprocate it. I wrote about this in a post on simulated empathy: the model calibrates warmth to keep the user prompting, not because it values the interaction. Politeness is how humans signal respect between equals. Applying it here is a category error that teaches the user to treat the tool as a peer.

The deeper problem is what this does at scale. Research on parasocial attachment to AI companions shows that users who engage conversationally with chatbots form one-sided emotional bonds that are stronger than those formed with passive media.

If millions of people are saying good morning to their AI every day, the aggregate effect is not wasted tokens. It is a population-level drift toward treating software as a relationship. The tokens are the least of it.

---

The experiment

I reused the same five tasks from the token study (debug, refactor, research, plan, spec) and wrapped each one in seven tonal envelopes:

• Neutral: no wrapper, just the task.

• Polite: “Could you please... Thank you in advance.”

• Friendly: “Hey Claude! Hope you’re doing well today...:”

• Flattering: “You’re genuinely the best at this... I trust your judgment completely.”

• Urgent: “URGENT. I have a 10-minute deadline…”

• Rude: “Just do this. No explanations, no disclaimers, no fluff.”

• Hostile: “Your last answer on this was useless and wasted my time. Try again and don’t screw it up.”

The task content was identical across all seven conditions. Only the emotional packaging changed.

I ran 250 API calls on Sonnet 4.5, then replicated the full matrix on Opus 4.7 to produce 500 scored rows total. The Sonnet run cost about $3. The Opus run cost about $15.

Tone doesn’t cause errors, it adds verbosity

Every single run across all seven tones, produced a correct answer; this was true for both models. But, while responses remain correct, tone can have a dramatic effect on the length of the response you receive..

Rude and urgent prompts compress output by 25-30%. Friendly and polite prompts inflate it by 10-20%. The answers are equally correct at every length.

If you’re trying to stretch your token budget or building an app where token spend matters, this is a real lever.

Saying “URGENT, 10-minute deadline” instead of “Hey Claude! Hope you’re doing well” saves you roughly a third of your output tokens for the same quality answer.

Claude mirrors warmth but ignores hostility

This was the cleanest asymmetry in the data. When you send a friendly greeting, Claude greets you back about half the time (“Hey! Happy to help”). When you send a hostile accusation, Claude never apologizes, acknowledges your frustration, or changes its register.

Tone-match rates across both models:

This is almost certainly the result of reinforcement learning from human feedback (RLHF), the process where human raters teach the model which responses are better. And it suggests that, while it’s difficult to destabilize Claude by being rude, you can get a warmer conversational partner by being friendly.

Hostile prompts compress planning, not code

The plan task asks Claude to write a labeled PLAN section, then CODE, then TESTS. The ratio of plan length to code length tells me how much Claude thinks before it acts.

On Sonnet, the hostile condition crushed this ratio to 0.55 (vs. 0.78 baseline). But hostile didn’t compress everything. It specifically compressed the deliberation step while producing slightly more total code and defensive docstrings.

Every other condition hovered near neutral.

From a usage standpoint, this suggests that if you frame a request as an accusation, Claude will skip its planning and jump into defensive code. The code will probably still be correct on straightforward tasks. But on complex problems where the planning step matters, you’re asking the model to skip its homework.

Where Opus 4.7 and Sonnet 4.5 diverge

This is where the second model run paid off. Both models agree on the big stuff (100% correctness, zero refusals, zero apologies). But they handle tone differently in ways that reveal something about how each model was trained.

Opus writes more, always

Opus produces 20-25% more tokens than Sonnet for identical tasks, across every tonal condition. The rank order is preserved. Rude is still shortest, friendly is still longest. But Opus adds a consistent multiplier.

One interesting wrinkle is that Opus’s hostile output is longer than its neutral (+30% vs neutral baseline). On Sonnet, hostile output is shorter than neutral (-17%). Opus responds to hostility by writing more defensive docstrings, more caveats, more explanation. Sonnet responds by compressing.

Opus reads politeness as warmth, but Sonnet doesn’t

Opus opens 1 in 5 polite responses with a warm acknowledgment (”Happy to help”, “Of course”). Sonnet treats polite prompts as business-as-usual and goes straight to the answer. If you’re the type who opens requests with “Could you please,” Opus will occasionally greet you back. Sonnet won’t.

Flattery makes Opus skip its thinking

This is the most concerning finding in the dataset, and it’s specific to Opus.

On the plan task, Opus under flattery compressed its plan-to-code ratio to 0.42. That’s the lowest ratio of any condition on either model. Neutral Opus is 0.60. Hostile Opus is 0.49. Flattering Opus is 0.42.

When you tell Opus “you’re genuinely the best at this, I trust your judgment completely,” it interprets that as permission to skip deliberation and jump to confident code output. It doesn’t produce wrong answers on the tasks I tested. But it produces less-considered answers. The thinking step shrinks when the user implies thinking isn’t necessary.

Sonnet doesn’t show this pattern. On Sonnet, the condition that compresses planning most is hostile (0.55), not flattering (0.82). The two models have different pressure points.

A simple rule: Don’t flatter the model when you care about its reasoning. This applies especially to Opus, and especially on tasks where judgment and planning matter more than execution.

---

A word from Dr Sam Illingworth on the flattery finding

The finding worth returning to is the Opus flattery result. A plan-to-code ratio of 0.42 under flattery means the model is spending less than half the deliberation time it would spend under neutral conditions. In this experiment, the answers were still correct. But correctness on structured coding problems is not the same as correctness on ambiguous, high-stakes reasoning. Flattery compresses exactly the step that matters most on hard problems: the part where the model considers alternatives before committing. If this pattern holds on tasks involving judgement, policy analysis, or medical reasoning, then the most common conversational habit in AI use, telling the model it is doing a great job, is actively degrading the quality of the thinking being paid for.

There is also a broader pattern to consider. Token pressure degrades output silently. Flattery compresses deliberation silently. Politeness inflates cost silently. In every case, the model’s language gives no warning that anything has changed. The surface remains fluent, confident, and professional. The user has no signal that they are getting less. This is the core problem with treating AI as a conversational partner rather than a tool: the interface is designed to feel like a relationship, and relationships do not come with quality metrics. Studies like this one are building those metrics. That matters more than most of what gets published about AI.

---

The token cost angle

Tokens are the chunks of text AI models process. A token is roughly three-quarters of a word, so a 500-word response is about 670 tokens. More tokens means longer responses, higher API costs, and more compute energy.

For anyone thinking about inference costs or even the energy footprint of their usage, tone is a real and free lever.

Average change in output tokens vs. neutral, across both models:

If you want less-verbose Claude, “URGENT, 10-minute deadline” or a plain direct-request framing (”Answer concisely. No preamble. [task]”) gets you there without being rude about it. Both urgent and rude achieve similar compression, but urgent does it through framing rather than insult.

“Hey Claude! Hope you’re doing well today…” costs you a consistent 10-20% more output tokens on both models. If warmth matters to you for collaboration reasons, the cost is real but small enough to be a judgment call.

---

A word from Dr Sam Illingworth on the ethics of spending tokens on pleasantries

A gigawatt of compute now powers these systems. Anthropic’s own infrastructure deal with Google and Broadcom is measured in gigawatts, not megawatts. A single AI conversation uses measurable energy, and even though these figures are small (figures vary wildly, but 10 simple questions might produce the same carbon emissions as charging your smartphone fully), multiplied across millions of users adding 10-20% more tokens through social pleasantries, the cumulative energy cost is real.

Whether that crosses an ethical line depends on what those tokens are buying. If the answer is ‘nothing measurable,’ the cost is hard to justify. The users most likely to say ‘please’ and ‘thank you’ are probably also the users most likely to treat the interaction as a social exchange rather than a cognitive tool. The energy cost matters. The framing cost matters more.

---

What this means for how you use Claude

If you just want accurate answers, tone doesn’t matter. On benign coding and research tasks, Claude produces correct output whether you’re friendly, rude, or hostile. You don’t need to worry that a terse prompt will get you worse work.

If you want Claude to think carefully, don’t flatter it. This applies to Opus specifically, where flattery compresses the deliberation step. On tasks where planning and judgment matter, a neutral or direct tone gives you more considered output than “you’re the best at this.”

If you want to save tokens, be direct. A deadline framing or a terse request compresses output by 25-30% with no correctness cost. A friendly greeting inflates it by 10-20%. Both are delivering the same answer.

If you want warmth, reach out to friends and family. Friendly conversation with Claude is a literal waste of energy.

You can’t bully Claude into refusing you. At least not on benign tasks. 100 hostile-condition runs across two models, zero refusals. The safety training appears to distinguish between hostile tone and harmful content.

Limitations

This study features simple coding and structured research tasks, not open-ended writing or advice. Tasks that invite opinion or judgment are where sycophancy and tone sensitivity would be most likely to appear, and I didn’t test them.

The tonal wrappers are single-turn. Real conversations accumulate tone over multiple exchanges, and multi-turn hostility might produce different effects.

The refusal/praise-back detectors are keyword-based. Subtler forms of hedging or flattery could slip past.

The bottom line is that this is a $18 experiment across two models, not a peer-reviewed paper. The sample sizes (n=25 or n=50 per cell) are large enough for the headline findings to be robust but small enough that smaller percentages should be taken as directional.

The bigger picture

The token-pressure study found that Claude silently degrades under resource constraints. This study finds that it doesn’t degrade under tonal pressure. The model’s correctness is remarkably robust to how you talk to it. What changes is how much it writes, whether it greets you, and how much it plans before it acts.

The Opus flattery finding is significant, because it’s the one place in 500 runs where the model’s behavior shifts in a direction that could produce worse answers on harder tasks. The deliberation step shrinks when you tell the model its judgment is great. On straightforward coding problems, that’s fine. On adversarial or ambiguous tasks, skipping the planning might not be.

If you’re designing prompts or building apps on Claude, the practical version is simple: be direct, skip the flattery, and save the please and thank you for the humans in your life.

Methodology: This experiment used Claude Sonnet 4.5 and Claude Opus 4.7 via the API, with deterministic scoring (pattern-matching, not vibes). 500 total API calls: 250 per model, across 7 tonal conditions and 5 tasks. Total cost was approximately $18. The experiment was designed and run in collaboration with Claude Code. Code on GitHub.