User Terminal
    ↓ claude [options] [query]
    ↓
Claude Code CLI
    ├── Interactive REPL Mode (default)
    ├── Print Mode (--print, -p)
    └── Session Resume (--resume)
         ↓
       Claude API
         ↓
       Output (text/json/stream-json)
         ↓
    Terminal/Pipe

claude (default)
    ├── Interactive REPL
    │    Features:
    │    - Multi-turn conversation
    │    - Tab completion
    │    - History
    │    - Slash commands
    │
    └── Print Mode (-p)
         Features:
         - Single query
         - Scriptable
         - Pipeable
         - JSON output

# Start interactive session
claude

# Start với 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 với other tools
claude -p "list todos" | grep "URGENT"

# One-off summarize trong bare mode, pre-approve Read tool
claude --bare -p "Summarize this file" --allowedTools "Read"

# Use Opus 4.7 cho complex tasks
claude --model opus "design a caching strategy"

# Use Haiku 4.5 cho quick tasks
claude --model haiku -p "format this JSON"

# Full model name
claude --model claude-sonnet-4-6-20250929 "review this code"

# Với fallback cho 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"

# CLI flag
claude --effort xhigh "complex review"

# Slash command
/effort xhigh

# Environment variable
export CLAUDE_CODE_EFFORT_LEVEL=xhigh

# 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 từ file
claude -p --system-prompt-file ./prompts/code-reviewer.txt "review main.py"

gh pr diff "$1" | claude -p \
  --append-system-prompt "You are a security engineer. Review for vulnerabilities." \
  --output-format json

# Read-only mode cho code review
claude --permission-mode plan "review this codebase"

# Restrict tới safe tools only
claude --tools "Read,Grep,Glob" -p "find all TODO comments"

# Allow specific git commands không 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 cho programmatic use
claude -p --output-format json "list all functions in main.py"

# Streaming JSON cho real-time processing
claude -p --output-format stream-json "generate a long report"

# Structured output với schema validation
claude -p --json-schema '{"type":"object","properties":{"bugs":{"type":"array"}}}' \
  "find bugs in this code and return as JSON"

# Filter text deltas, display streaming text
claude -p "Write a poem" --output-format stream-json --verbose --include-partial-messages | \
  jq -rj 'select(.type == "stream_event" and .event.delta.type? == "text_delta") | .event.delta.text'

# 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"

{
  "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"
  }
}

# Define 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 từ file
claude --agents "$(cat ~/.claude/agents.json)" "review the auth module"

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

# crontab -e
# Run every weekday at 2pm — analyze logs
0 14 * * 1-5 cd /var/log/app && \
  tail -1000 error.log | claude -p \
    --dangerously-skip-permissions \
    "Analyze errors, identify patterns, alert if critical" | \
    mail -s "Daily Log Report" devops@example.com

# Analyze error logs
tail -1000 /var/log/app/error.log | claude -p "summarize these errors and suggest fixes"

# Find patterns trong access logs
cat access.log | claude -p "identify suspicious access patterns"

# Review 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, prioritize
grep -r "TODO" src/ | claude -p "prioritize these TODOs by importance"

# Start feature branch session
claude -r "feature-auth" "let's implement user authentication"

# Later, continue
claude -r "feature-auth" "add password reset functionality"

# Fork để thử alternative
claude --resume feature-auth --fork-session "try OAuth instead"

# Switch giữa feature sessions
claude -r "feature-payments" "continue with Stripe integration"

