Published: 2026-07-30
Deep dive

Why You Hit Token Limits: 15 Rules for Claude, Codex and ChatGPT

Chapters / key moments (click to jump — plays here on the page)

You ask a handful of questions and the tool tells you to come back in three hours. Nate B Jones instrumented his own usage to find out why: in one working day his tracker logged 3.77 billion tokens moving through his Codex workspace across 143 threads — and 3.59 billion of those, roughly 96%, were reused input. Nobody typed them. Every time you hit enter, the whole conversation is packaged and re-sent from the top, because that is how models fake memory. This page collects the fixes he lays out, organised the way he does: habits anyone can adopt, a skill that automates most of them, and a local proxy that shrinks the request before it's ever sent.

Source video

"Paste This Into Claude, Never Hit a Token Limit Again" by Nate B Jones — Watch on YouTube →

Editorial note

Two of the three levels below are the presenter's own products — the Token Saver skill and the Ringer framework. Level 1 costs nothing and needs no software; it is where most of the measured savings came from. We've kept the numbered rules as stated in the video, including a gap in his own numbering.

The mechanism, in one paragraph

Your first message costs exactly what you typed. Your second costs what you typed plus the previous answer plus the original message. By message thirty, the thing you just wrote is a rounding error against everything being re-sent behind it. That older material has a name — reused input: the portion of every request the model has already seen. His argument for why this won't be fixed for you: labs are incentivised to have you spend tokens, and nobody is graded on lowering your consumption. It's your desk to keep clean.

Level 1 — Habits (no install, works on any AI)

Rule 1 — Edit your mistake instead of correcting it in the next message
When a reply misses because your request was unclear, the instinct is to type "no, that's not it." That appends both the bad answer and your correction to everything that gets re-sent forever after. Use the edit button on the original message, fix the ambiguity, and resend. He notes almost nobody actually does this.
Rule 2 — Ask related questions together, and name the output shape
If several questions come off the same document set, put them in one query. Then say what you want back: a one-pager, 150 words, just the bullets, just the headline. Naming the format removes ambiguity the model would otherwise spend tokens resolving.
Rule 3 — Start a clean task when the job changes
This "drove the biggest measured change" across his own Codex and Claude installs. Long threads are good while you're on one problem and expensive when you're not. A fresh task doesn't report zero — the tool still sends its own system instructions — but it stops the old conversation riding along. You aren't throwing the previous thread away; you're just refusing to make the next job carry it.
Rule 4 — Carry the artifact forward, not the argument
In a multi-stage job (research, then drafting), carry only the output of the finished stage into the next one. You don't need the bad first draft, three rounds of criticism, the sources you rejected and the model's reasoning stacked into step two. Take the result and move on.
Rule 5 — Ask only for the answer you need, because output is billed twice
Output costs once when it's generated, then again as input on the next turn, and every turn after that. A 50-page deep-research report keeps charging you for the rest of the conversation. If you need a paragraph, ask for a paragraph; if you need JSON, ask for JSON; if you need five bullets, say five bullets.
Rule 6 — Search the file yourself instead of making the model search it
Model-side file search is a convenience and a large token burner. Find the relevant passage, hand over the snippet, and say explicitly that the model does not need to read the whole file.
Rule 7 — Send the lightest useful form of the source
If the words matter and the layout doesn't, convert to text or markdown and paste that. A PDF plus eighteen screenshots will be sorted out by the model — and will eat your budget doing it. Don't send a PDF just because the source arrived as one.
Rule 9 — Keep accepted answers somewhere retrievable
(His numbering skips 8 in the video.) When you circle the same problem across several conversations, store the findings in a database you can query — he uses OpenBrain, but any store works. Looking a fact up is dramatically cheaper than having the model re-derive it, re-search the sources, or recalculate it.

Level 2 — The Token Saver skill

He packaged most of Level 1 as a skill called Token Saver, installed with one command into Codex, Claude Code, or wherever you keep skills, and invoked by asking for it on a given job. What he says it does: search before opening large sources; send selected passages instead of whole files; run exact work as code where possible; save the version you accepted and build the next request from that result plus your change; hold answers to the length you asked for; and stop pointless retries.

Level 2.5 — The advanced rules the skill assists with

Rule 10 — Load only the tools the job can actually use
Every connected tool ships a description — what it does, when to use it, what arguments it takes — and that text is model input before anything happens. He cites Anthropic's published work: a typical setup with several tool servers connected (GitHub, Slack, Sentry, Grafana) burns roughly 55,000 tokens in tool definitions before Claude does any work. He expects models to manage this themselves within six to eight months; they don't reliably do it today.
Compaction and context editing, for threads you can't restart
Sometimes starting clean isn't practical — you're mid-debug and the model needs a decision from you. OpenAI supports compaction for long-running work, carrying state forward in fewer tokens. Anthropic supports context editing, which clears old tool results and thinking blocks before the next request. Both help; both are approximations of your earlier prompts and responses, so treat the recovered context as lossy.
Use the dumbest model that still does the job
A smaller model is cheaper but trades away context and capability. The skill takes a first-pass opinion on whether your current model is right for the task; you're free to disagree. His heuristic, stated plainly: for a serious task, use the absolute dumbest model that will still get the work done.
Prompt caching — real, but an API concern
Caching a stable prefix makes repeated work much cheaper. He is direct that this is an API-level feature and not a "clean your desk" fix for a regular knowledge worker: if you don't know what an API is, by definition you don't need this, and the habits above will do more for you.

Level 3 — Ringer, a local intermediary

Everything above shares one ceiling: a skill cannot shrink the call it is inside of. By the time the model reads the skill, the conversation, the standing instructions, the tool definitions and the hidden setup are already in the envelope. Ringer is his answer — a local process sitting between your AI and the model provider, before the request goes up. Depending on the case it can return an answer with no model call at all, run a fixed local recipe, select only the useful passages to forward, forward a small request under hard limits, or stop the call entirely. It isn't another chat window; you keep working where you already work.

Rule 14 — Enforce hard limits
Cap outbound request size, cap response size, cap the call so you never send ten million tokens by accident. He is clear this is only enforceable with an intermediary in the path — you can't really do it from inside the conversation.
Rule 15 — Answer from your own store before calling the model
Ringer can query OpenBrain or your database first and reply "we already answered this last week — is this what you mean?" That saves not part of the call but 100% of it.

Gotchas & Caveats

Levels 2 and 3 are the presenter's own tools. Token Saver and Ringer are his products, distributed through his Substack. The Level 1 habits are vendor-neutral and cost nothing.
Compaction and context editing lose fidelity. You continue against an approximated version of the earlier conversation. Better than hitting the wall, but not the same as having the original context.
A "clean task" never reports zero. System instructions and tool definitions are re-sent regardless. Rule 10 is what attacks that floor.
Prompt caching is not a chat-UI fix. It applies to API work with a stable prefix and repeated calls.
More capability makes this worse, not better. His framing: the more tools you hand a capable model, the more material it pulls in and the faster you hit the wall.

Key Takeaways

96% of a heavy user's daily token volume was reused input — text nobody typed, re-sent on every turn.
Starting a fresh task when the job changes produced the single biggest measured saving, and costs nothing to adopt.
Output is charged twice: once when written, then repeatedly as input on every subsequent turn. Ask for the shortest useful answer.
Tool definitions alone can consume ~55,000 tokens before a request does any work — connect only the servers the job needs.
A skill can only optimise from inside the request; shrinking the request itself requires something in the network path.
The habits transfer across Claude, Codex, ChatGPT and any other chat model — none of them are platform-specific.