How to keep your AI coding agent's context window from filling up

Every AI coding agent works inside a context window — the finite amount of text it can "see" at once: your messages, its replies, the files it reads, the command output it runs. When that window fills up, quality drops in ways that feel mysterious. The agent forgets a decision you made twenty minutes ago, re-reads a file it already edited, or quietly contradicts itself. On any task longer than a few minutes, managing context is the single biggest lever you have over output quality. Here is how to do it deliberately.

Why a full window hurts

Models don't degrade gracefully when the window gets crowded. Two things happen. First, older messages get pushed toward the edges, where the model attends to them less reliably — the classic "lost in the middle" problem. Second, most agents auto-summarize when they run low on room, and an automatic summary made under pressure is lossy: it might drop the exact constraint you cared about. The fix is to stay in control of what the agent is holding, rather than letting it fill up and improvise.

Watch how full the window is

You can't manage what you can't see. In Claude Code, run /context to print current usage as a percentage. A good rule of thumb from practitioners is to act at around 60% utilization on a complex task — well before the ~80% mark where automatic compaction kicks in. Cursor and Codex surface a similar indicator in their UIs. Glancing at that number every so often turns context management from a vague worry into a concrete signal.

Compact at checkpoints — don't just keep going

When you hit a natural checkpoint (a feature works, tests pass, a bug is fixed), compress the history instead of letting it grow. In Claude Code, /compact replaces the full transcript with a model-generated summary — a 70,000-token conversation can drop to roughly 4,000 tokens. Crucially, you can steer what survives:

/compact "Keep the API contract and the DB schema we agreed on. Summarize the debugging session — I only need the root cause, not every step."

Compacting proactively, while there's still headroom, produces a better summary than an automatic one triggered at the last second, because the model still has clear recall of the whole conversation when it writes the summary.

Clear when you switch tasks

/compact is for continuing the same thread of work. /clear is for abandoning it. When you pivot to something unrelated — you finish a backend fix and move to a frontend feature — start fresh. Carrying the old context forward doesn't help; it just wastes tokens and risks the agent pattern-matching onto the previous task. Clearing is also the cure when the context is "poisoned": the model has latched onto a wrong assumption and keeps reverting to it no matter how you correct it.

Put stable knowledge in a file, not in chat

If you find yourself re-explaining the same things — your test command, your naming conventions, which directory the API lives in — that information shouldn't live in the conversation at all. Put it in a project file the agent reads automatically: CLAUDE.md for Claude Code, AGENTS.md for Codex and others, .cursorrules for Cursor. It loads at the start of every session, so the agent has it from message one, and it survives every /clear and /compact. Keep it lean, though — it costs tokens on every single request, so a bloated CLAUDE.md is its own kind of context waste.

Give the agent less, not more

The instinct to dump ten files "so it has everything" backfires. Each file you paste or @-mention consumes budget and dilutes the model's attention. One well-chosen file is usually better than ten. Start minimal and add context only when the agent actually needs it. If you're not sure which file matters, ask the agent to find it first rather than pre-loading the whole directory.

Delegate messy exploration to a subagent

Some tasks are inherently verbose — "search the codebase for every place we call the payments API." If you run that in your main session, the raw output of the search floods your window. Instead, delegate it to a subagent (Claude Code's Task tool, or a separate Cursor agent). The subagent does the noisy exploration in its own isolated window and hands back only the conclusion — the three files that matter — keeping your main context clean.

A working rhythm

Put together, a healthy long session looks like this:

1. Start with a concise CLAUDE.md so the agent knows your project.
2. Scope each task narrowly; reference only the files it touches.
3. Glance at /context every 30–45 minutes or after each milestone.
4. /compact with a custom instruction at each checkpoint.
5. /clear the moment you switch to unrelated work.

None of this is exotic. It's the difference between an agent that stays sharp across a two-hour session and one that starts strong and slowly loses the plot — and it costs you a few seconds of attention rather than a mysterious afternoon of debugging its confusion.