CLI Reference

# Start interactive session
claude
 
# Start with initial prompt
claude "explain the authentication flow"

# Single query, then exit
claude -p "what does this function do?"
 
# Process file content
cat error.log | claude -p "explain this error"
 
# Chain with other tools
claude -p "list todos" | grep "URGENT"

# Use Opus 4.6 for complex tasks
claude --model opus "design a caching strategy"
 
# Use Haiku 4.5 for quick tasks
claude --model haiku -p "format this JSON"
 
# Full model name
claude --model claude-sonnet-4-6-20250929 "review this code"
 
# With fallback for reliability
claude -p --model opus --fallback-model sonnet "analyze architecture"
 
# Use opusplan (Opus plans, Sonnet executes)
claude --model opusplan "design and implement the caching layer"

# Complete custom persona
claude --system-prompt "You are a senior security engineer. Focus on vulnerabilities."
 
# Append specific instructions
claude --append-system-prompt "Always include unit tests with code examples"
 
# Load complex prompt from file
claude -p --system-prompt-file ./prompts/code-reviewer.txt "review main.py"

# Read-only mode for code review
claude --permission-mode plan "review this codebase"
 
# Restrict to safe tools only
claude --tools "Read,Grep,Glob" -p "find all TODO comments"
 
# Allow specific git commands without prompts
claude --allowedTools "Bash(git status:*)" "Bash(git log:*)"
 
# Block dangerous operations
claude --disallowedTools "Bash(rm -rf:*)" "Bash(git push --force:*)"

# Plain text (default)
claude -p "explain this code"
 
# JSON for programmatic use
claude -p --output-format json "list all functions in main.py"
 
# Streaming JSON for real-time processing
claude -p --output-format stream-json "generate a long report"
 
# Structured output with schema validation
claude -p --json-schema '{"type":"object","properties":{"bugs":{"type":"array"}}}' \
  "find bugs in this code and return as JSON"

# Work across multiple project directories
claude --add-dir ../frontend ../backend ../shared "find all API endpoints"
 
# Load custom settings
claude --settings '{"model":"opus","verbose":true}' "complex task"

# Load GitHub MCP server
claude --mcp-config ./github-mcp.json "list open PRs"
 
# Strict mode - only specified servers
claude --strict-mcp-config --mcp-config ./production-mcp.json "deploy to staging"

# Continue last conversation
claude -c
 
# Resume named session
claude -r "feature-auth" "continue implementing login"
 
# Fork session for experimentation
claude --resume feature-auth --fork-session "try alternative approach"
 
# Use specific session ID
claude --session-id "550e8400-e29b-41d4-a716-446655440000" "continue"

# Fork a session to try a different approach
claude --resume abc123 --fork-session "try alternative implementation"
 
# Fork with a custom message
claude -r "feature-auth" --fork-session "test with different architecture"

# Limit autonomous actions
claude -p --max-turns 5 "refactor this module"
 
# Debug API calls
claude --debug "api" "test query"
 
# Enable IDE integration
claude --ide "help me with this file"

{
  "agent-name": {
    "description": "Required: when to invoke this agent",
    "prompt": "Required: system prompt for the agent",
    "tools": ["Optional", "array", "of", "tools"],
    "model": "optional: sonnet|opus|haiku"
  }
}

{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  },
  "debugger": {
    "description": "Debugging specialist for errors and test failures.",
    "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes.",
    "tools": ["Read", "Edit", "Bash", "Grep"],
    "model": "opus"
  },
  "documenter": {
    "description": "Documentation specialist for generating guides.",
    "prompt": "You are a technical writer. Create clear, comprehensive documentation.",
    "tools": ["Read", "Write"],
    "model": "haiku"
  }
}

# Define custom agents inline
claude --agents '{
  "security-auditor": {
    "description": "Security specialist for vulnerability analysis",
    "prompt": "You are a security expert. Find vulnerabilities and suggest fixes.",
    "tools": ["Read", "Grep", "Glob"],
    "model": "opus"
  }
}' "audit this codebase for security issues"
 
# Load agents from file
claude --agents "$(cat ~/.claude/agents.json)" "review the auth module"
 
# Combine with other flags
claude -p --agents "$(cat agents.json)" --model sonnet "analyze performance"

name: AI Code Review
 
on: [pull_request]
 
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
 
      - name: Run Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude -p --output-format json \
            --max-turns 1 \
            "Review the changes in this PR for:
            - Security vulnerabilities
            - Performance issues
            - Code quality
            Output as JSON with 'issues' array" > review.json
 
      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = JSON.parse(fs.readFileSync('review.json', 'utf8'));
            // Process and post review comments

pipeline {
    agent any
    stages {
        stage('AI Review') {
            steps {
                sh '''
                    claude -p --output-format json \
                      --max-turns 3 \
                      "Analyze test coverage and suggest missing tests" \
                      > coverage-analysis.json
                '''
            }
        }
    }
}

