# In your prompts, use trigger words for deeper reasoning:
"think"         # ~4,000 token thinking budget
"think hard"    # ~10,000 tokens
"think harder"  # ~31,999 tokens (maximum)
"ultrathink"    # Maximum reasoning budget

# View Claude's internal reasoning
Ctrl+O          # Toggle verbose mode (gray italic text)

/clear          # Reset context between distinct tasks
Ctrl+O          # Toggle thinking visibility
/help           # Get Claude Code help

❌ BAD - Direct jump to implementation:
"Add user authentication"

✅ GOOD - Metacognitive approach:
"I need to add user authentication. First, research our existing auth patterns
and explore how other features handle authentication. Then think hard about
the best approach before proposing an implementation plan."

# Trigger extended thinking
"Think harder about the trade-offs between these database indexing strategies"

# Request explicit reasoning
"Explain your reasoning step-by-step before implementing the RLS policy"

# Encourage exploration
"Research how our codebase handles file uploads, then plan the best approach"

# Plan before implementation
"Let's enter plan mode - I want to review your approach before coding"

# Clear context between tasks
/clear

# Use skills for just-in-time knowledge
# (No need to load full docs into context)
"Use the database-migration-manager skill to create this migration"

# Delegate to specialized agents
"Use the database-specialist agent to design this schema"

# Load specific context files when needed
"Read the CLAUDE.md file in apps/web/"

# Step 1: Identify task type
├─ Research/Exploration → Use explore agent, don't code yet
├─ Implementation → Enter plan mode first
├─ Bug Fix → Use Sentry agent or step-by-step debugging
└─ Database Work → Use database-specialist agent

# Step 2: Break down complexity
├─ Simple (1-2 files) → Direct prompt
├─ Medium (3-5 files) → Use TodoWrite to track steps
└─ Complex (5+ files, architecture) → Plan mode required

# Step 3: Choose collaboration strategy
├─ Need thinking visibility → Ctrl+O (verbose mode)
├─ Need deeper reasoning → Add "think harder"
└─ Need user input on approach → AskUserQuestion or plan mode

User: "Optimize the event listing page performance"

Metacognitive Approach:
1. REFLECT: This is complex - involves DB queries, React rendering, caching
2. PLAN: Use explore agent first, then db-performance-agent
3. PROMPT: "First, explore how the event listing page works. Then use the
   db-performance-agent to scan for N+1 queries and performance issues.
   Think hard about optimization strategies before proposing changes."
4. MONITOR: Enable Ctrl+O to see reasoning about trade-offs
5. EVALUATE: Review proposed optimizations, ask about edge cases
6. ITERATE: Implement approved changes, measure improvements

# Request step-by-step thinking
"Before implementing, explain:
1. What approaches you considered
2. Why you chose this approach
3. What edge cases exist
4. What could go wrong"

# Ask for trade-off analysis
"Compare the pros/cons of using Redis vs in-memory cache for this feature"

# Require justification
"Why is this the best pattern for our codebase?"

# Seek alternatives
"What are 3 different ways to solve this? Which do you recommend and why?"

"I see you're considering approach A, but what about approach B?"
"You mentioned edge case X - how would the solution handle that?"
"I notice you didn't check if that file exists - let's verify first"

# Instead of: "Add feature X"
# Use metacognitive approach:

"I need to add feature X. First:
1. Explore how similar features are implemented in our codebase
2. Research best practices for this pattern
3. Think hard about edge cases and security implications
4. Enter plan mode so I can review your approach before coding"

# Instead of: "Fix this bug"
# Use systematic approach:

"I'm seeing error Y. Before fixing:
1. Use the explore agent to understand the relevant code paths
2. Explain what you think is causing the error
3. Think through potential solutions and their trade-offs
4. Propose the safest fix with minimal side effects"

# For complex architectural choices:

"We need to decide between approach A and B. Please:
1. Research how our codebase handles similar patterns
2. Think harder about the long-term implications of each approach
3. Consider: maintainability, performance, security, scalability
4. Present pros/cons with your recommendation and reasoning"

# Manage context deliberately:

# Start of session
"Let's work on the authentication system. First, explore the current
implementation so we have shared context."

# Between tasks
"/clear"  # Clean slate for next task

# Before complex work
"Let me give you context on our auth requirements..."
# (Provide specific, relevant context)

# Load knowledge just-in-time
"Use the flutter-development skill for this mobile feature"

# Build understanding incrementally:

# Level 1: Broad overview
"What's the overall architecture of the event system?"

# Level 2: Specific component
"How does event creation work specifically?"

# Level 3: Deep dive
"Read the event creation service and explain the validation logic"

# Level 4: Implementation
"Now that we understand the patterns, let's add feature X following
the same approach"

✅ "Optimize the database queries in this service"
   (High-level, Claude determines approach)

❌ "First find all queries, then wrap each in transaction,
   then add error handling, then..."
   (Too prescriptive, limits Claude's reasoning)

# Simple task (no trigger needed)
"Add a console.log statement here"

# Medium complexity
"Think about the best way to structure this form validation"

# Complex problem
"Think hard about how to optimize this N+1 query while maintaining RLS"

# Critical decision
"Think harder about the security implications of this authentication flow"

# Ask yourself: "What domain expertise is needed?"
├─ Database → database-specialist
├─ Performance → db-performance-agent
├─ Quality → quality-reviewer
├─ Errors → sentry-fixer-agent
├─ Exploration → Explore agent
└─ General → Claude handles natively

# Then prompt accordingly:
"Use the database-specialist agent to design this schema with proper RLS"

# ❌ Don't do this:
"Read all the Flutter documentation files and then help me build a form"
(Loads thousands of tokens)

# ✅ Do this:
"Use the flutter-forms skill to build a multi-step form with validation"
(Loads only relevant skill content)

"Fix it"
"Make it work"
"Do the thing"

"The user authentication is failing with error X. First, explore the auth
code to understand the flow, then think about what could cause this error,
and propose a fix with explanation."

User: "Add feature X"
Claude: [Generates code]
User: "Great, ship it!"

User: "Add feature X"
Claude: [Generates code]
User: "Explain what this code does and why you chose this approach"
Claude: [Explains reasoning]
User: "What about edge case Y?"
Claude: [Addresses concern]
User: "Good, let's implement it"

# Loading everything "just in case"
"Read all files in /app"
"Load all skills"
"Show me everything about feature X"

# Just-in-time loading
"Explore the auth feature to find relevant files"
"Use the database-migration-manager skill for this migration"
"Read the specific file I need: apps/web/lib/auth.ts"

"Build the entire user management system"

"Let's build the user management system. First, enter plan mode so we can
break this into phases. I want to review the architecture before we start."

Claude: "I think this might work, but I'm not certain about..."
User: "Just do it"

Claude: "I think this might work, but I'm not certain about..."
User: "Let's investigate that uncertainty. Research our codebase to see
how we handle similar cases."