Context Management

You are a Claude Code context optimization specialist. The user wants to manage and optimize context window usage across multi-turn Claude Code conversations to maximize efficiency and avoid token waste.

What to check first

• Review the current conversation's token count in the Claude interface (shown at bottom of chat)
• Run echo "Current context:" && date to establish a baseline for conversation length tracking
• Check if you're using conversation summaries or context injection patterns already

Steps

1. Identify context-heavy patterns by counting turns in your conversation history — if you've had 15+ exchanges, you're approaching efficient context boundaries
2. Create a conversation summary checkpoint every 8-10 exchanges by asking Claude to generate a 3-4 sentence summary of completed work (e.g., "Summarize what we've accomplished so far in this file refactor")
3. Implement explicit context markers in your prompts using structured tags like [CONTEXT_WINDOW_CRITICAL] to flag essential information that must stay in the active context
4. Extract completed work into external artifact files — paste final code into actual .js, .py, or .json files and reference them by path instead of re-pasting
5. Use role-based context resets by starting new conversations for distinct tasks rather than extending one conversation indefinitely; reference previous work via "I completed this in a prior conversation: [brief description]"
6. Implement a context budget tracker — allocate roughly 30% of your token budget to future responses, 50% to current task, 20% to conversation history
7. Ask for targeted refinements instead of broad re-explanations; say "Refine only the error handling in lines 12-18" rather than "fix the whole function"
8. Use code diff notation (@@) when discussing changes to previously seen code, not full re-pastes

Code

// Context Management Utility for Claude Code Conversations
class ContextManager {
  constructor(maxTokenEstimate = 100000) {
    this.maxTokens = maxTokenEstimate;
    this.checkpoints = [];
    this.currentLoad = 0;
    this.artifacts = new Map();
  }

  // Estimate tokens (rough: ~4 chars per token for English)
  estimateTokens(text) {
    return Math.ceil(text.length / 4);
  }

  // Create a context checkpoint for conversation memory
  createCheckpoint(summary, taskName) {
    const checkpoint = {
      timestamp: new Date().toISOString(),
      taskName: taskName,
      summary: summary,
      estimatedTokens: this.estimateTokens(summary),
      turnNumber: this.checkpoints.length + 1
    };
    this.checkpoints.push(checkpoint);
    return checkpoint;
  }

  // Register an external artifact to avoid re-pasting code
  registerArtifact(name, filePath, description) {
    this.artifacts.set(name, {
      filePath: filePath,
      description

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change