gh-josiahsiegel-claude-code-marketplace-plugins-context-master/skills/context-master/references/context_strategies.md

Context Management Strategies

Detailed workflows and strategies for managing context efficiently in Claude Code.

Understanding Context Usage

Context window size:

• Standard: 200K tokens (~150K words)
• Extended (API): 1M tokens (~750K words)

What consumes context:

• Conversation history (messages back and forth)
• File contents loaded into context
• Tool call results (bash output, test results, etc.)
• CLAUDE.md configuration
• Extended thinking blocks

Context awareness: Claude Sonnet 4.5 tracks remaining context and reports it with each tool call.

Core Commands

/clear - Reset Context

When to use:

• Between major features or tasks
• After completing a self-contained piece of work
• When switching between different parts of the codebase
• If you notice Claude getting distracted or referencing old context

Example workflow:

1. Complete feature A
2. Run tests and commit
3. /clear
4. Start feature B with fresh context

/compact - Compress Context

When to use:

• Before starting complex multi-step work
• When approaching context limits (~80% full)
• To preserve key decisions while clearing clutter

What it does: Summarizes conversation history while retaining key information.

Example workflow:

1. Long research and planning session
2. /compact "Summarize architecture decisions and open TODOs"
3. Continue with implementation

/continue - Resume Session

When to use:

• Returning to previous work
• After a break
• To pick up where you left off

Combines well with:

claude --continue  # Resume last session in current project

Strategy 1: Task Isolation

Goal: Keep each task in its own context bubble.

Workflow:

1. Start task → /clear (if needed)
2. Use subagents for research/analysis
3. Main context focuses on implementation
4. Complete and test
5. /clear before next task

When to use:

• Multiple independent features
• Bug fixes that don't require historical context
• Refactoring isolated modules

Benefits:

• Each task starts with clean slate
• No cross-contamination between tasks
• More predictable context usage

---

Strategy 2: Progressive Context Management

Goal: Build up context deliberately, clearing non-essential information.

Workflow:

1. Research phase
   - Subagents search and analyze
   - Main context reviews summaries
   
2. Planning phase
   - "think hard" to create plan
   - Save plan to document/issue
   
3. /compact "Keep architecture decisions and plan"
   
4. Implementation phase
   - Reference plan document
   - Focus on current file/module
   
5. Testing phase
   - Subagent runs tests
   - Main context addresses failures
   
6. /clear before next feature

When to use:

• Large features requiring multiple steps
• Complex refactoring
• Projects with extensive research phase

Benefits:

• Intentional context building
• Clear phase transitions
• Preserved key decisions

---

🚨 CRITICAL GUIDELINES

Windows File Path Requirements

MANDATORY: Always Use Backslashes on Windows for File Paths

When using Edit or Write tools on Windows, you MUST use backslashes (\) in file paths, NOT forward slashes (/).

Examples:

• ❌ WRONG: D:/repos/project/file.tsx
• ✅ CORRECT: D:\repos\project\file.tsx

This applies to:

• Edit tool file_path parameter
• Write tool file_path parameter
• All file operations on Windows systems

Documentation Guidelines

NEVER create new documentation files unless explicitly requested by the user.

• Priority: Update existing README.md files rather than creating new documentation
• Repository cleanliness: Keep repository root clean - only README.md unless user requests otherwise
• Style: Documentation should be concise, direct, and professional - avoid AI-generated tone
• User preference: Only create additional .md files when user specifically asks for documentation

---

Strategy 3: Parallel Workstreams

Goal: Work on multiple aspects simultaneously using subagents.

Workflow:

1. Main context: High-level orchestration
2. Subagent A: Frontend work
3. Subagent B: Backend work  
4. Subagent C: Test execution
5. Main context: Integration and coordination

When to use:

• Full-stack features
• Multi-component changes
• When different aspects are independent

Benefits:

• Efficient use of subagent isolation
• Parallel progress
• Main context stays focused on coordination

---

Strategy 4: Test-Driven Context Management

Goal: Keep context focused on current test/implementation cycle.

Workflow:

1. Write test in main context
2. /agent test-runner "run new test"
3. Implement feature to pass test
4. /agent test-runner "run test suite"
5. If fail → fix in main context
6. If pass → commit and /clear

When to use:

