# Why UI work burns more Claude Code tokens than backend work

> Claude Code sends your whole conversation with every request, so a pasted screenshot is billed on that turn and on every turn after it. One 1080p screenshot over 10 turns costs 26,910 input tokens; four cost 107,640 — calculated at 2,691 each on Claude 4.7 and later, high-resolution tier.

Author: Roberto Ercole · Published: 2026-08-16 · Updated: 2026-08-16 · Canonical URL: https://usewalkie.com/blog/image-tokens-compound-every-turn/

---

Backend sessions feel cheap and frontend sessions feel expensive, and most people put it down to frontend work being fiddlier. The real difference is structural: only one of the two puts images into the conversation, and an image is the one thing in a context window that costs thousands of tokens and gets re-read on every request that follows.

## Why does a screenshot cost tokens more than once?

Because the whole conversation is resent with every request. [Anthropic's vision documentation](https://platform.claude.com/docs/en/build-with-claude/vision) puts it plainly: "In multi-turn conversations and agentic workflows, each request resends the full conversation history. If images are base64-encoded, the full image bytes are included in the payload on every turn."

[Anthropic's context-window documentation](https://platform.claude.com/docs/en/build-with-claude/context-windows) says the same thing from the accounting side: "Everything in the request counts toward the context window: the system prompt, every message in `messages` (including tool results, images, and documents), and your tool definitions." It also notes that as a conversation advances, "each user message and assistant response accumulates within the context window, and previous turns are preserved completely."

Claude Code inherits that behavior directly. [Anthropic's Claude Code cost documentation](https://code.claude.com/docs/en/costs) explains why a long session drains a plan faster than the activity suggests: "Claude Code sends your full conversation with every request, and each time Claude uses tools it sends another request carrying that batch of tool results."

One honest correction before the arithmetic. Re-sent is not the same as re-billed at full rate. [Anthropic's prompt-caching documentation](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) prices cache reads at 0.1 times the base input rate, with a five-minute lifetime by default and a one-hour option, and images are cacheable content. But caching is a discount, not a deletion — the context-window documentation states that "Cached prompt prefixes still occupy the context window: prompt caching changes what you pay for those tokens, not whether they count." Every figure below is the uncached, list-rate ceiling. A cache hit lowers the dollars; it does not free up the window.

## How fast does it compound?

Multiply. Image tokens carried per session = screenshots x 2,691 x turns, on Claude 4.7 and later, the high-resolution tier, where a single image is capped at 4,784. One screenshot over 10 turns is 26,910 input tokens. Four screenshots over 10 turns is 107,640. Both calculated.

| Carried in context | 1 turn | 5 turns | 10 turns | 20 turns | Cost at 20 turns, at $10 per million input tokens |
|---|---|---|---|---|---|
| 1 screenshot (2,691 tokens) | 2,691 | 13,455 | 26,910 | 53,820 | $0.54 |
| 2 screenshots (5,382 tokens) | 5,382 | 26,910 | 53,820 | 107,640 | $1.08 |
| 4 screenshots (10,764 tokens) | 10,764 | 53,820 | 107,640 | 215,280 | $2.15 |
| 1 Walkie bundle (about 3,500 tokens) | 3,500 | 17,500 | 35,000 | 70,000 | $0.70 |

Every cell is calculated: tokens = payload x turns, and dollars = tokens divided by 1,000,000, times 10, at $10 per million input tokens.

Two things in that table are worth saying out loud. First, compounding does not change any ratio — it is linear, so a bundle is the same multiple cheaper at turn 20 as at turn 1. What changes is the absolute stake: a gap of 7,264 tokens at turn one becomes 145,280 tokens by turn twenty. Second, the bottom-right corner of the screenshot rows crosses a real ceiling. Four screenshots carried through 20 turns is 215,280 input tokens of images alone, which does not fit inside a 200,000-token context window at all. Nothing about that session is unusual; it is one page, reviewed four times.

To price your own screen resolution against the same formula, use the [screenshot token cost calculator](/calculator/). For the cross-vendor version of this table, see the [visual context token cost benchmark](/research/visual-context-token-cost/).

## Why frontend sessions look expensive

Frontend work is where images enter the conversation at all. A backend session is text end to end — files, diffs, stack traces, test output — while a UI session adds screenshots, and each 1080p screenshot is 2,691 input tokens on Claude 4.7 and later, the high-resolution tier, capped at 4,784, carried forward on every request after it.

The interpretation follows from the mechanism rather than from any survey. Text turns are small and roughly constant. An image turn is a step change: one paste can add more input tokens than the previous ten messages combined, and unlike a message you regret, it does not shrink. That is why the felt cost of a UI session is back-loaded — the expensive part is not the moment you paste, it is the twelve turns of iteration afterwards, each carrying the same pixels.

It also explains a pattern that looks like a bug and is not: the same fix costs more when it takes longer. On text, a slow session costs a little more. On a session with four screenshots in it, every extra round trip is another 10,764 tokens of images before a single new word is read. The multiplier is your patience.

Worth naming clearly: none of this makes visual feedback wrong. It makes *undirected* visual feedback expensive. The question is what you put in the conversation, and how long you leave it there. That is the wider subject of [what visual feedback for AI coding agents actually is](/blog/what-is-visual-feedback-for-ai-coding-agents/).

## What to send instead

Text, wherever text will do. A CSS selector, a file path and a sentence naming the expected state cost a fraction of an image and stay legible after compaction. Where pixels are genuinely required, send fewer and smaller ones, or send a compiled review: a Walkie bundle averages about 3,500 tokens (measured, typical) against 10,764 for four screenshots (calculated).

In rough order of what saves the most:

1. **Name the thing instead of showing it.** A selector plus "should be flush along the top edge" is a few dozen tokens and is more precise than an image, because it says which element you mean.
2. **Crop before you paste.** The patch formula bills by area, so a cropped region of a 1080p screen costs a fraction of the full 2,691 tokens it would cost whole on Claude 4.7 and later, the high-resolution tier, where the per-image cap is 4,784. The [screenshot token cost calculator](/calculator/) prices any width and height.
3. **Send one image, not four.** Four screenshots covering one page is 10,764 tokens (calculated) with no narration attached. One cropped image plus a sentence usually carries more meaning.
4. **Compile the review instead of streaming it.** A [REVIEW.md bundle](/blog/what-is-review-md-bundle/) puts a transcript first and only the pointed frames after it — about 3,500 tokens (measured, typical) for a whole review, against 80,730 for the same 30 seconds frame-dumped at one frame per second (calculated).
5. **Clear the images out when the fix lands.** Anthropic's Claude Code cost documentation recommends `/clear` when switching to unrelated work, and notes that `/clear` costs nothing while `/compact` reads the conversation it summarizes.

The bundle compounds too, of course — 3,500 tokens carried through 20 turns is 70,000. Nothing escapes the multiplier. The only lever is what you hand over in the first place.

## How to check what a session actually cost

Run `/usage` in Claude Code. It reports the session's token counts and a locally computed dollar figure, and on a paid plan it also attributes recent usage to skills, subagents and individual MCP servers, and flags behaviors such as long context or cache misses when one accounts for 10% or more of recent usage.

Three commands do most of the diagnosis, all documented in [Anthropic's Claude Code cost documentation](https://code.claude.com/docs/en/costs):

1. `/usage` — session token counts, plan usage bars, and the attribution and behavior-flag breakdown.
2. `/context` — what is currently taking up space, which is where a forgotten screenshot shows itself.
3. `/clear` — start fresh when the task changes, which is the only way to actually remove an image from the bill.

For scale, [that same documentation](https://code.claude.com/docs/en/costs) puts the average across enterprise deployments at around $13 per developer per active day and $150 to $250 per developer per month, with 90% of users staying below $30 per active day. Those are Anthropic's numbers for whole days of work across a whole organization, not for one session — which is the point of comparison worth having when a single UI review shows up as $2.15 of images.

For a line-item walk through one real session, see [what one Claude Code session actually costs](/blog/what-a-claude-code-session-costs/); for the wider set of levers, see [Claude Code token costs](/blog/claude-code-token-costs/) and [what a context window is](/blog/what-is-a-context-window/).

---

Read the HTML version: https://usewalkie.com/blog/image-tokens-compound-every-turn/