# Process multiple files
for file in src/*.ts; do
  echo "Processing $file..."
  claude -p --model haiku "summarize this file: $(cat $file)" >> summaries.md
done

# Generate tests cho all modules
for module in $(ls src/modules/); do
  claude -p "generate unit tests for src/modules/$module" > "tests/$module.test.ts"
done

# Get structured analysis
claude -p --output-format json \
  --json-schema '{"type":"object","properties":{"functions":{"type":"array"}}}' \
  "analyze main.py and return function list"

# Integrate với jq cho processing
claude -p --output-format json "list all API endpoints" | jq '.endpoints[]'

# Use trong 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")'

# Convert tới 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'

# Short names
claude --model opus "complex architectural review"
claude --model sonnet "implement this feature"
claude --model haiku -p "format this JSON"

# opusplan alias (Opus plans, Sonnet executes)
claude --model opusplan "design and implement the API"

# Interactive session
claude

# Quick question
claude -p "how do I..."

# Continue conversation
claude -c

# Process file
cat file.py | claude -p "review this"

# JSON output cho scripts
claude -p --output-format json "query"

# Phân tích SEO của 1 post
cat blog/kafka-consumer-groups.md | claude -p \
  --model haiku \
  "Phân tích SEO: title length, description length, headings hierarchy, image alts. Output as JSON" \
  --output-format json | jq '.'

# Generate description từ existing content
cat blog/draft.md | claude -p \
  "Generate 150-160 char SEO description for this post. Vietnamese ok." > description.txt

# Generate summaries cho all posts
for file in blog/*.md; do
  slug=$(basename "$file" .md)
  claude -p --model haiku \
    "Summarize this post in 50 Vietnamese words: $(cat "$file")" \
    > "summaries/$slug.txt"
done

# Audit tất cả posts về frontmatter
for file in blog/*.md; do
  slug=$(basename "$file" .md)
  cat "$file" | claude -p --output-format json \
    --json-schema '{"type":"object","properties":{"valid":{"type":"boolean"},"issues":{"type":"array"}}}' \
    "Audit frontmatter. Check title 50-60 chars, description 150-160, slug, date, tags. Return JSON" \
    > "audits/$slug.json"
done

# Show posts với issues
for f in audits/*.json; do
  if [[ $(jq '.valid' "$f") == "false" ]]; then
    echo "❌ $(basename "$f" .json):"
    jq '.issues' "$f"
  fi
done

name: Blog Quality Audit

on:
  pull_request:
    paths:
      - 'blog/**.md'

jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Audit changed posts
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          FILES=$(git diff --name-only origin/main...HEAD | grep "blog/.*\.md$" || true)
          for file in $FILES; do
            cat "$file" | claude -p \
              --model sonnet \
              --output-format json \
              --max-turns 1 \
              --max-budget-usd 0.10 \
              "Audit blog post for SEO frontmatter, code blocks, image alts, links. Output as JSON." \
              > "audit-$(basename $file .md).json"
          done

# crontab -e
# Mỗi sáng 7h, summary traffic logs gửi email
0 7 * * * tail -1000 /var/log/nginx/blog-access.log | \
  claude --bare -p \
    --model haiku \
    --max-budget-usd 0.05 \
    "Summarize traffic patterns trong 24h qua. Top pages, suspicious requests, error rate." | \
    mail -s "Blog Daily Report" pin@example.com

#!/bin/bash
# Tạo blog post mới với Claude generate frontmatter

TITLE="$1"
SLUG=$(echo "$TITLE" | iconv -f utf-8 -t ascii//TRANSLIT | tr '[:upper:]' '[:lower:]' | tr -c '[:alnum:]' '-' | sed 's/-\+/-/g' | sed 's/^-\|-$//g')
DATE=$(date -u +%Y-%m-%d)

claude -p --output-format json \
  --json-schema '{"type":"object","properties":{"title":{"type":"string"},"description":{"type":"string"},"tags":{"type":"array"}}}' \
  "Generate blog post frontmatter for title: \"$TITLE\".
   - title: keep close to original, max 60 chars
   - description: 150-160 chars, Vietnamese
   - tags: 3-5 lowercase tags
   Return JSON only" > /tmp/frontmatter.json

cat > "blog/$DATE-$SLUG.md" << EOF
---
title: "$(jq -r '.title' /tmp/frontmatter.json)"
description: "$(jq -r '.description' /tmp/frontmatter.json)"
slug: "$SLUG"
date: "${DATE}T12:00:00Z"
tags: $(jq -c '.tags' /tmp/frontmatter.json)
---

# $(jq -r '.title' /tmp/frontmatter.json)

Start writing here...
EOF

echo "✅ Created blog/$DATE-$SLUG.md"

#!/bin/bash
# Chạy validation Claude trước khi commit posts

CHANGED_POSTS=$(git diff --cached --name-only | grep "blog/.*\.md$")

if [ -z "$CHANGED_POSTS" ]; then
  exit 0
fi

echo "🔍 Validating changed posts với Claude..."

for file in $CHANGED_POSTS; do
  RESULT=$(cat "$file" | claude --bare -p \
    --model haiku \
    --max-budget-usd 0.02 \
    --output-format json \
    --json-schema '{"type":"object","properties":{"valid":{"type":"boolean"},"errors":{"type":"array"}}}' \
    "Quick validate this MD: frontmatter complete (title, slug, date, tags), no broken markdown. Return JSON.")

  VALID=$(echo "$RESULT" | jq -r '.valid')
  if [ "$VALID" != "true" ]; then
    echo "❌ $file failed validation:"
    echo "$RESULT" | jq -r '.errors[]'
    exit 1
  fi
  echo "✅ $file"
done

echo "✅ All posts valid"

claude -c                         # Last conversation
claude -r "auth-refactor"         # Specific named session
claude -r "550e8400-..."          # Specific session UUID
claude --resume abc123 --fork-session  # Fork specific session

# Conservative cho automation
claude -p --max-turns 3 "fix lint errors"

# Generous cho complex tasks
claude -p --max-turns 20 "refactor entire module"

# Limit $0.50 per invocation
claude -p --max-budget-usd 0.50 "analyze this codebase"

# Exact match
--allowedTools "Bash(git status)"          # Chỉ "git status"

# Prefix match (note SPACE trước *)
--allowedTools "Bash(git status:*)"        # "git status", "git status -s", etc.

# Compound prefix
--allowedTools "Bash(git push origin:*)"   # "git push origin main", etc.

# Wildcard tool
--allowedTools "Read(*)"                   # All Read calls
--allowedTools "Edit(*)"                   # All Edit calls

# Manual cleanup sessions cũ hơn 30 days
find ~/.claude/projects -name "transcript.jsonl" -mtime +30 -exec rm -rf {}/.. \;

# Disk usage check
du -sh ~/.claude/projects/

# Disable session persistence cho ephemeral runs
claude -p --no-session-persistence "one-off query"

# Use case: Real-time event processing
tail -f /var/log/events.jsonl | \
  claude -p --input-format stream-json \
    "Process each event và alert if anomaly detected"

# Enable specific beta
claude --betas interleaved-thinking "analyze with interleaved thinking"

# Multiple betas
claude --betas interleaved-thinking,prompt-caching "complex task"

# Time với verbose output
time claude --debug --verbose -p "simple query"

# Cost tracking với JSON
RESULT=$(claude -p --output-format json "query")
COST=$(echo "$RESULT" | jq -r '.cost.total_cost')
TOKENS=$(echo "$RESULT" | jq -r '.usage.total_tokens')
DURATION=$(echo "$RESULT" | jq -r '.duration_ms')

echo "Cost: \$$COST"
echo "Tokens: $TOKENS"
echo "Duration: ${DURATION}ms"

# Compare models
for model in opus sonnet haiku; do
  start=$(date +%s%N)
  claude -p --model $model "explain X" > /dev/null
  end=$(date +%s%N)
  echo "$model: $(( (end - start) / 1000000 ))ms"
done

# Bash
eval "$(claude completion bash)"

# Zsh
eval "$(claude completion zsh)"

# Fish
claude completion fish | source

# Add tới ~/.bashrc, ~/.zshrc, etc. để persistent

# Safer scripting với fallback
set -e

result=$(claude -p "query" 2>error.log) || {
  echo "Claude failed: $(cat error.log)"
  result="<unable to analyze>"
}

# Install specific version
npm install -g @anthropic-ai/claude-code@2.1.117

# Check installed version
claude --version

# List available versions
npm view @anthropic-ai/claude-code versions

# Install previous
npm install -g @anthropic-ai/claude-code@<previous-version>

# Custom endpoint
export ANTHROPIC_BASE_URL=https://my-proxy.example.com/v1

# Bedrock
export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-west-2

# Vertex AI
export CLAUDE_CODE_USE_VERTEX=1
export ANTHROPIC_VERTEX_PROJECT_ID=my-project
export CLOUD_ML_REGION=us-central1