• TDD workflows
• Bug fixes with test coverage
• API endpoint development

Benefits:

• Tight feedback loop
• Context stays focused on current test
• Test output doesn't clutter main context

---

Strategy 5: Documentation-First Development

Goal: Use CLAUDE.md as persistent memory across sessions.

Setup:

# CLAUDE.md

## Current Focus
Sprint goal: User authentication system

## Recent Decisions
- Using JWT with refresh tokens
- PostgreSQL for user storage
- Redis for session management

## Next Tasks
- [ ] Implement token refresh endpoint
- [ ] Add rate limiting
- [ ] Write integration tests

## Architecture Notes
[Key decisions that inform all work]

Workflow:

1. CLAUDE.md provides persistent context
2. Each session references current focus
3. Update CLAUDE.md with new decisions
4. /clear frequently - CLAUDE.md persists

When to use:

• Multi-day projects
• Team collaboration (CLAUDE.md in git)
• Complex projects needing persistent memory

Benefits:

• Survives /clear commands
• Shared team knowledge
• Consistent across sessions

---

Scenario-Based Strategies

Scenario: Large Refactoring

Challenge: Need broad codebase understanding but context fills quickly.

Strategy:

1. Subagent: "Map all files using old pattern"
2. Review map, create refactoring plan
3. Save plan to REFACTOR.md
4. /clear
5. For each file:
   a. Load file
   b. Refactor based on plan
   c. Test
   d. /clear before next file

---

Scenario: Bug Investigation

Challenge: Unknown cause, need to search widely but track findings.

Strategy:

1. Create BUG_NOTES.md to track findings
2. Subagent: "Search logs for error X"
3. Document findings in BUG_NOTES.md
4. Subagent: "Analyze code paths that could cause X"
5. Document in BUG_NOTES.md
6. /compact "Keep bug theory and evidence"
7. Implement fix
8. /agent test-runner "verify fix"

---

Scenario: New Feature with Unknown Patterns

Challenge: Need to research existing patterns without cluttering context.

Strategy:

1. Subagent: "Find similar features in codebase"
2. Subagent: "Extract common patterns from those features"
3. Main context reviews patterns
4. "think about best approach for new feature"
5. Create implementation plan
6. /clear
7. Implement based on plan
8. Reference plan doc if needed

---

Scenario: Multi-File Feature

Challenge: Changes span many files, hard to keep all in context.

Strategy:

1. Create FEATURE.md with:
   - Overall design
   - File change checklist
   - Cross-file dependencies
   
2. For each file:
   a. Load just that file
   b. Reference FEATURE.md for context
   c. Make changes
   d. Test
   e. /compact if context getting full
   
3. Final integration test
4. /clear and move to next feature

---

Advanced Techniques

Technique: Context Checkpoints

Save key state to files before clearing:

1. Long planning session
2. "Create PLAN.md with our architecture decisions"
3. /clear
4. Reference PLAN.md during implementation

Technique: Layered Context Loading

Load information progressively as needed:

1. Start with just current file
2. If need more context: "show me the caller"
3. If need more: "show me the config"
4. Don't load everything upfront

Technique: Subagent Summarization

Use subagents to create digestible summaries:

Subagent: "Analyze all 50 test files and create a summary:
- Total coverage percentage
- Files with <50% coverage
- Most complex tests"

Then work from the summary, not the raw test files.

Technique: Incremental /compact

Compress context multiple times in long sessions:

1. Research phase → /compact "Keep research findings"
2. Planning phase → /compact "Keep findings and plan"
3. Implementation → /compact "Keep plan and decisions"

Monitoring Context Health

Signs context is getting cluttered:

• Claude references old, irrelevant information
• Responses become less focused
• Performance seems to degrade
• You're >80% through context budget

Remedies:

1. /compact for quick compression
2. /clear for fresh start
3. Move key info to files before clearing
4. Use subagents more aggressively

Best Practices Summary

1. Use /clear liberally between tasks
2. Front-load subagent usage for research
3. Document decisions in CLAUDE.md or files
4. Load files progressively as needed
5. Test in subagents to keep output isolated
6. /compact before complex multi-step work
7. Think first to plan before implementing
8. Reference plans instead of keeping full context
9. Batch similar operations in single subagent
10. Monitor context usage and respond proactively