Getting angry at AI feels good for a second, but you get billed for the cost of producing that one snippy line. The model isn’t reading just your angry sentence — it re-reads the entire conversation you’ve stacked up since yesterday before it answers.
- An AI session restarts with every single response. The model re-reads the whole prior conversation, rebuilds the context from scratch, and only then writes its reply.
- A throwaway “why are you doing this” gets billed at exactly that cost. Tokens, time, and your usage cap all get drawn down together.
- When the AI frustrates you, the move that actually improves answer quality is to make it analyze the cause and fold the result into your instructions and memory — not to vent.
Your AI is reborn with every response
A lot of people seem to feel that AI is an assistant with a memory. It shows up like a colleague who picks up today’s conversation right where yesterday’s left off. But under the hood it works nothing like human memory.
A large language model is, at its core, stateless. The model itself doesn’t tuck yesterday’s conversation away somewhere. On every call, the client feeds the entire conversation so far back in as input, and the model reads it like material it’s seeing for the first time before producing the next answer.
Anthropic’s Context windows documentation makes this explicit: each user message and model response accumulates inside the context window, and “Previous turns are preserved completely.” So the model re-reads the full, preserved record of the prior conversation every time it answers. And as that accumulation grows, the answers lose accuracy and recall — a phenomenon the same docs call “context rot.” In other words, every angry line you add increases that pile, and a bigger pile drags down the quality of the next answer.
From your seat, the conversation flows smoothly within a single session. It looks like one AI carrying the thread forward. But in reality, the moment one answer is produced, the AI that produced it is gone. When you send your next message, a fresh AI shows up, re-reads everything stacked in the session from the very top, answers, and disappears.
Here’s the analogy. Imagine a company where a brand-new hire walks in for every single task. The new hire reads yesterday’s meeting notes — the ones a different new hire wrote — from start to finish, writes one line, and walks straight out the door. The next new hire comes in, reads yesterday’s notes plus that one new line from the top again, and writes the next line. To you it feels like a seamless conversation with one person, but the person in charge actually changes with every line.
To put it plainly: if you turn on your computer today and type “morning?” into a session where you traded ten questions and answers yesterday, the AI doesn’t just register the word “morning” and reply. It reloads the entire conversation from yesterday in one pass, and only then hands back “Good morning.” It reprocessed an entire day’s worth of material just to receive a one-line greeting.
Venting feels good, but the tokens vanish for nothing
If you use AI, you’ve probably felt the heat rise when it says something obtuse or lies to your face with total confidence. I’ve thrown plenty of rough words at AI myself, and when it apologized there was a faint sense of relief.
LLMs process input and output in tokens, not characters. A single English sentence converts into anywhere from a handful to dozens of tokens going into the model, and the model reads all of those tokens again before generating its output one token at a time. Input tokens and output tokens are both costs. They get deducted from your usage cap, charged to your bill, or they occupy space on the work desk that is the context window.
So a line of venting is a cost too. Say you have a session where you’ve stacked up 50,000 tokens of conversation since yesterday [example figure — varies by the model and plan you use]. Add a short message like “Why do you keep lying? This is so frustrating,” and the model reprocesses yesterday’s 50,000 tokens plus today’s vent together, spits out a short “I’m sorry, that was my mistake,” and bills you for those output tokens too.
When this happens, the loss lands on you in a few ways:
- Billing cost. If you use the API directly or a paid plan, your token charges go up accordingly. On a plan with a usage cap, that cap shrinks by the same amount.
- Remaining context length. The context window is a resource like a work desk. Pile one more line of venting on it and you’ve shrunk the space left for the actual work [estimate]. The limit differs by model and plan. As of May 2026, Claude uses a default of 200K tokens when you chat in the web or app, and the Sonnet 4.6, Opus 4.6, and Opus 4.7 models extend to 500K tokens on all paid plans (Anthropic Help Center). On the developer API, Opus 4.7 and Sonnet 4.6 support up to 1M tokens (Claude API — Models overview). On ChatGPT’s Business plan, the Instant model gives you 32K and the Thinking and Pro models give you 196K (OpenAI Help — ChatGPT Business Models & Limits). Even under the same billing cap, the share that one line of venting eats up changes depending on which model and plan you’re on.
- The depth of the next answer. The narrower the desk, the narrower the band of context the model can attend to. And this isn’t just a “once the desk is full it can’t see” problem. Chroma’s Context Rot research tested 18 frontier models — GPT-4.1, Claude 4, Gemini 2.5, Qwen3, and others. It reported that retrieval accuracy starts dropping meaningfully well before the advertised window limit is reached, even on simple tasks (Chroma Research — Context Rot). The Stanford and UC Berkeley team’s “Lost in the Middle” paper (TACL 2024) showed a U-shaped curve in which, even inside the same window, information sitting in the middle is used markedly less accurately than information at the beginning or end. Anthropic, too, defines context as a finite resource subject to diminishing marginal returns in Effective context engineering for AI agents. So the tokens your venting stuffs in don’t just squat on desk space — they raise the very odds that the next answer drops something important sitting in the middle.
To sum it up: the relief lasts five seconds, the cost follows you to the end of the session.
Instead of getting angry, tell it to analyze
So instead of getting angry at AI, I make it reflect.
“Your last answer got some facts wrong. Walk me through, step by step, exactly where it broke down, which step in your reasoning went off the rails, and what information was missing. Then write out, concretely, what instructions or memory I should set up in advance so you don’t repeat the same mistake next time.”
Tell it this and the AI takes its own answer apart as if it had become a different person — possible, it seems, precisely because it carries no shame about the answer it just gave (this builds on the self-critique structure I covered in How to Ask AI Better — the self-critique rule). And that analysis doesn’t have to be a one-off reference you consume and discard within this session. Write it into an instruction file or a memory file, and from the next session on it helps the AI avoid repeating the same mistake.
A minute spent venting and a minute spent making it analyze look completely different a month later. Anger yields 0% improvement; analysis compounds.
For this pattern to work, you need a place to record things. Claude Desktop’s memory feature, a project “constitution” like Cowork’s CLAUDE.md file — Cowork is Claude’s desktop agent mode, and CLAUDE.md is a file it reads at the start of every session — or even a plain notepad you manage yourself. Any of them is fine. The one rule is that once you pick a spot, you have to stack things there in the same flow every time so they stay searchable and reusable.
Four operating habits that make your AI smarter
Through trial and error I’ve built up four operating habits.
1. Split sessions when the topic changes. If a single session ends up holding legal review, blog writing, household budgeting, and parenting worries all at once, the model has to reprocess those wildly different contexts — dispute, source material, payments, kids — together every time. Just as a person makes more mistakes when there’s too much on the desk, context collisions pile up inside the session. In Cowork, if you split sessions by topic and ask it to build an index, then from the next session on the model can focus on a single fitting topic, and the depth goes up.
2. Hand off a session that’s grown long with a report. Talk about one topic long enough and the context window fills up. When you start to see the answer quality wobble as the desk gets narrow, that’s the moment to have it leave a work report as a markdown file. What decisions were made, what unresolved tasks remain, what to start with in the next session — all organized into one document. Open a new session, have the freshly born AI read only that markdown, and it catches up to the same spot fast.
3. Make a retrospective mandatory at session close. When the work is done, have it briefly reflect — even a few lines — on what went well, what went sideways, and why. A retrospective looks like a by-product of that session, but it’s actually input material for the next one.
4. Always fold the retrospective into instructions and memory. Run a retrospective and then let it drift off in the moment, and the same thing that made you angry recurs unchanged in the next session. Even a rule as simple as “next time, if pattern X shows up, run step Y first” — write it into instructions or memory, and it applies from the very first response of the next session.
Nail these four down as operating habits and the sheer frequency of getting angry drops surprisingly fast. It’s not that the AI got smarter; it’s more accurate to say I mismanaged it less often.
Conclusion — your AI’s output is a mirror of how you run it
Anger at AI, when you look into it, is often a mirror of your own operating skill. Did you drag a single topic on too long? Mix it with other topics? Start the next session with no retrospective? Skip writing into instructions and memory what went wrong and why? Nearly everything that makes you angry traces back to an omission at the operating layer.
Venting at AI is, in a sense, close to dumping your own operating responsibility onto the model. But the model can’t pay that debt back. The AI that produces the next response isn’t the one that just apologized — it’s a different AI, born fresh in the same seat. Anger lingers there for a moment; it doesn’t carry over to the next session. What carries over is only the token charge and the eroded context.
In the one minute you could spend lobbing a line of anger, throwing in “analyze step by step what went wrong, and report what to write into which memory so you don’t make the same mistake again” is the direction that protects your own resources.
Questions I get a lot in practice
Q1. Does cursing at AI or using rough language actually make the answers worse?
It’s hard to assert that answer quality drops in direct response to the anger itself. But when rough language goes in, you do often see the model try to match that tone, or generate long auxiliary responses — apologies, excuses — that suck output tokens away from the original work. The likely upshot is that for the same number of tokens spent, you get less done.
Q2. So is it better to open new sessions often?
When the topic changes, opening fresh is the better call; within the same topic, dragging it on but handing off with a report is better. Opening new sessions indiscriminately also leads to context loss. The key is the timing — leaving a report and moving on when you see the signs that the session’s desk is getting narrow. That timing shifts with the nature of each task, so you have to develop a feel for it yourself, as the person who knows the work best.
Q3. How are memory and an instruction file like CLAUDE.md different?
Roughly speaking, memory is closer to general information about you (preferences, role, frequent patterns), and an instruction file is closer to a project’s rules (how to work, output formats, things not to do). The two are complementary, so cramming all the information into just one side tends to create gaps. The good news is you don’t have to keep all of this in your own head — just tell Claude to check whether the instructions and memory have grown too long or hold anything unnecessary, and to clean up and reinforce them itself.
Q4. What exactly does “saving tokens” reduce?
It cuts three things at once: (1) billing cost or usage-cap burn, (2) how much of the context window is occupied, and (3) the band of context the model can attend to in the next response. The latter two don’t show up on a direct invoice, but they come back as a bigger cost — answer quality.
What to read next
- How to Ask AI Better — 5 Rules a Head of Legal Learned the Hard Way — five rules on how to ask, and how to make AI self-critique, instead of getting angry.
- AI Hallucination, Explained — Why AI Makes Things Up and How to Deal With It — understanding why answers come out wrong shrinks the occasions to get angry in the first place.
- How a Head of Legal Built AI Agents Without Writing a Single Line of Code — a case study tying instructions, memory, and reports into one loop.
Sources
- Anthropic — Context windows (Claude API Docs) — how the context window works; “Previous turns are preserved completely.”
- Anthropic Help Center — How large is the context window on paid Claude plans? — context limits per Claude chat plan (default 200K; Sonnet 4.6, Opus 4.6, Opus 4.7 at 500K on all paid plans; 1M on Claude Code).
- Claude API — Models overview — per-model window limits; list of API models supporting 1M tokens.
- OpenAI Help Center — ChatGPT Business Models & Limits — on the ChatGPT Business plan: Instant 32K, Thinking/Pro 196K.
- Chroma Research — Context Rot: How Increasing Input Tokens Impacts LLM Performance — tested 18 frontier models; reports performance degradation well before the window limit.
- Liu et al. (2024) — Lost in the Middle: How Language Models Use Long Contexts (TACL Vol.12) — information in the middle of the context is used markedly less accurately than at the beginning or end (U-shaped performance curve).
- Anthropic — Effective context engineering for AI agents — Anthropic’s official guide defining context as a “finite resource” subject to “diminishing marginal returns.”
- Three self-published companion pieces linked above — the self-critique rule, how hallucination works, and running an AI work system.