# Analyze error logs
tail -1000 /var/log/app/error.log | claude -p "summarize these errors and suggest fixes"
 
# Find patterns in access logs
cat access.log | claude -p "identify suspicious access patterns"
 
# Analyze git history
git log --oneline -50 | claude -p "summarize recent development activity"

# Review a specific file
cat src/auth.ts | claude -p "review this authentication code for security issues"
 
# Generate documentation
cat src/api/*.ts | claude -p "generate API documentation in markdown"
 
# Find TODOs and prioritize
grep -r "TODO" src/ | claude -p "prioritize these TODOs by importance"

# Start a feature branch session
claude -r "feature-auth" "let's implement user authentication"
 
# Later, continue the session
claude -r "feature-auth" "add password reset functionality"
 
# Fork to try an alternative approach
claude --resume feature-auth --fork-session "try OAuth instead"
 
# Switch between different feature sessions
claude -r "feature-payments" "continue with Stripe integration"

# Save agents config to file
cat > ~/.claude/agents.json << 'EOF'
{
  "reviewer": {
    "description": "Code reviewer for PR reviews",
    "prompt": "Review code for quality, security, and maintainability.",
    "model": "opus"
  },
  "documenter": {
    "description": "Documentation specialist",
    "prompt": "Generate clear, comprehensive documentation.",
    "model": "sonnet"
  },
  "refactorer": {
    "description": "Code refactoring expert",
    "prompt": "Suggest and implement clean code refactoring.",
    "tools": ["Read", "Edit", "Glob"]
  }
}
EOF
 
# Use agents in session
claude --agents "$(cat ~/.claude/agents.json)" "review the auth module"

# Process multiple files
for file in src/*.ts; do
  echo "Processing $file..."
  claude -p --model haiku "summarize this file: $(cat $file)" >> summaries.md
done
 
# Batch code review
find src -name "*.py" -exec sh -c '
  echo "## $1" >> review.md
  cat "$1" | claude -p "brief code review" >> review.md
' _ {} \;
 
# Generate tests for all modules
for module in $(ls src/modules/); do
  claude -p "generate unit tests for src/modules/$module" > "tests/$module.test.ts"
done

# Read-only security audit
claude --permission-mode plan \
  --tools "Read,Grep,Glob" \
  "audit this codebase for security vulnerabilities"
 
# Block dangerous commands
claude --disallowedTools "Bash(rm:*)" "Bash(curl:*)" "Bash(wget:*)" \
  "help me clean up this project"
 
# Restricted automation
claude -p --max-turns 2 \
  --allowedTools "Read" "Glob" \
  "find all hardcoded credentials"

# Get structured analysis
claude -p --output-format json \
  --json-schema '{"type":"object","properties":{"functions":{"type":"array"},"complexity":{"type":"string"}}}' \
  "analyze main.py and return function list with complexity rating"
 
# Integrate with jq for processing
claude -p --output-format json "list all API endpoints" | jq '.endpoints[]'
 
# Use in scripts
RESULT=$(claude -p --output-format json "is this code secure? answer with {secure: boolean, issues: []}" < code.py)
if echo "$RESULT" | jq -e '.secure == false' > /dev/null; then
  echo "Security issues found!"
  echo "$RESULT" | jq '.issues[]'
fi

# Extract specific fields
claude -p --output-format json "analyze this code" | jq '.result'
 
# Filter array elements
claude -p --output-format json "list issues" | jq -r '.issues[] | select(.severity=="high")'
 
# Extract multiple fields
claude -p --output-format json "describe the project" | jq -r '.{name, version, description}'
 
# Convert to CSV
claude -p --output-format json "list functions" | jq -r '.functions[] | [.name, .lineCount] | @csv'
 
# Conditional processing
claude -p --output-format json "check security" | jq 'if .vulnerabilities | length > 0 then "UNSAFE" else "SAFE" end'
 
# Extract nested values
claude -p --output-format json "analyze performance" | jq '.metrics.cpu.usage'
 
# Process entire array
claude -p --output-format json "find todos" | jq '.todos | length'
 
# Transform output
claude -p --output-format json "list improvements" | jq 'map({title: .title, priority: .priority})'

# Use short names
claude --model opus "complex architectural review"
claude --model sonnet "implement this feature"
claude --model haiku -p "format this JSON"
 
# Use opusplan alias (Opus plans, Sonnet executes)
claude --model opusplan "design and implement the API"
 
# Toggle fast mode during session
/fast

# Set effort level via CLI flag
claude --effort high "complex review"
 
# Set effort level via slash command
/effort high
 
# Set effort level via environment variable
export CLAUDE_CODE_EFFORT_LEVEL=high   # low, medium, high, or max (Opus 4.6 only)

# Interactive session
claude
 
# Quick question
claude -p "how do I..."
 
# Continue conversation
claude -c
 
# Process a file
cat file.py | claude -p "review this"
 
# JSON output for scripts
claude -p --output-format json "query"