AI is expensive, and you’ve probably felt it by now. The subscription that used to cover everything now gates the good models behind a higher tier, the limits are significantly tighter, and the features you actually want keep drifting up the pricing page.

While a lot of this is just pure capitalism and the cost of doing business when demand for compute is outpacing supply, not all of it is out of your hands. There’s a cost baked into how you actually use these tools, and it shows in both how fast you hit your limits and in how good your answers are by the end of a long chat. Fortunately, the fix is almost embarrassingly simple, and all it takes is understanding what actually happens every single time you hit send.

The model has no memory

It just re-reads everything

Here’s the thing most people never realize about Claude, ChatGPT, Gemini or any chatbot: they have no memory. Not in the way you would hope, anyway. While all AI assistants ship with some form of persistent memory now, with some maintaining memory summaries and having the capability to search through your past chats, that’s not how an LLM actually works. Underneath, the model itself remembers nothing. Each time you hit send, it wakes up cold, with no recollection of the conversation you’ve been having.

So, how does it keep up with you then? The entire conversation gets handed back to it from scratch every single time you send it a new message. That sense of continuity you feel, the memory, isn’t the model remembering. Instead, it’s the whole chat being re-read, start to finish, before every single reply. All of this lives in what’s called the context window. Anthropic describes it as the model’s “working memory” — all the text a model can reference when generating a response, including the response itself.

Every message you send costs more than the last

In tokens, and in focus

Anthropic explains in its own documentation that as a conversation advances through turns, each user message and assistant response accumulates within the context window, and previous turns are preserved completely. Nothing leaves. Your first prompt, Claude’s reply, your follow-up, its next answer — every turn gets stacked on top of the last, and the entire pile is re-read before each new response.

What makes this even more complex is that it isn’t just your messages piling up. Everything within a new request counts toward the context window, including the system instructions running behind the scenes, every message in the conversation, any tool results, and every image or document you’ve dropped in it. Even Claude’s own reasoning, which is the thinking it does before answering, counts as well.

Think about what this means in a fairly long conversation. For instance, in your 100th message, you’re not sending one message anymore. You’re sending all 100, plus all 99 of the model’s replies, plus every document, image, and tool result that every passed through the chat, plus the reasoning it did along the way. All of it, bundled up and re-read from the top, just so the model can respond to your latest line.

So what does that actually cost you?

You pay in speed and smarts

Ultimately, every turn is heavier than the one before, because every turn carries everything that came before. That weight lands on you, the user, in two ways.

The first is the obvious one: you hit your limits faster. Whether you’re paying per token on the API or working within a subscription’s caps, every message you send costs more to process than the last, because it drags the entire conversation along with it. On the API, that’s literal money. By your hundredth message, you’re paying to reprocess the previous ninety-nine every single time. On a subscription, it’s your usage limits draining faster than they should.

The second cost is that your answers actually get worse. You would assume that more context means a better-informed model, and up to a point, it does. Anthropic’s own documentation states that more context isn’t automatically better. As the token count climbs, the model’s accuracy and recall start to degrade, a phenomenon Anthropic calls context rot. The detail that actually matters (your real question, the one crucial instruction) ends up buried under everything else you’ve ever said in that chat, and the model gets worse at picking it out of the pile.

The fix is to frontload everything

A dribbled-out conversation does more harm than good

The reason why I went so in-depth into the mechanics is that the fix only sticks once you actually understand the problem and how everything works behind the scenes. The fix, itself, is simple: front load everything. Instead of dribbling your request out across a dozen messages (asking a question, getting an answer, clarifying, correcting, adding the thing you forgot), the best approach is to put as much as you can into your first message.

Here’s an example of what a typical dribbled-out conversation looks like, the kind most of us have without thinking twice:

Give the model the full picture up front: the context, the constraints, the examples, the format you want, all of it, in one shot. This works against both costs at once. For the answer-quality problem, frontloading is a direct hit. Remember context rot? A single, well-structured prompt is the opposite of that: everything the model needs is right there, concentrated, with nothing burying it. You’re handing it a clean brief instead of making it reconstruct your intent from forty scattered messages.

For the limits problem, the win is slightly less obvious. Frontloading doesn’t make any individual message lighter. If anything, a big opening prompt is heavier. What it does is let you get what you need in far fewer turns. And since every turn re-reads the entire conversation, fewer turns means less total reprocessing. Ten back-and-forths refining a request you could have specified once is ten times the accumulated context re-read, over and over. Say it well the first time, and you collapse all of that into a turn or two!

Ultimately, if you’ve been struggling with limits that seem to vanish faster than they should, or answers that drift and dull the longer you chat, the problem might simply be the way you’re talking to them. So, frontload what you need, keep your threads lean, and start fresh when one has run its course. AI is expensive, sure. There’s no reason to make it more expensive than it has to be.