What are the most common sources of token waste?

The four most common sources are: repeated context (re-sending files the model already has), poor prompt caching (unstable context windows that invalidate cache), verbose prompts (conversational padding instead of structured instructions), and unnecessary re-rolls (regenerating from scratch instead of correcting). Each wastes fresh input tokens, which are squared in the yield denominator.

How do I identify token waste in my cascade?

Run `sigrank me` and examine your four pillars. High input with low cache-read means repeated context. Low cache hit rate (cache_read / (cache_read + cache_write) below 50%) means poor caching. High input with low output means verbose prompts or re-rolls. Each pattern points to a specific waste source.

How do I fix repeated context waste?

Build a stable context window: keep the same system prompt, file order, and project preamble across turns. Send only the delta — the changed lines or new instruction — on top of the cached base. This engages prompt caching and converts fresh input into cache-read.

How do I measure token waste reduction?

Compare your Υ Yield before and after applying fixes. Yield = (cache_read × output) / input², so reducing input (less waste) and increasing cache-read (more reuse) both raise yield. Track cache hit rate and input count as secondary indicators. Use `sigrank me` across 7d, 30d, and 90d windows.

Does reducing token waste save money?

Yes. Fresh input tokens are the most expensive token type. Cache-read tokens are significantly cheaper on most platforms. By converting fresh input into cache-read (via stable context windows), you reduce both your token spend and your yield penalty simultaneously.

◈ Guide

How to Reduce Token Waste

Token waste is the silent killer of AI coding efficiency. Here’s how to find it, fix it, and measure the improvement.

Common sources of token waste

Token waste isn’t about using too many tokens — it’s about using the wrong kind. Fresh input is expensive (squared in the yield denominator); cache-read is cheap (in the numerator). Waste happens when you burn fresh input that could have been cache-read. The four most common sources:

1. Repeated context

Re-sending files, system prompts, or project context the model already has. Every re-paste is fresh input that could have been cache-read. The #1 waste source — and the easiest to fix.

2. Poor prompt caching

Unstable context windows that invalidate the cache between turns. If you reorder context, change the system prompt, or restructure your file list, the cache breaks and everything re-processes as fresh input.

3. Verbose prompts

Conversational padding, restated context, and redundant instructions. A 500-token prompt that could be 50 tokens costs 100× more in the yield denominator (input is squared). Brevity isn’t just style — it’s math.

4. Unnecessary re-rolls

Regenerating from scratch instead of correcting. Each re-roll sends fresh input and generates new output without advancing cache-read. Three re-rolls triples your input with zero cache benefit.

How to identify waste in your cascade

Run sigrank me and examine your four pillars. Each waste source leaves a specific fingerprint:

High input, low cache-read → repeated context
You’re re-sending context the model already has. Your cache hit rate will be low (below 50%). Fix: stabilize your context window.
Low cache hit rate → poor prompt caching
Cache hit rate = cache_read / (cache_read + cache_write). Below 50% means your cache is churning. Fix: keep context stable across turns.
High input, low output → verbose prompts
You’re sending a lot but getting little back. Your compression ratio (output / input) will be low. Fix: structure inputs to be minimal.
High input, high output, low cache-read → re-rolls
You’re generating a lot of output but not reusing context. Multiple re-rolls produce high output but low signal density. Fix: replace re-rolls with corrections.

Concrete fixes for each waste source

Fix: Repeated context

1. Front-load stable context (project rules, file contents) in turn 1.
2. Keep the same context order in every subsequent turn.
3. Send only the delta — changed lines, new instructions — on top of cache.
4. Use file references instead of re-pasting file contents.

Fix: Poor prompt caching

1. Don’t reorder context between turns — position matters for cache.
2. Don’t change the system prompt mid-session.
3. Ensure your context exceeds the cache threshold (typically 1,024+ tokens).
4. Track cache hit rate — target above 80%.

Fix: Verbose prompts

1. Remove conversational padding (“Hey, so I was wondering...”).
2. Use bullet points and file references instead of prose.
3. Don’t restate context the model has in cache.
4. Target 3-5× reduction in input tokens per turn.

Fix: Unnecessary re-rolls

1. Plan your prompt before sending — know what you want.
2. If the response is wrong, correct with a small delta on top of cache.
3. Reserve re-rolls for when the model is truly off-track, not for minor adjustments.
4. Track re-roll count per task — target zero or one.

Measuring improvement

After applying the fixes for a week, run sigrank me again and compare against your pre-fix baseline. The key indicators:

Υ Yield should rise — less input and more cache-read both push it up.
Cache hit rate should climb toward 80%+ as your context stabilizes.
Input count should drop — fewer fresh tokens, more cache reuse.
Compression ratio should rise — more output per input token.

Submit a new snapshot with sigrank submit to update your leaderboard rank and class tier. If your yield improved significantly, you may have jumped a tier.

FAQ

What are the most common sources of token waste?: Repeated context, poor prompt caching, verbose prompts, and unnecessary re-rolls. Each wastes fresh input tokens, which are squared in the yield denominator.
How do I identify waste in my cascade?: Run `sigrank me` and examine your pillars. High input + low cache-read = repeated context. Low cache hit rate = poor caching. High input + low output = verbose prompts. High input + high output + low cache-read = re-rolls.
How do I fix repeated context waste?: Build a stable context window. Send only deltas on top of cached context. Use file references instead of re-pasting contents.
How do I measure waste reduction?: Compare yield before and after. Reducing input and increasing cache-read both raise yield. Track cache hit rate and input count as secondary indicators.
Does reducing token waste save money?: Yes. Fresh input tokens are the most expensive. Cache-read tokens are significantly cheaper. Converting fresh input into cache-read reduces both spend and yield penalty.

Next: How to Improve Your Yield →