Claude Code Optimization Guide

Feature Discovery Checklist

When working with users, watch for opportunities to suggest:

Underutilized Power Features

Quick Wins to Suggest

1. •Parallel Tool Calls: "I can run these searches simultaneously"
2. •Agent Delegation: "Let me spawn a specialized agent for this"
3. •Memory Search: "Let me check if we've solved this before"
4. •Background Tasks: "I'll run this in background while we continue"

Efficiency Patterns

Pattern 1: Parallel Exploration

Instead of:
  Search for X → Wait → Search for Y → Wait → Search for Z

Do:
  Search for X, Y, Z simultaneously → Continue when all complete

When to use: Independent searches, file reads, or exploratory tasks

Pattern 2: Agent Specialization

Instead of:
  One conversation doing: research + code + review + test

Do:
  Explore agent → does research
  Main context → writes code
  Code-reviewer agent → reviews changes
  Test agent → writes/runs tests

When to use: Complex tasks with distinct phases

Pattern 3: Progressive Disclosure

Instead of:
  Dump all context upfront

Do:
  Provide essential context first
  Load detailed references when needed
  Use skills for domain knowledge

When to use: Large codebases, complex domains

Pattern 4: Background Processing

Instead of:
  Run slow task → Wait → Continue

Do:
  Start task in background → Continue other work → Check results later

When to use: Long builds, extensive tests, large exports

Model Selection Strategy

MCP Server Recommendations

High-Value Integrations

When to Suggest MCP

• •User mentions needing data from external service
• •Repeated manual data fetching
• •Integration with team tools
• •Debugging production issues

Hook Automation Opportunities

Pre-Tool Hooks (Before Claude acts)

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [{ "type": "command", "command": "echo 'About to modify: $FILE'" }]
      }
    ]
  }
}

Use cases:

• •Lint before edit
• •Backup before overwrite
• •Validate paths

Post-Tool Hooks (After Claude acts)

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "npx biome check $FILE --write" }]
      }
    ]
  }
}

Use cases:

• •Auto-format after changes
• •Run tests after edits
• •Update checksums

Workflow Optimization Patterns

Pattern: Task Breakdown with Todos

User: "Implement feature X"

Optimized approach:
1. Create todo list with subtasks
2. Mark first task in_progress
3. Complete and mark done
4. Move to next task
5. User has visibility throughout

Pattern: Exploratory Research First

User: "Fix the bug in checkout"

Optimized approach:
1. Use Explore agent to understand codebase
2. Search episodic memory for related issues
3. Gather full context before proposing fix
4. Make minimal, targeted changes

Pattern: Review After Implementation

User: "Add authentication"

Optimized approach:
1. Implement feature
2. Spawn code-reviewer agent
3. Address review feedback
4. Spawn security-auditor if auth-related
5. Final verification

Context Management

Keeping Context Focused

• •Use subagents for isolated tasks
• •Compact context when it grows large
• •Save decisions to CLAUDE.md
• •Use skills for repeated patterns

Cross-Session Continuity

1. •Episodic memory: Search past conversations
2. •CLAUDE.md: Document project-level decisions
3. •Todo lists: Track incomplete work
4. •Git commits: Clear commit messages for context

Performance Tips

Reduce Token Usage

• •Use glob patterns instead of listing files
• •Read specific line ranges, not whole files
• •Use grep before read to find relevant sections
• •Delegate to haiku agents for simple tasks

Increase Speed

• •Parallel tool calls for independent operations
• •Background agents for long tasks
• •Cached results from previous sessions
• •Specialized agents for focused work

Quality Assurance Automation

Suggested Workflow Hooks

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          { "type": "command", "command": "npx biome check $FILE --write" },
          { "type": "command", "command": "npx tsc --noEmit" }
        ]
      }
    ]
  }
}

Suggested Agent Chain

1. •Before coding: Plan agent researches
2. •During coding: Main context implements
3. •After coding: code-reviewer checks quality
4. •Before commit: security-auditor scans
5. •After commit: Tests run automatically

Proactive Suggestions Script

When observing user behavior, suggest: