Stop Wasting Tokens: The Claude Code Context Workflow

Short answer

Most token waste in AI coding agents comes from making the main chat carry everything: the codebase, logs, docs, test output, decisions, and old conversation history.

The fix is not one magic prompt. It is a context workflow: keep big material in files, use subagents for noisy work, store reusable memory outside the main thread, protect prompt caching, and compact at clean handoff points.

That is how you build an AI coding setup that stays cheaper, clearer, and easier to steer.

Why tokens get wasted

A chat feels cheap because you only type one message. Under the hood, the model often receives a large prefix: instructions, tools, files, summaries, and conversation history.

If you paste a giant document or dump a full log into the main thread, that context can keep following the conversation. You pay attention and tokens for material that may no longer matter.

The practical rule is simple: the main agent should carry decisions, not every raw artifact that produced those decisions.

Step 1: move big context out of the window

Do not load everything up front just because the model might need it.

Put large source material in files: docs, specs, code, call notes, exports, screenshots, logs, examples, and research. Then ask the agent to search, inspect, or read the exact part needed for the current task.

This is the heart of context engineering. The agent still has access to the knowledge, but the whole thing does not have to sit inside the active context window.

Step 2: use subagents for noisy work

Subagents are useful when the task creates a lot of temporary noise: test output, stack traces, research scans, dependency inspection, scraping, migration logs, or source comparison.

The subagent can read the mess in its own context and return the main agent a clean summary: what failed, why it failed, which files matter, and what should happen next.

Think of the subagent as a filter. Raw noise goes in. A short, useful diagnosis comes back.

Step 3: memory should be an index, not a dump

Project memory is useful when it saves you from explaining the same setup every session. It becomes expensive when it turns into a giant wall of instructions that loads every time.

Keep permanent instruction files short and stable. Use them for rules that almost never change: build commands, folder structure, style rules, deployment notes, safety checks, and what not to touch.

For bigger knowledge, use memory files like a table of contents. One line points to one topic file. The agent can pull the relevant file only when the task needs it.

Step 4: protect prompt caching

Prompt caching is the quiet multiplier. Stable repeated input can be cached, which can reduce cost and latency compared with sending the same tokens fresh every time.

The catch is that caching depends on stable prompt structure. If timestamps, changing session notes, reordered tools, or random text appear before the stable material, the cache can miss.

Put stable instructions first. Keep them boring and consistent. Put volatile material lower in the request or in retrievable files.

Step 5: compact between tasks

Compaction is useful, but timing matters.

If you let the system compact in the middle of a hard task, it may summarize away the wrong detail. If you compact after a clean milestone, the summary can preserve the decision and drop the noise.

The habit is simple: finish the task, summarize the result, name the next goal, then compact. That keeps the next session small without losing the thread.

The self-managed agent loop

Once the workflow is in place, the agent can manage more of its own context.

A practical self-managed agent loop checks what it needs, reads only that source, delegates noisy work, writes a concise result, updates durable memory only when something is reusable, and stops when the task is complete.

This connects directly to state machines: the agent should have clear states for planning, researching, editing, reviewing, awaiting approval, done, and failed. Context management becomes part of the workflow, not a heroic afterthought.

What not to believe

The phrase "90 percent fewer tokens" can be true in narrow examples, especially when a huge static document is moved out of the prompt and replaced with targeted retrieval.

But it is not a guaranteed result for every project. Your savings depend on how much repeated context you currently send, how stable your prompt prefix is, how often you inspect huge files, and whether your workflow actually uses summaries instead of raw dumps.

The safer promise is this: better context management lowers waste and makes the agent easier to control.

Reference links

These sources are useful for the official mechanics behind prompt caching, Claude Code memory, and context management.

Sources: Anthropic: prompt caching, Anthropic: token counting, Claude Code: memory, Claude Code: slash commands, Claude Code: settings

Final answer

The cheapest AI coding agent is not the one with the smallest model. It is the one that carries the smallest useful context.

Keep raw material in files, use subagents for noisy work, make memory retrievable instead of bloated, protect prompt caching, and compact between tasks. That is the context workflow that keeps AI agents useful without letting the token bill quietly grow.