How to Improve Your AI Coding Yield
Yield (Υ) is the headline metric of token-cascade efficiency. Here are seven concrete strategies to raise it — with before/after examples.
What Υ Yield means
Yield (Υ) = (cache_read × output) / input². It measures the architecture of your token cascade — whether signal is compounding (high cache reuse × high output per fresh input) or tokens are being burned (low cache, high fresh input, low output).
The formula has three levers, and understanding them is the key to improvement:
- Increase cache-read — reuse context via prompt caching. This is the highest-leverage lever because it appears in the numerator and enables cheaper turns.
- Increase output — get more signal per turn. Better prompts produce more useful code per response.
- Decrease input — send less fresh context. Input is squared in the denominator, so reducing it has an outsized effect on yield.
Strategy 1 — Build a stable context window
Prompt caching only fires when prior context matches. If you reorder your context, re-paste files, or change the system prompt between turns, the cache invalidates and the model re-processes everything as fresh input. Keep your context window stable: same system prompt, same file order, same project preamble. Send only the delta — the new instruction or the changed file — on top of the cached base.
Before
Every turn: paste the full file, paste the system prompt, paste the project context, then add your instruction. Cache-read stays at zero. Input balloons. Yield tanks.
After
Turn 1: send the full context (cache-write fires). Turn 2+: send only the changed lines and your instruction. Cache-read soars. Input shrinks. Yield climbs.
Strategy 2 — Engage prompt caching deliberately
Most platforms support prompt caching, but it engages automatically only when your context is stable and large enough to hit the cache threshold (typically 1,024+ tokens on Claude). To engage it deliberately: front-load your stable context (project rules, file contents, coding standards) in the first turn, then keep it in the same position for every subsequent turn. The model will read from cache instead of re-processing.
Track your cache hit rate = cache_read / (cache_read + cache_write). A hit rate above 80% means your caching strategy is working. Below 50% means your context is churning.
Strategy 3 — Use structured, minimal inputs
Verbose prompts burn input tokens. A 500-token prompt that could be 50 tokens costs you 10× in the yield denominator (100× because input is squared). Structure your inputs: use bullet points, file references instead of pasted content, and concise instructions. Remove pleasantries, restated context, and redundant constraints the model already has in cache.
Before
“Hey, so I have this function here and I was wondering if you could maybe look at it and see if there’s a way to make it faster because it’s kind of slow when I run it with large inputs and I think the problem might be in the nested loop but I’m not sure...” (80 tokens, zero signal density)
After
“Optimize the nested loop in `processBatch` — it’s O(n²). Target O(n log n).” (15 tokens, same intent, 5× less input, 25× less penalty in the yield denominator)
Strategy 4 — Reduce re-rolls
Every re-roll sends fresh input and generates new output without advancing cache-read. Three re-rolls on the same task triples your input and output without increasing your effective signal. Plan your prompt before sending. If the response is wrong, correct it with a small delta on top of cached context rather than re-rolling from scratch.
A correction (“No, I meant the second function, not the first”) is a small input delta on top of cache. A re-roll (“Try again”) is a full fresh input with no cache benefit. Corrections compound; re-rolls burn.
Strategy 5 — Reuse cache across sessions
If your platform supports cross-session caching (Claude Code does), keep the same project context loaded across sessions. The cache persists, and your first turn in a new session can hit cache-read immediately instead of starting from zero. This is especially powerful for long-running projects where the codebase context is stable.
Strategy 6 — Batch related tasks in one turn
Instead of sending three separate prompts for three related changes, batch them into one turn. The model processes the context once (from cache) and produces all three outputs in a single response. You get more output per unit of input, and cache-read stays high because the context didn’t change between sub-tasks.
Strategy 7 — Prune noisy context
Context that isn’t relevant to the current task dilutes your signal. If your context window includes files the model doesn’t need, it still processes them — either as fresh input (bad) or as cache-read that doesn’t contribute to output (wasted cache). Prune your context to only what’s relevant. Smaller, focused context means higher output per input token.
Track your signal-to-noise ratio (SNR) = signal tokens / total tokens. A high SNR means your context is focused; a low SNR means you’re carrying noise.
Before/after: the full picture
Before
Unstable context, verbose prompts, 3 re-rolls per task, full re-paste every turn. Input: 50,000. Output: 8,000. Cache-read: 2,000. Yield = (2,000 × 8,000) / 50,000² = 0.0064
After
Stable context, minimal deltas, corrections instead of re-rolls, pruned context. Input: 5,000. Output: 12,000. Cache-read: 40,000. Yield = (40,000 × 12,000) / 5,000² = 19,200
That’s a 3-million-fold improvement in yield — from the same operator, same model, same project. The cascade architecture changed; the raw effort didn’t.
FAQ
- What is Υ Yield?
- Υ = (cache_read × output) / input². It measures token-cascade efficiency — whether signal is compounding or tokens are being burned. High yield means efficient sessions; low yield means wasted fresh input.
- How can I improve my yield?
- Build a stable context window, engage prompt caching, structure inputs to be minimal, reduce re-rolls, reuse cache across sessions, batch related tasks, and prune noisy context. Each strategy increases cache-read or decreases input — both raise yield.
- What is prompt caching and why does it matter?
- Prompt caching lets the model reuse previously-processed context. When your context is stable, the model reads from cache instead of re-processing fresh input. Cache-read tokens are cheaper and multiply your yield.
- How do I know if my yield improved?
- Run `sigrank me` before and after, or use the /score calculator. Submit a new snapshot to update your leaderboard rank and class tier. Track across 7d, 30d, 90d, and all-time windows.
- What yield is considered good?
- 5,000 is solid. 50,000 is excellent. Top operators push into six figures. Your class tier (IGNITER → SEEKER → BUILDER → TRANSMITTER) is assigned from yield and cascade shape.