Claude Code Losing Context: Stop the Verbosity Spiral

You're deep in a Claude Code session, it's making progress, and then it starts narrating: "Let me check this file... Let me verify that... Let me re-read the config." Twenty messages later it's forgotten what you asked for, the context window is full, and you're staring at a session that died without saving anything. This is fixable, and none of the fixes require you to write code.

Quick answer: Claude Code loses context because the window fills with narration, tool output, and repo dumps until earlier instructions get pushed out. Stop it by running /compact before the window fills (not /clear, which wipes everything), scoping the context you load instead of dumping the whole repo, offloading research to subagents, and adding a "do not narrate" directive to your CLAUDE.md.

Why Claude Code keeps forgetting earlier context

Claude Code has a fixed context window, and everything competes for space in it: your instructions, the files it reads, every tool result, and every line of its own narration. When that window fills, the oldest content, usually your original instructions, gets dropped. That's the "forgetting."

The community has named the specific failure clearly. On the Figma developer forum, builders describe the "Let me check... Let me verify..." narration loop that quietly eats the window before any real work ships. On dev.to, the widely-shared "Part 10" of an experienced-user series lists three top pains in order: context too long, conflicting CLAUDE.md rules, and tokens running out mid-task. And plenty of builders report the worst version: a session that "dies without a restore point," taking an hour of progress with it.

The root cause is not that Claude is dumb. It's that context is a budget, and by default you're spending it on things that don't matter. If you set up Claude Code properly for a business workflow in the first place (here's the full setup), you spend far less time firefighting context later.

/compact vs /clear: which one to use and when

Use /compact to summarize and shrink the current conversation while keeping the thread alive; use /clear to wipe context and start fresh. They solve different problems, and reaching for the wrong one is a common mistake.

The mistake that burns sessions: waiting until Claude is already confused, then hitting /clear in a panic and losing everything you'd built up. Compact early and often. A good habit is to compact after each meaningful milestone: a feature works, a file is written, a bug is fixed.

Scope the context instead of dumping the whole repo

Load only the files Claude needs for the current task, not your entire project. Dumping the whole repo is the single fastest way to fill the window with noise before any work begins.

When you point Claude Code at a large codebase and let it read freely, it will read freely, and each file it opens spends tokens you'll want later. Instead, tell it exactly which files and folders matter for the task in front of you. If you're editing the checkout flow, it doesn't need your entire test suite loaded into context.

For non-developers running Claude on business workflows, the same rule applies to documents. If you're processing an intake form, load the form and the rules for handling it, not the whole shared drive. This mirrors the boring-work thesis behind most of our 10 copy-paste Claude Code automations: tight scope, one job, done cleanly.

Use subagents for research so the main session stays clean

Send exploration and research work to a subagent, so the results come back as a short summary instead of pages of raw output cluttering your main context. This keeps your primary session focused on the actual task.

Here's the pattern: if you need Claude to figure out how something works across ten files before making a change, that "figure it out" phase produces a mountain of tool output. If it all lands in your main session, the window fills with reading nobody needs to keep. A subagent does the reading in its own context and hands back only the conclusion. Your main session gets the answer, not the archaeology.

This is the same delegation logic that makes the 3 agents most businesses should deploy first work: give each one a narrow job and a clean handoff, and the whole system stays legible.

Add a "do not narrate" directive to CLAUDE.md

Put an explicit instruction in your CLAUDE.md file telling Claude to stop narrating every step, and the verbosity spiral shrinks dramatically. The CLAUDE.md file is read at the start of every session, so rules there apply automatically.

Add something like this:

## Communication rules
- Do not narrate routine steps ("Let me check...", "Let me verify...").
- Act, then report the outcome in one or two sentences.
- Only explain your reasoning when I ask or when a decision has trade-offs.
- Batch tool calls; don't announce each one.

Keep the file short and non-contradictory. The dev.to pain list flags conflicting CLAUDE.md rules as a top failure for a reason: if one section says "explain your reasoning thoroughly" and another says "be terse," Claude will pick badly and you'll lose trust and tokens. Review the file whenever it grows past a screen.

The State-of-the-Union handoff prompt

Before a session ends or gets compacted, ask Claude to write a "state of the union" summary you can paste into the next session, so you never lose your restore point. This is the fix for sessions that "die without a restore point."

Paste this near the end of a working session:

Write a State of the Union handoff for the next session. Include:
1. The goal we're working toward, in one sentence.
2. What's done so far (files changed, decisions made).
3. What's left, as a short ordered list.
4. Any gotchas, dead ends, or constraints to remember.
Keep it under 200 words. I will paste this to start the next session.

Save that output somewhere outside the session, a note, a doc, wherever. When you come back, paste it in first. You've now recreated the important context in a fraction of the tokens a full transcript would cost. This one habit is the difference between a session that dies and a project that ships.

Common pitfalls that keep the spiral going

Even with the fixes above, a few habits quietly reintroduce the problem. Watch for these.

FAQ

Why does Claude Code forget what I asked earlier?

Because the context window is finite, and by default it fills with file reads, tool output, and narration until your original instructions get pushed out. Scope what you load, offload research to subagents, and compact at milestones to keep your instructions in the window.

What's the difference between /compact and /clear in Claude Code?

/compact summarizes the current conversation into a shorter version while keeping the task alive, freeing window space. /clear deletes the entire conversation to start fresh. Use /compact to continue the same task and /clear only when switching to unrelated work.

How do I stop Claude Code from narrating every step?

Add a "do not narrate" directive to your CLAUDE.md file instructing it to act first and report the outcome in one or two sentences rather than announcing each check. Because CLAUDE.md loads at the start of every session, the rule applies automatically.

How do I save my progress before a Claude Code session ends?

Ask Claude to write a "State of the Union" handoff: the goal, what's done, what's left, and any gotchas, kept under 200 words. Save it outside the session and paste it in to start the next one, recreating context at a fraction of the token cost.

Does the CLAUDE.md file really change how Claude behaves?

Yes. It's read at the start of every session and its rules apply automatically, which is why conflicting or bloated instructions are a top cause of context problems for experienced users. Keep it short and non-contradictory.

Most of these fixes are five-minute habits, and once they're second nature your sessions stop dying mid-task. If you want the copy-paste CLAUDE.md templates, the handoff prompts, and live workshops where builders trade what's actually working, join the free Claude Community — 7,800+ builders solving exactly this.