context-engineering（情境工程）

Context Engineering Skill

This skill provides techniques for managing context effectively throughout the workflow to prevent bloat and maintain efficiency.

Core Principles

1. Stay Under 40%: Orchestrator should never exceed 40% context usage
2. Fresh Context Per Task: Each major task gets a fresh agent with clean context
3. Load Only What's Needed: Don't load full files when summaries suffice
4. Delegate Deep Work: Spawn agents for context-heavy operations

Context Budget Guidelines

Context Loading Strategies

Selective Loading

Instead of loading full files:

BAD: Read entire codebase
GOOD: Read specific files needed for current task
BEST: Read summaries, then specific sections

Hierarchical Loading

Load context in layers:

1. L1 Summary: High-level overview (FLOW.md)
2. L2 Details: Item-specific state (ITEM-XXX.md)
3. L3 Specifics: Task-specific files (only files in current task)

Incremental Loading

Load more context only when needed:

1. Start with minimal context
2. Identify what's missing
3. Load specific missing pieces
4. Repeat as needed

Fresh Context Patterns

When to Use Fresh Context

Spawn a fresh agent when:

• Starting a new task in EXECUTE phase
• Moving to a new phase
• Current context is getting heavy
• Deep codebase exploration needed

Fresh Context Handoff

When spawning fresh agent:

Include in handoff:
- Task ID and definition
- Key decisions from ITEM-XXX.md
- Relevant file paths
- Success criteria

Exclude:
- Full conversation history
- Files not related to task
- Exploration paths not taken

Context Reset Points

Natural points to reset context:

• Phase transitions
• After each completed task
• After resolving a blocker
• After user requests fresh start

Context Monitoring

Signs of Context Bloat

Watch for:

• Repeated information in responses
• Slower response times
• Forgetting earlier context
• Inconsistent references

Context Health Check

Periodically verify:

• Can still reference key decisions?
• Can identify current task?
• Can access state files?
• Response quality maintained?

State File as External Memory

Use state files as external memory:

What to Store in Files

• All decisions (ITEM-XXX.md Decisions section)
• Exploration progress (ITEM-XXX.md Exploration section)
• Task definitions (ITEM-XXX.md Tasks section)
• Requirements (ITEM-XXX.md Requirements section)

What to Keep in Context

• Current phase and task
• Key constraints
• Immediate next steps
• Recent decisions (can reference file for older ones)

Delegation Patterns

Deep Exploration Delegation

Task: Understand how authentication works in this codebase

Instead of:
- Loading all auth-related files into orchestrator context

Do:
- Spawn researcher agent with specific question
- Receive summary findings
- Keep summary in orchestrator context

Implementation Delegation

Task: Implement TASK-005

Instead of:
- Loading full codebase patterns and task into orchestrator

Do:
- Spawn executor with task definition + relevant files only
- Receive completion status
- Update state files

Context Compression Techniques

Summary Generation

After deep work, compress to summary:

Before compression: [Full exploration transcript]

After compression:
**Exploration Result**: Authentication
- Uses JWT tokens
- Stored in localStorage
- Refresh flow in AuthService.refresh()
- Decision needed: token expiry duration

Reference Instead of Inline

BAD: Include full task XML in every message
GOOD: "Executing TASK-005 (see ITEM-XXX.md Tasks section)"

Checkpoint Snapshots

At checkpoints, snapshot key state:

### CHECKPOINT: EXECUTE-001
**Context snapshot**:
- Phase: EXECUTE
- Progress: 5/10 tasks
- Current: TASK-006
- Blocked: None
- Key decisions: Use JWT (DECISION-003)

Integration with Workflow

During DISCUSS

• Keep exploration map in ITEM-XXX.md
• Summarize findings per area
• Reference decisions by ID

During PLAN

• Read requirements once, create tasks
• Don't reload requirements repeatedly
• Reference task IDs not full definitions

During EXECUTE

• Fresh context per task
• Load only task + relevant files
• Update state after each task

During VERIFY

• Load summary of completed work
• Cross-reference requirements by ID
• Keep verification results in ITEM-XXX.md

Best Practices

1. Reference, don't repeat: Use IDs and file paths
2. Summarize immediately: After deep work, compress findings
3. Clean handoffs: Fresh agents get focused context
4. Use state files: They're your external memory
5. Monitor bloat: Watch for degradation signs
6. Delegate proactively: Don't wait until context is full