If you prompt Claude or ChatGPT the way you did 6 months ago, you're leaving a lot of value on the table. And above all, you're burning through your tokens far faster than necessary.
The models have evolved (Opus 4.7, GPT-5.5, Gemini 3.5), and so have the features: skills, connectors, reasoning mode, memory, projects…
→ The result: yesterday's best practices are no longer today's.
October 2026 update: since this article came out in May, Anthropic has released Claude Opus 5.5 and Sonnet 5.5, and OpenAI its GPT-6 family. The frugality habits below still apply. On Opus 5.5, cache reads cost only 5% of the input token price, versus the usual 10%.
I had put together a newsletter issue in January 2025 on how to generate optimized prompts in 1 click.
Back then, we talked about detailed structures (role, context, task, format, examples…) and tools like the Playground's meta-prompts to do the work for us. 18 months later, the topic has completely shifted!
And there's a new topic that concerns us all: token frugality. I've talked recently about Claude chat, Cowork and Claude Code, encouraging you to try out and use Claude Code, which lets you go even further. Except that after a few sessions, you hit the same “limit reached” wall. Understanding how the black box behind it works genuinely changes everything. That's exactly what this article is about!
What has really changed in the way we prompt
Anthropic shares best practices for prompting the new models like Opus 4.7.
Here's a summary of the 4 real shifts compared with what we used to do:
1. Be literal, not verbose
The new models interpret your instructions literally. No more need for the Role section = “You are a senior consultant, do a complete and detailed audit of this contract, analyzing every angle…” over 10 lines.
Now, you can be more direct = “Audit this contract. List the risks by clause. Rate severity from 1 to 5. Suggest a rewording for each risky clause. Format: table.”
More precise, fewer tokens, better result. It's exactly the opposite of what we advised a year ago, when you had to stuff the prompt with context to make up for the models' limitations.
2. Frame the length explicitly
In the past, Claude calibrated roughly the same response length no matter what you shared as input. Now, it sizes its response to what it thinks the task's complexity is. A long document + “summarize” = a long summary.
If you want it short, you have to spell it out: “Summarize in exactly 5 bullets. Each bullet under 15 words. First word = action verb.”
3. Give positive instructions only
Negative instructions (“don't do X”) don't work well. The model interprets the sentence literally but doesn't generalize.
Not very useful to spell it out with “Don't use jargon. Don't use buzzwords. Don't sound like a marketer.”
It's better to write “Write in plain English, readable by a 16-year-old. Short, concrete words. Replace ‘leverage’ with ‘use’.”
4. Ask Claude to ask questions
Probably the habit that makes the biggest difference. Rather than a 500-word prompt with all the context, write:
“I want [task] for [goal]. Ask me questions before you start. Use the ask_user_question tool.”
Claude asks you for exactly the info it needs, with tappable choices. That means fewer tokens in your prompt, less risk of it heading in the wrong direction, and a better-targeted response on the first try.
A quick detour: what is a token?
I've talked a lot about tokens so far, here's a quick recap if it isn't clear.
When you send a message to Claude, your text is cut into small pieces: those are the tokens. There are input tokens (your message + all the context) and output tokens (the model's response). Both count toward your usage limits. On recent Claude models, 100 tokens are roughly 55 words, according to Anthropic's documentation (as of October 2026).
You can even see on this site the token breakdown of your prompts.
The second concept to keep in mind is the context window. It's everything Claude “sees” when it answers you: your current message, the conversation history, the uploaded files, the instructions of the active skills, the connectors' tools. It can go up to 1 million tokens.
The problem: the more this window fills up, the more each message costs (because everything is re-read every time) AND the more Claude's performance degrades. From 40 to 60% of context filled, you start losing response quality. That's exactly what brings us to the next trap.
The hidden trap: the token snowball effect
It's what nobody tells you before you pay for the Max plan at $100 or $200 a month.
With every message, Claude re-reads the entire conversation from the beginning. Concretely:
- Message 1: 500 tokens
- Message 30: 15,500 tokens (31 times more expensive for an equivalent message)
- Cumulative total over 30 messages: 232,000 tokens
Over a long session, 98% of your tokens go just to re-reading the history. You're paying for memory, not for work. It's exponential, not linear.
On top of that, here's what silently weighs on your context with every message: 13% goes to MCP connectors, 6% to connected apps (Drive, Calendar, Gmail), not counting the active skills, web search, artifacts. Everything is read every time.
5 habits on Claude chat to cut your usage by 3
Good news: on the classic chat, you can manage this much better with a few habits:
- Turn off what you don't use. Every active skill and connector is read with every message. Turn them on on demand, off after use. It's 2 clicks in the bottom-left menu.
- Choose the right model. Opus eats through your limits much faster than Haiku. On the API, Opus 5.5 costs 4 times more per token than Haiku 4.5 ($4 vs $1 per million input tokens, as of October 2026). Sonnet is enough for 90% of everyday work (writing, analyzing, structuring). Save Opus for genuinely complex problems. And turn off adaptive thinking by default, enable it only when it's useful.
- Edit rather than reply. When Claude heads in the wrong direction, your instinct is to type “no, try this instead”. Bad habit: the failed attempt stays in the context and pollutes what follows. The right habit: go back to the original message, edit it with what you've learned, regenerate. The failure disappears, the context stays clean.
- Upload once, reuse everywhere. The worst habit is uploading the same PDF into 5 different chats. With Projects on Claude, you upload once, accessible across all the project's chats. Claude uses RAG in the background: it only reads 8 to 12% of the document, just what's relevant to your question.
On Claude Code, it's even more critical (and a bit different)
Claude Code consumes much faster than the chat. One session is equivalent to 20+ classic chats. That's where most Pro and Max users hit a wall.
And there's a slightly technical but really important concept to understand: prompt caching. Basically, with every message, Claude caches the start of your conversation (system instructions, tools, project context…) so it doesn't have to reprocess everything. As long as the start doesn't change, it costs much less. As soon as you change something in the middle, the cache “breaks” and everything is reprocessed from scratch.
Then there are other habits to keep in mind on Claude Code:
- Don't continue by default: after each Claude response, you have 5 options. And they don't all cost the same. Continue: the whole history stays (the most expensive option, and the one we pick 99% of the time without thinking). Rewind: go back to a previous message, everything after it is deleted. Compact: summarize the conversation to condense it (more on this below). Sub-agent: delegate a subtask in a separate context. Fresh session: start over in a new chat with just the brief.
- Start clean at the right moment. When you reach 60% of context, two options: make a summary and continue on the same session (Claude condenses the conversation, you carry on from it) or start from scratch (you write a concise brief yourself in a new chat). The new chat is more precise: you decide what matters.
- Don't switch models mid-session. If you're 100k tokens into a conversation with Opus and you switch to Haiku to “save”, it's the opposite: Haiku has to rebuild the entire cache. It costs you more than letting Opus finish.
- Don't add or remove tools (MCP, skills) mid-session. The instinct is to say “I'll enable this skill just for this task”. Bad idea: it breaks the cache for the whole conversation. Decide your tools at the start of the session and leave them alone.
- Keep your CLAUDE.md stable. This file is read with every message. If you modify it mid-session, the cache breaks too. Make your updates between sessions, at the end, not during.
- Delegate heavy tasks to sub-agents: Some tasks generate a lot of “noise”: reading 20 files, running 10 searches, exploring a topic in depth. If you do them in your main session, all that noise piles up in your context and weighs on what follows. The best move is to delegate to a sub-agent. It works in its own context, does all the raw work, and returns only the useful conclusion to you. Your main session stays light. A word of caution though: a sub-agent is only good for isolated tasks (one search, the analysis of a single file). If you ask it for something that requires re-reading your whole project to understand the context, you pay to read the project twice.
The future of prompting: less prompt, more context
A lot has changed in prompting, where everything now comes down to how you organize your environment.
Skills, projects, connectors, memory… everything pushes in the same direction: structure once, and let the model go fetch what it needs at the right moment, rather than re-injecting everything into every prompt.
It's also what justifies the huge compute investments underway (in May 2026, Anthropic signed a compute deal with SpaceX). The vendors have understood that token frugality is becoming a business-critical topic, as much for them as for you.
There's a good chance that by mid-2027, the right prompt will be 3 lines, and 80% of the response quality will depend on how you've structured your working folder, your skills and your connectors upfront. Structuring that context is precisely what we set up with teams in our Claude training.
