name: claude-optimization description: | Maximizing Claude Code capabilities and efficiency. Use when helping users discover features, optimize workflows, or improve their Claude Code experience.

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: