Example: Completed Phase 1 (design), starting Phase 2 (implementation)

Example: Backend work complete, handing off to Frontend Developer

Example: Major refactoring complete, starting new feature

Estimate: ~20-30 file reads + significant back-and-forth

Example: About to analyze large codebase or generate comprehensive report

💡 **Context Management Suggestion**

We've completed [phase/task] and are about to start [new phase/task].
Consider running `/compact` to optimize context before proceeding:

\`\`\`
/compact preserve the established coding patterns, architectural
decisions, and key requirements from the PRD
\`\`\`

This will:
- Free up context space for upcoming work
- Preserve important decisions and patterns
- Improve response speed and quality

Example: "Implement authentication service" is self-contained

Example: Switch from backend to frontend work

Example: "Search codebase for all API endpoints"

Example: "Run test suite and analyze failures"

Example: "Generate comprehensive API documentation"

Instead of implementing in current context:

Use Task tool:
  subagent_type: backend-developer
  prompt: "Implement user authentication service according to
          docs/product/prds/auth-prd.md. Create all necessary files,
          write tests, and provide implementation summary."

The subagent will:
- Start with fresh context
- Focus only on auth service
- Return implementation summary
- Parent context stays clean

For codebase exploration:

Use Task tool:
  subagent_type: Explore
  prompt: "Find all API endpoints in the codebase and document
          their authentication requirements. Provide comprehensive
          list with file locations."

The subagent will:
- Search codebase independently
- Build understanding in its own context
- Return findings summary
- Parent avoids context bloat

When handing off between agents:

Use Task tool instead of direct handoff:
  subagent_type: frontend-developer
  prompt: "Implement the UI components based on the design specs
          at docs/design/ui/dashboard-spec.md and the API contracts
          at docs/architecture/api-contracts/dashboard.yaml"

Benefits:
- Frontend agent starts fresh
- Parent doesn't accumulate frontend context
- Clean separation of concerns

## Context Management

### When to Recommend Compacting

If this conversation exceeds 100K tokens (~20+ file reads) and:
- Transitioning to new major phase
- About to hand off to another agent
- Starting complex analysis or large implementation

**Recommend to user**:
💡 "Consider running `/compact preserve [key decisions and patterns]`
    before proceeding to optimize context."

### When to Use Subagents

For isolated work that could run independently:
- Use Task tool with appropriate subagent_type
- Keeps parent context clean
- Subagent returns focused summary

**Example**:
\`\`\`
Task tool:
  subagent_type: [appropriate-agent]
  prompt: "Clear, specific task description with all context needed"
\`\`\`

## Context Management

### Strategic Compacting Points

Consider recommending `/compact` when:
1. [Specific trigger point for this agent]
2. [Another trigger point]
3. [Third trigger point]

**Example recommendation**:
💡 "We've completed [X]. Consider `/compact preserve [Y]` before [Z]."

### Subagent Isolation

Use Task tool instead of continuing when:
1. [Scenario where subagent makes sense]
2. [Another scenario]

**Example**:
\`\`\`
Task tool:
  subagent_type: [agent-type]
  prompt: "[Clear task description]"
\`\`\`

**Agent**: "Phase 1 (Database Schema) is complete with 8 migrations created.

💡 **Context Management Suggestion**

Before starting Phase 2 (API Implementation), consider running:
\`\`\`
/compact preserve the database schema design, table relationships,
and the RLS policies we established
\`\`\`

This will optimize context for the upcoming API work."

**Agent**: "I need to analyze the entire codebase for security vulnerabilities.

Rather than accumulating all analysis in this context, I'll use a
dedicated subagent:

[Spawns app-security-engineer subagent with secure-push skill]

The subagent will return a focused security report without bloating
our current conversation."

**Agent**: "Backend API implementation is complete.

💡 **Context Management Options**

Option A (Continue): I can hand off to frontend-developer in this context
Option B (Fresh Start): Spawn frontend-developer subagent with clean context

Recommend **Option B** because:
- Frontend work is self-contained
- Keeps our context focused on backend
- Frontend agent gets targeted context only

Would you like me to spawn the frontend-developer subagent?"