Reducing Context Without Losing Capability

Learning Objectives

• Reduce startup and per-turn cost with levers, not with deletions
• Move a fact to a home that loads it back when it is needed
• Pair every cut with a capability test that would fail if the fact were simply gone
• Explain the difference between reducing context and losing capability
• Pick the cheapest lever that preserves the capability

The Problem

You read that a full window causes forgetting. So you delete half of CLAUDE.md.

The window drops. It feels great for a week. Then Claude stops following a rule you deleted — a rule you had forgotten existed, because the file no longer reminds you. A release goes out without the check, and you find out from the incident.

That is not reduction. That is amnesia with better numbers. The size went down and so did the capability, and you cannot tell the difference until something breaks.

The Concept

Reduction is relocation, not deletion. Every fact you remove gets a place to load from when it is actually needed. The window stays small because the fact is not standing there; the capability stays because the fact is still reachable.

The levers, roughly cheapest and safest first:

graph TD
    A[Start: full window] --> B[Delete what the code already says]
    B --> C[Move procedures to skills]
    C --> D[Move directory facts to path-scoped rules]
    D --> E[Move long reference to references/]
    E --> F[Move research reads to a subagent]
    F --> G[Trim memory files, scope rules]
    G --> H[Clear between tasks, compact at breaks]
    H --> I[Smaller window, same capability]

The capability test

A cut is safe when you can name a task that fails if the fact is deleted and passes if the fact is relocated. Without that task, you are guessing.

The reframe: the goal is not a smaller context but the same capability at a

lower standing cost — so every cut must come with a place to load the thing

back, and a task that proves it still works.

Verified against the skills page, memory page, and context window page on 2026-10-15. Which levers exist and their exact budgets are version-gated; the principle — relocate, then prove — is not.

Build It

Use the project from Lesson 88, or any project where /context starts above half the window.

1. Baseline. Run /context in a fresh session and record the startup total and the total after one representative task.

1. Apply two levers, no more:
   • a procedure out of memory into a skill, and
   • one long file read delegated to a subagent.

Do not delete anything yet.

✅ You pass when you can name the two levers and the fact each one moved.

1. Re-/clear, run /context again, and run the same representative task. Record both totals.

✅ You pass when the startup total is lower and the task still completes.

1. Write the capability test. Name a task that requires the moved facts and would fail if they were deleted. Run it in a fresh session.

✅ You pass when the task succeeds using the relocated content, and you have the transcript as evidence — not just "it looked fine".

1. Only now consider deleting the derivable lines. For each, state where Claude would get the fact instead.

✅ You pass when every deletion has a stated re-derivation path and a task that still passes without it.

Use It

Exercises

1. Cut and prove. Pick one fact at startup. Move it to a home that loads it back. Write the capability test and run it. ✅ You pass when the window is smaller, the test task passes, and the evidence shows the fact was loaded on demand rather than deleted.

1. Distinguish reduction from deletion. Take a fact and produce two versions of the setup: one where it is deleted, one where it is relocated. Run the capability test against both. ✅ You pass when the deleted version fails the test and the relocated version passes — this is the whole lesson in one experiment.

1. Find the cheapest lever. For a bloated section of memory, list every lever that could handle it and pick the one that loads it back latest (cheapest standing cost) without breaking the capability test. ✅ You pass when you can name a cheaper lever you rejected and why it was cheaper but wrong.

Key Terms

What this lesson skipped

The cache cost of your cuts. Moving content changes the prefix and may invalidate the cache. Re-read Lesson 89 before a large reshuffle.

Automating the audit. /doctor and /doctor prompt-audit can flag unused extensions and redundant instructions. Worth revisiting once your manual pass feels repetitive.

Harness-level budgeting. Deciding the cost envelope for an entire harness — rather than one project — is Phase 14.

The graded version. This is the lesson. The module practice/13-cut-context-in-half is where you do it to a real repo and submit the before/after and the proof.