Three habits that quietly inflate your AI bill
AI does not charge by the question. It charges by the context. Every turn you send re-tokenizes the entire conversation above it: system prompt, memories, style preferences, every previous message, every previous response. Turn one is cheap. Turn twenty is paying for turns one through nineteen, plus the machinery, plus whatever you just typed.
Nobody tells you this when you sign up. The interface is a chat window. Chat windows in every other product on earth are free. It feels wrong that this one has a meter running.
There are three habits that account for most of the silent spend in everyday engineering use. None of them require you to change what you use Claude for. All of them are one setting or one instinct away.
Fresh chats per task
The “kitchen sink” thread is the most expensive habit in the ecosystem.
You debugged a Kusto query Monday. You asked about a WinDbg command Tuesday. You drafted an email Wednesday. Now it is Thursday and you are asking Claude to review a PowerShell script in the same thread. That PowerShell review is now paying rent on the Kusto query it will never reference. Every response gets slower. Every turn costs more. The bill grows roughly quadratically over the session because each new turn re-sends everything above it.
A rough sketch. Assume an average turn adds a thousand tokens of combined prompt and response, which is conservative for real engineering work. Turn thirty of a kitchen sink thread ships thirty thousand tokens of prior context back to the model before Claude reads your new question. Cumulative input tokens across the session land near four hundred sixty-five thousand. Break the same work into six focused five-turn threads and you spend closer to ninety thousand. Same amount of actual work, one-fifth the input tokens. One session is a rounding error. Multiply it across a team and a year and it stops being one.
There is a second cost that shows up before the first one bites: quality. A forty-turn thread that has veered across four topics gives worse answers than a clean chat with a tight framing. Irrelevant earlier context still influences the response. Claude is trying to serve you, and “you” includes the thing you asked about last week.
The heuristic that works: if the new question would not benefit from anything above it, start a new chat.
Concretely.
- Different codebase, new chat.
- Different customer case, new chat.
- Different document you are drafting, new chat.
- Pivoting from “help me debug” to “help me write about it,” new chat.
Where you stay is when the context earns its keep. Iterating on the same artifact. Continuing to debug the same problem. Refining a draft. The prior turns have leverage there because the next turn actually depends on them.
Kitchen sink: 30-turn thread ≈ 465K input tokens vs. six focused 5-turn threads ≈ 90K. One-fifth the cost for the same work.
The cost of starting fresh is roughly zero. The cost of not doing it compounds every turn.
Uploads, not paste
When you paste a two-thousand-line file into a message, those tokens live in that message forever. They get re-sent with every subsequent turn. Paste it again in turn five to ask about a different function and you are now carrying two copies. Do it three times over a long session and you have paid for the file six times.
The math is worse than it sounds. A two-thousand-line source file runs roughly twenty thousand tokens. Paste it once and drag it through twenty follow-up turns and you have shipped four hundred thousand tokens for a file that has not changed since turn one. Paste the same file a second time to ask about a different function and you cross seven hundred thousand before you have written any new code. Uploads live as attachments the interface handles more efficiently, and they stay addressable instead of drifting up the transcript. The habit pays back somewhere around the third follow-up.
The rules that keep this from mattering:
- Anything over roughly a hundred lines, upload it.
- Multiple related files, upload them separately. Do not concatenate into one giant paste for “convenience.”
- If you need to reference a specific section repeatedly, quote that section inline and keep the full file as an upload.
- For iterative work on one file, upload the current version and ask for changes. Request diffs back, not full rewrites. Diffs save output tokens too, which are the expensive ones.
There is a second-order benefit. Pasted content thirty turns back is still there but harder for Claude to locate precisely. An uploaded file stays addressable. You get better answers and a smaller bill from the same behavior change.
Pasted files: A 20K-token file dragged through 20 turns = 400K input tokens. Re-paste it once and you cross 700K before writing new code.
Thinking and search off by default
Extended thinking generates reasoning tokens before the visible response. You pay for those tokens whether or not you see most of them. For a lot of everyday questions the thinking budget is pure overhead. The answer would have been the same without it.
The number that matters: thinking budgets vary, but ten thousand reasoning tokens per response is a reasonable estimate for a nontrivial question. Twenty responses in a working session is two hundred thousand reasoning tokens on top of the visible output, billed at output rates. If half those questions did not need the extra thought, you have paid a real premium for zero difference in the answer. Web search compounds harder because retrieved pages persist in the context: a single search that pulls back three sources at five thousand tokens each adds fifteen thousand tokens to every subsequent turn in that thread until you close it.
Turn thinking on deliberately.
- Genuinely hard debugging where the answer requires multi-step reasoning.
- Architecture decisions with tradeoffs to weigh.
- Math, proofs, complex logic.
- Anything where you would want a senior engineer to stop and think rather than answer from reflex.
Turn thinking off for.
- Syntax questions.
- “Format this.”
- “Summarize this.”
- “Write me an email.”
- Code review of small changes.
- Anything a competent human would answer in ten seconds.
Web search follows the same pattern with a sharper edge. Search pulls back pages of retrieved content that then live in your context. Every result is tokens you pay for on the current turn and often on the turns that follow. Leave search on for a conversational question about how a for-loop works in Python and you will get an answer that cites six blog posts you did not need, wrapped in a context window that is now heavier than it should be.
Turn search on for.
- Current events, recent releases, anything after the training cutoff.
- Specific product versions or documentation you want cited.
- Facts where you need a source, not just an answer.
Turn search off for.
- General knowledge that has not changed in a decade.
- Coding help on established languages and frameworks.
- Writing assistance.
- Anything conceptual.
The posture that keeps the bill sane: thinking off, search off, flip them on when the question actually needs them, flip them back off. Treating them as always-on is where the silent token spend lives. It is also where the answers get worse for reasons that are hard to trace.
Thinking and search: 10K reasoning tokens × 20 responses = 200K reasoning tokens billed at output rates. One web search sticks ~15K tokens onto every subsequent turn until you close the thread.
The one habit under all of them
Notice what these three have in common. They are all forms of the same discipline: do not carry weight the current turn does not need.
The kitchen sink thread carries yesterday’s questions. Pasted files carry every previous copy. Extended thinking and search carry reasoning and retrieved pages you did not ask for. Each of them individually is a small choice. Together they are the difference between a Claude session that feels sharp and one that feels expensive and vague at the same time.
Fresh chat. Upload the file. Leave the toggles off unless you need them. Everything else is fiddling.
Azure Advice 