Intermediate

# .github/workflows/claude-analysis.yml
name: Claude Code Analysis # => Workflow name shown in GitHub Actions UI
on: [push, pull_request] # => Triggers on every push and PR
 
jobs:
  analyze:
    runs-on: ubuntu-latest # => Fresh Ubuntu VM for each run
    steps:
      - uses: actions/checkout@v3 # => Checks out repo code
      - uses: anthropics/claude-code-action@v1 # => Sets up Claude CLI
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }} # => Reads from GitHub Secrets
      - name: Analyze codebase
        run: claude -p "analyze code for security issues" --output-format json > analysis.json
        # => Runs Claude in non-interactive mode, saves JSON output
      - name: Check for critical issues
        run: |
          CRITICAL=$(jq '.issues[] | select(.severity=="critical") | length' analysis.json)
          # => Counts critical severity issues using jq
          if [ "$CRITICAL" -gt 0 ]; then exit 1; fi
          # => Fails the build (exit 1) if any critical issues found

# .github/workflows/cross-version-test.yml
name: Cross-Version Claude Tests # => Runs tests across all supported Node versions
on: [pull_request] # => Triggers on every PR
 
jobs:
  test-matrix:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [18, 20, 22] # => Creates 3 parallel jobs, one per version
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }} # => Each job uses its matrix node version
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
      - name: Generate tests for Node ${{ matrix.node-version }}
        run: |
          claude -p "generate compatibility tests for Node ${{ matrix.node-version }}" > tests/node${{ matrix.node-version }}.spec.ts
          # => Claude generates version-specific tests (e.g., Node 18 vs 22 async differences)
      - name: Run generated tests
        run: npm test # => Runs Claude-generated tests against current Node version

# .github/workflows/artifact-gen.yml
name: Generate Documentation Artifacts # => Runs on every push to generate fresh docs
on: [push]
 
jobs:
  generate-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
      - name: Generate API docs
        run: |
          claude -p "generate comprehensive API documentation from src/api/**/*.ts" --output-format json > api-docs.json
          # => Scans all TypeScript API files, outputs structured JSON
          claude -p "convert JSON docs to markdown" < api-docs.json > API.md
          # => Converts JSON to readable Markdown documentation
      - name: Upload artifacts
        uses: actions/upload-artifact@v3
        with:
          name: documentation # => Artifact name for downstream jobs
          path: |
            api-docs.json        # => Machine-readable docs
            API.md               # => Human-readable docs
 
  deploy-docs:
    needs: generate-docs # => Runs only after generate-docs succeeds
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@v3
        with:
          name: documentation # => Downloads artifact from generate-docs job
      - name: Deploy to docs site
        run: ./deploy-docs.sh API.md # => Publishes generated docs

# .github/workflows/secure-claude.yml
name: Secure Claude Usage
on: [pull_request] # => Runs on every PR for security gating
 
jobs:
  secure-analysis:
    runs-on: ubuntu-latest
    environment: production # => Requires manual approval for production secrets
    steps:
      - uses: actions/checkout@v3
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }} # Never hardcode API keys
          # => Reads encrypted secret, masked in all logs
      - name: Run Claude with scoped permissions
        env:
          CLAUDE_MAX_BUDGET: "5.00" # => Limits spending to $5 per workflow run
        run: |
          claude -p "analyze security vulnerabilities" \
            --max-budget-usd $CLAUDE_MAX_BUDGET \
            --output-format json > vulnerabilities.json
            # => Budget limit prevents runaway costs if workflow loops
      - name: Never log secrets
        run: |
          # WRONG: echo $CLAUDE_API_KEY   # => Exposes secret in logs
          # RIGHT: Use masked variables
          echo "Analysis complete"        # => Only logs non-sensitive status

# .github/workflows/conditional.yml
name: Conditional Claude Analysis
on:
  pull_request:
    paths:
      - "src/**/*.ts" # => Only run when TypeScript files change
      - "src/**/*.js"
      - "!src/**/*.spec.ts" # => Skip test files (they don't need analysis)
 
jobs:
  analyze-code:
    runs-on: ubuntu-latest
    if: github.event.pull_request.draft == false # => Skip draft PRs (work-in-progress)
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0 # => Full history needed for accurate git diff
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
 
      - name: Get changed files
        id: changed-files
        run: |
          CHANGED=$(git diff --name-only origin/${{ github.base_ref }}...HEAD | grep -E '\.(ts|js)$' || true)
          # => Finds only TS/JS files changed in this PR vs base branch
          echo "files=$CHANGED" >> $GITHUB_OUTPUT  # => Passes file list to next step
 
      - name: Analyze only changed files
        if: steps.changed-files.outputs.files != '' # => Skip if no TS/JS files changed
        run: |
          for FILE in ${{ steps.changed-files.outputs.files }}; do
            echo "Analyzing $FILE"
            claude -p "review $FILE for issues" --output-format json > $FILE.analysis.json
            # => Analyzes each changed file separately for precise feedback
          done

# .github/workflows/pipeline.yml
name: Multi-Stage Pipeline # => Progressive quality gate: lint → test → analyze → deploy
on: [push]
 
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm run lint # => Fast check (~30s), fails fast on style issues
 
  test:
    needs: lint # => Only runs if lint passes
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm test
 
  claude-analysis:
    needs: test # => Only runs if tests pass (saves API costs on failing code)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
      - name: Deep code analysis
        run: |
          claude -p "analyze architecture and suggest improvements" \
            --output-format json > architecture-review.json
            # => Outputs structured JSON for downstream processing
      - name: Generate improvement report
        run: |
          claude -c -p "create prioritized improvement roadmap from analysis" \
            > improvement-roadmap.md
            # => -c flag continues previous session context
      - uses: actions/upload-artifact@v3
        with:
          name: analysis-reports # => Stores reports for download or deploy job
          path: |
            architecture-review.json
            improvement-roadmap.md
 
  deploy:
    needs: claude-analysis # => Deploys only after Claude approves
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' # => Production deploys on main branch only
    steps:
      - uses: actions/checkout@v3
      - run: ./deploy.sh

# .github/workflows/pr-comment.yml
name: Claude PR Review # => Posts Claude's analysis as inline PR comment
on: [pull_request]
 
jobs:
  review-and-comment:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write # => Required permission to post PR comments
    steps:
      - uses: actions/checkout@v3
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
 
      - name: Analyze PR changes
        run: |
          claude -p "review this PR for code quality, security, and best practices" \
            --output-format json > review.json
            # => Produces structured JSON with issues, severity, file references
 
      - name: Format review as markdown
        run: |
          claude -p "convert review JSON to markdown with severity icons" \
            < review.json > review-comment.md
            # => Second Claude call transforms JSON into human-readable comment
 
      - name: Post comment
        uses: actions/github-script@v6 # => GitHub's official scripting action
        with:
          script: |
            const fs = require('fs');
            const body = fs.readFileSync('review-comment.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,  # => Posts to current PR
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## 🤖 Claude Code Review\n\n${body}`
            });

# .github/workflows/release.yml
name: Automated Release Notes # => Triggers on version tags (v1.2.3)
on:
  push:
    tags:
      - "v*" # => Matches v1.0.0, v2.3.1, etc.
 
jobs:
  create-release:
    runs-on: ubuntu-latest
    permissions:
      contents: write # => Required permission to create GitHub releases
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0 # => Full history needed to find previous tag
 
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
 
      - name: Get commits since last tag
        id: commits
        run: |
          PREVIOUS_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
          # => Finds previous version tag (e.g., v1.1.0 before current v1.2.0)
          if [ -z "$PREVIOUS_TAG" ]; then
            COMMITS=$(git log --pretty=format:"%s (%h)" HEAD)  # => First release: all commits
          else
            COMMITS=$(git log --pretty=format:"%s (%h)" $PREVIOUS_TAG..HEAD)  # => Only new commits
          fi
          echo "commits<<EOF" >> $GITHUB_OUTPUT
          echo "$COMMITS" >> $GITHUB_OUTPUT
          echo "EOF" >> $GITHUB_OUTPUT            # => Multiline output using heredoc syntax
 
      - name: Generate release notes
        run: |
          echo "${{ steps.commits.outputs.commits }}" | \
          claude -p "create professional release notes from these commits, categorizing by Features, Bug Fixes, and Improvements" \
            > release-notes.md
            # => Claude categorizes commits and writes user-friendly descriptions
 
      - name: Create GitHub Release
        uses: softprops/action-gh-release@v1
        with:
          body_path: release-notes.md # => Uses Claude's generated content
          generate_release_notes: false # => Disables GitHub's auto-notes in favor of Claude's

# .github/workflows/deploy-gate.yml
name: Deployment with Risk Assessment # => AI-gated deployments based on change analysis
on:
  push:
    branches: [main] # => Every main branch push triggers risk assessment
 
jobs:
  assess-risk:
    runs-on: ubuntu-latest
    outputs:
      risk-level: ${{ steps.risk.outputs.level }} # => Exports risk level to other jobs
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 50 # => Last 50 commits for broader change context
 
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
 
      - name: Assess deployment risk
        id: risk
        run: |
          git diff HEAD~1 HEAD > changes.diff      # => Captures diff of latest commit
          RISK=$(claude -p "assess deployment risk (low/medium/high) based on these changes" \
            --output-format json < changes.diff | jq -r '.risk_level')
            # => Claude analyzes diff: DB migrations, API changes → high; docs → low
          echo "level=$RISK" >> $GITHUB_OUTPUT     # => Makes risk level available to other jobs
          echo "Deployment risk: $RISK"
 
  deploy-staging:
    needs: assess-risk # => Always deploys to staging for verification
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: ./deploy-staging.sh
 
  deploy-production:
    needs: [assess-risk, deploy-staging] # => Requires both risk assessment and staging success
    runs-on: ubuntu-latest
    environment:
      name: production # => GitHub environment with protection rules
      # High-risk deployments require manual approval via environment protection
    steps:
      - uses: actions/checkout@v3
      - name: Check risk level
        run: |
          if [ "${{ needs.assess-risk.outputs.risk-level }}" = "high" ]; then
            echo "⚠️ High-risk deployment detected. Manual approval required."
            # => Environment protection pauses workflow for manual review
          fi
      - run: ./deploy-production.sh

# .github/workflows/auto-rollback.yml
name: Deploy with Auto-Rollback # => AI-monitored deployment with automatic recovery
on:
  workflow_dispatch: # => Manual trigger only - safer for rollback scenarios
    inputs:
      version:
        description: "Version to deploy"
        required: true # => Must specify version explicitly (e.g., v1.2.3)
 
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          ref: ${{ github.event.inputs.version }} # => Checks out specific version tag
      - run: ./deploy.sh
      - name: Save deployment info
        run: |
          echo "VERSION=${{ github.event.inputs.version }}" >> deployment-info.txt
          echo "TIMESTAMP=$(date -u +%s)" >> deployment-info.txt  # => Unix timestamp for rollback timing
      - uses: actions/upload-artifact@v3
        with:
          name: deployment-info # => Passes version/timestamp to monitor-health job
          path: deployment-info.txt
 
  monitor-health:
    needs: deploy # => Starts monitoring immediately after deployment
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
 
      - name: Wait for deployment to stabilize
        run: sleep 120 # => Waits 2 minutes for service to fully start
 
      - name: Fetch and analyze logs
        id: health-check
        run: |
          ./fetch-prod-logs.sh > production.log  # => Fetches last 100 production log lines
 
          HEALTH=$(claude -p "analyze these production logs for errors, anomalies, or performance issues. Return JSON with {healthy: boolean, issues: string[]}" \
            --output-format json < production.log)
            # => Claude detects: error spikes, timeout patterns, memory anomalies
 
          HEALTHY=$(echo "$HEALTH" | jq -r '.healthy')
          echo "healthy=$HEALTHY" >> $GITHUB_OUTPUT  # => Passes health status to rollback step
 
          if [ "$HEALTHY" = "false" ]; then
            echo "🚨 Health check failed!"
            echo "$HEALTH" | jq '.issues[]'           # => Lists detected issues
          fi
 
      - name: Trigger rollback if unhealthy
        if: steps.health-check.outputs.healthy == 'false' # => Only rollback on health failure
        run: |
          echo "Initiating automatic rollback..."
          ./rollback.sh               # => Restores previous stable version

# analyze.py
import subprocess
import json
import sys
 
def analyze_file(filepath):
    """Analyze Python file using Claude Code."""
    result = subprocess.run(
        ['claude', '-p', f'analyze {filepath} for code quality issues',
         '--output-format', 'json'],
        capture_output=True,
        text=True,
        timeout=60
    )
 
    if result.returncode != 0:
        print(f"Error: {result.stderr}", file=sys.stderr)
        sys.exit(1)
 
    analysis = json.loads(result.stdout)
    return analysis
 
def main():
    filepath = sys.argv[1]
    analysis = analyze_file(filepath)
 
    print(f"Issues found: {len(analysis['issues'])}")
    for issue in analysis['issues']:
        print(f"  - [{issue['severity']}] {issue['message']}")
 
if __name__ == '__main__':
    main()

python analyze.py src/main.py   # => Runs Claude analysis
                                    # => Parses JSON output
                                    # => Prints formatted results

// generate-docs.js
const { exec } = require("child_process");
const { promisify } = require("util");
const execAsync = promisify(exec);
 
async function generateDocs(sourceDir) {
  try {
    const { stdout, stderr } = await execAsync(
      `claude -p "generate API documentation from ${sourceDir}" --output-format json`,
      { timeout: 60000 }, // 60 second timeout
    );
 
    if (stderr) {
      console.error("Claude stderr:", stderr);
    }
 
    const docs = JSON.parse(stdout);
    return docs;
  } catch (error) {
    console.error("Failed to generate docs:", error.message);
    process.exit(1);
  }
}
 
async function main() {
  const docs = await generateDocs("src/api/");
 
  console.log(`Generated docs for ${docs.endpoints.length} endpoints`);
 
  // Write to file
  const fs = require("fs").promises;
  await fs.writeFile("docs/api.json", JSON.stringify(docs, null, 2));
}
 
main();

node generate-docs.js           # => Calls Claude via exec
                                    # => Parses JSON output
                                    # => Writes to docs/api.json

// ClaudeAnalyzer.java
import java.io.*;
import java.util.concurrent.TimeUnit;
import com.google.gson.Gson;
 
public class ClaudeAnalyzer {
    private static final int TIMEOUT_SECONDS = 60;
 
    public static class Analysis {
        public String summary;
        public Issue[] issues;
    }
 
    public static class Issue {
        public String severity;
        public String message;
        public String file;
        public int line;
    }
 
    public static Analysis analyzeCodebase(String directory) throws IOException, InterruptedException {
        ProcessBuilder pb = new ProcessBuilder(
            "claude", "-p",
            "analyze code in " + directory + " for security issues",
            "--output-format", "json"
        );
 
        pb.redirectErrorStream(true);
        Process process = pb.start();
 
        // Read output
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(process.getInputStream())
        );
        StringBuilder output = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            output.append(line);
        }
 
        // Wait for completion
        boolean finished = process.waitFor(TIMEOUT_SECONDS, TimeUnit.SECONDS);
        if (!finished) {
            process.destroyForcibly();
            throw new RuntimeException("Claude process timed out");
        }
 
        if (process.exitValue() != 0) {
            throw new RuntimeException("Claude failed with exit code " + process.exitValue());
        }
 
        // Parse JSON
        Gson gson = new Gson();
        return gson.fromJson(output.toString(), Analysis.class);
    }
 
    public static void main(String[] args) throws Exception {
        Analysis analysis = analyzeCodebase("src/main/java/");
 
        System.out.println("Summary: " + analysis.summary);
        System.out.println("Issues found: " + analysis.issues.length);
 
        for (Issue issue : analysis.issues) {
            System.out.printf("[%s] %s:%d - %s%n",
                issue.severity, issue.file, issue.line, issue.message);
        }
    }
}

javac ClaudeAnalyzer.java       # => Compile Java class
java ClaudeAnalyzer             # => Run Claude analysis
                                    # => Prints formatted results

// analyze.go
package main
 
import (
 "bytes"
 "encoding/json"
 "fmt"
 "os"
 "os/exec"
 "time"
)
 
type Analysis struct {
 Summary string  `json:"summary"`
 Issues  []Issue `json:"issues"`
}
 
type Issue struct {
 Severity string `json:"severity"`
 Message  string `json:"message"`
 File     string `json:"file"`
 Line     int    `json:"line"`
}
 
func analyzeCode(directory string) (*Analysis, error) {
 ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
 defer cancel()
 
 cmd := exec.CommandContext(ctx, "claude", "-p",
  fmt.Sprintf("analyze code in %s for issues", directory),
  "--output-format", "json")
 
 var stdout, stderr bytes.Buffer
 cmd.Stdout = &stdout
 cmd.Stderr = &stderr
 
 err := cmd.Run()
 if err != nil {
  return nil, fmt.Errorf("claude failed: %w, stderr: %s", err, stderr.String())
 }
 
 var analysis Analysis
 if err := json.Unmarshal(stdout.Bytes(), &analysis); err != nil {
  return nil, fmt.Errorf("failed to parse JSON: %w", err)
 }
 
 return &analysis, nil
}
 
func main() {
 analysis, err := analyzeCode("./pkg")
 if err != nil {
  fmt.Fprintf(os.Stderr, "Error: %v\n", err)
  os.Exit(1)
 }
 
 fmt.Printf("Summary: %s\n", analysis.Summary)
 fmt.Printf("Issues found: %d\n", len(analysis.Issues))
 
 for _, issue := range analysis.Issues {
  fmt.Printf("[%s] %s:%d - %s\n",
   issue.Severity, issue.File, issue.Line, issue.Message)
 }
}

go run analyze.go               # => Runs Claude analysis from Go
                                    # => Parses JSON output
                                    # => Prints formatted results

#!/bin/bash
# Multi-stage code analysis pipeline
 
# Stage 1: Extract function signatures
cat src/**/*.ts | \
  claude -p "extract all function signatures" --output-format json > signatures.json
 
# Stage 2: Identify complex functions
cat signatures.json | \
  jq '.functions[] | select(.complexity > 10)' | \
  claude -p "analyze these complex functions and suggest refactoring" --output-format json > complex-analysis.json
 
# Stage 3: Generate refactoring plan
cat complex-analysis.json | \
  claude -p "create prioritized refactoring roadmap with effort estimates" > refactoring-plan.md
 
# Stage 4: Validate plan feasibility
cat refactoring-plan.md | \
  claude -p "validate this plan for risks and dependencies" --output-format json > validation.json
 
# Output final results
echo "Refactoring Plan:"
cat refactoring-plan.md
 
echo -e "\nValidation Results:"
jq '.risks[]' validation.json

./multi-stage-analysis.sh       # => Stage 1: Extract signatures
                                    # => Stage 2: Analyze complexity
                                    # => Stage 3: Generate plan
                                    # => Stage 4: Validate plan
                                    # => Outputs final roadmap

function fetchUserData(userId, callback) {
  db.query("SELECT * FROM users WHERE id = ?", [userId], (err, results) => {
    // => Callback receives error and results
    if (err) {
      // => Error passed to callback
      callback(err, null);
      return;
    }
    // => Success: pass null error, results data
    callback(null, results[0]);
  });
}

async function fetchUserData(userId) {
  // => Returns Promise, can use await
  try {
    const results = await db.query("SELECT * FROM users WHERE id = ?", [userId]);
    // => await pauses execution until query resolves
    return results[0];
    // => Returns data directly, no callback needed
  } catch (err) {
    // => Promise rejection caught here
    throw err;
    // => Re-throw for caller to handle
  }
}

You: Convert src/services/legacy.ts from callbacks to async/await
                                    # => Claude reads legacy.ts
                                    # => Identifies callback patterns:
                                    # =>   - 12 functions using error-first callbacks
                                    # =>   - 3 levels of callback nesting (callback hell)
                                    # => Refactors each function:
                                    # =>   - Wraps callback APIs in Promises
                                    # =>   - Converts functions to async
                                    # =>   - Replaces callbacks with await
                                    # =>   - Replaces error-first pattern with try-catch
                                    # => Confirms: "Migrated 12 functions to async/await"

You: Standardize all error handling in src/api/ to use our custom ApiError class
                                    # => Claude searches for error patterns
                                    # => Finds inconsistencies:
                                    # =>   - 8 endpoints use: throw new Error('message')
                                    # =>   - 5 endpoints use: res.status(500).send('Error')
                                    # =>   - 3 endpoints use: throw { code: 500, message: '...' }
                                    # => Reads ApiError class definition
                                    # => Refactors all error handling:
                                    # =>   throw new Error('Not found')
                                    # =>   → throw new ApiError(404, 'USER_NOT_FOUND', 'User not found')
                                    # => Ensures consistent structure:
                                    # =>   - HTTP status code
                                    # =>   - Error code constant
                                    # =>   - User-facing message
                                    # => Updates 16 error throw sites

You: Extract all hardcoded configuration values in src/ to environment variables
                                    # => Claude searches for configuration candidates:
                                    # =>   - Database connection strings
                                    # =>   - API keys and secrets
                                    # =>   - Port numbers
                                    # =>   - Feature flags
                                    # =>   - Rate limit thresholds
                                    # => Identifies 23 hardcoded values:
                                    # =>   - src/config/database.ts: 'localhost:5432'
                                    # =>   - src/api/auth.ts: 'secret-key-123'
                                    # =>   - src/server.ts: port 3000
                                    # =>   - src/middleware/rateLimiter.ts: 100 requests/hour
                                    # => Creates .env.example:
                                    # =>   DATABASE_URL=postgresql://localhost:5432/dbname
                                    # =>   JWT_SECRET=your-secret-key
                                    # =>   PORT=3000
                                    # =>   RATE_LIMIT_PER_HOUR=100
                                    # => Updates code to use process.env:
                                    # =>   const dbUrl = process.env.DATABASE_URL;
                                    # => Creates config module: src/config/env.ts

You: Refactor the payment processing code in src/services/payments.ts to use Strategy pattern
                                    # => Claude reads payments.ts
                                    # => Identifies current structure:
                                    # =>   function processPayment(type, data) {
                                    # =>     if (type === 'credit_card') { ... }
                                    # =>     else if (type === 'paypal') { ... }
                                    # =>     else if (type === 'crypto') { ... }
                                    # =>   }
                                    # => Recognizes Strategy pattern opportunity
                                    # => Refactors to pattern:
                                    # =>   1. Creates interface PaymentStrategy
                                    # =>   2. Implements: CreditCardStrategy, PaypalStrategy, CryptoStrategy
                                    # =>   3. Creates PaymentProcessor with strategy map
                                    # =>   4. Updates processPayment to use strategy
                                    # => Result: extensible, testable, follows OCP
                                    # => Creates 4 new files:
                                    # =>   - PaymentStrategy.ts (interface)
                                    # =>   - CreditCardStrategy.ts
                                    # =>   - PaypalStrategy.ts
                                    # =>   - CryptoStrategy.ts

You: Find and remove unused functions in src/utils/
                                    # => Claude analyzes each file in src/utils/
                                    # => For each exported function:
                                    # =>   1. Searches project for imports
                                    # =>   2. Checks if function called anywhere
                                    # => Identifies unused functions:
                                    # =>   - src/utils/legacy.ts: formatDate (not imported)
                                    # =>   - src/utils/helpers.ts: calculateTotal (imported but never called)
                                    # =>   - src/utils/validators.ts: validateZipCode (not imported)
                                    # => Asks for confirmation:
                                    # => "Found 3 unused functions. Safe to remove?"
You: Yes, remove them
                                    # => Claude deletes functions from files
                                    # => Removes empty files if no exports remain
                                    # => Confirms: "Removed 3 unused functions, deleted 1 empty file"

You: Create a new feature branch for the rate limiting feature and commit the changes
                                    # => Claude uses Bash tool
                                    # => Runs: git checkout -b feature/rate-limiting
                                    # => Branch created: feature/rate-limiting
                                    # => Runs: git status
                                    # => Modified files:
                                    # =>   - src/middleware/rateLimiter.ts (new file)
                                    # =>   - src/server.ts (modified)
                                    # =>   - package.json (modified)
                                    # => Runs: git add (specific files, not git add .)
                                    # =>   git add src/middleware/rateLimiter.ts
                                    # =>   git add src/server.ts
                                    # =>   git add package.json
                                    # => Generates commit message:
                                    # =>   feat(api): add rate limiting middleware
                                    # =>
                                    # =>   - Implement Redis-based rate limiter
                                    # =>   - Support tier-based limits (free: 100/hr, premium: 1000/hr)
                                    # =>   - Add rate limit middleware to server
                                    # => Runs: git commit -m "..."
                                    # => Confirms: "Created branch + committed 3 files"

You: Generate a commit message for the staged changes
                                    # => Claude runs: git diff --staged
                                    # => Analyzes changes:
                                    # =>   - src/api/users.ts: Added error handling (8 insertions)
                                    # =>   - src/api/posts.ts: Added error handling (12 insertions)
                                    # =>   - src/utils/errors.ts: Created ApiError class (new file)
                                    # => Generates message:
                                    # =>   feat(api): standardize error handling with ApiError class
                                    # =>
                                    # =>   - Create custom ApiError class for consistent error responses
                                    # =>   - Add error handling to users and posts endpoints
                                    # =>   - Include HTTP status, error codes, and messages
                                    # =>
                                    # =>   Improves API client error handling with predictable format.
                                    # => Shows message for review
You: Commit with that message
                                    # => Claude runs: git commit -m "..."
                                    # => Confirms: "Committed with generated message"

You: Generate a pull request description for the current branch
                                    # => Claude runs: git diff main...HEAD
                                    # => Analyzes all commits in branch:
                                    # =>   - 5 commits
                                    # =>   - Files changed: 12
                                    # =>   - Insertions: 450, Deletions: 120
                                    # => Reads commit messages and changes
                                    # => Generates PR description:
                                    # => ## Summary
                                    # => Implements rate limiting for API endpoints with tier-based limits.
                                    # =>
                                    # => ## Changes
                                    # => - Add Redis-based rate limiter middleware
                                    # => - Implement tier detection from JWT
                                    # => - Configure limits: free (100/hr), premium (1000/hr)
                                    # => - Add rate limit headers to responses
                                    # => - Include integration tests for rate limiting
                                    # =>
                                    # => ## Testing
                                    # => - [x] Unit tests for middleware
                                    # => - [x] Integration tests for tier-based limits
                                    # => - [x] Manual testing with free and premium accounts
                                    # =>
                                    # => ## Breaking Changes
                                    # => None

You: Help me resolve the merge conflict in src/api/users.ts
                                    # => Claude reads conflicted file
                                    # => Sees conflict markers:
                                    # =>   <<<<<<< HEAD
                                    # =>   export async function createUser(data: CreateUserDTO) {
                                    # =>     const user = await db.users.create(data);
                                    # =>   =======
                                    # =>   export async function createUser(userData: UserInput) {
                                    # =>     const user = await database.insert('users', userData);
                                    # =>   >>>>>>> feature/database-refactor
                                    # => Analyzes differences:
                                    # => "Conflict: Parameter naming and database API differences.
                                    # =>  HEAD uses: CreateUserDTO + db.users.create
                                    # =>  Branch uses: UserInput + database.insert
                                    # =>
                                    # =>  Recommendation: Keep HEAD's approach (ORM-based),
                                    # =>  but update parameter name if UserInput is preferred.
                                    # =>
                                    # =>  Suggested resolution:
                                    # =>  export async function createUser(data: CreateUserDTO) {
                                    # =>    const user = await db.users.create(data);
                                    # =>  }"
You: Apply that resolution
                                    # => Claude removes conflict markers
                                    # => Updates file with suggested code
                                    # => Runs: git add src/api/users.ts

You: Create a GitHub Actions workflow for testing and deploying this Node.js app
                                    # => Claude analyzes project:
                                    # =>   - Detects: Node.js 20.x (from package.json engines)
                                    # =>   - Detects: Jest tests (from package.json scripts)
                                    # =>   - Detects: TypeScript (from tsconfig.json)
                                    # => Generates .github/workflows/ci.yml:
                                    # =>   name: CI/CD
                                    # =>   on: [push, pull_request]
                                    # =>   jobs:
                                    # =>     test:
                                    # =>       runs-on: ubuntu-latest
                                    # =>       steps:
                                    # =>         - uses: actions/checkout@v4
                                    # =>         - uses: actions/setup-node@v4
                                    # =>           with: { node-version: '20.x' }
                                    # =>         - run: npm ci
                                    # =>         - run: npm run build
                                    # =>         - run: npm test
                                    # =>     deploy:
                                    # =>       needs: test
                                    # =>       if: github.ref == 'refs/heads/main'
                                    # =>       runs-on: ubuntu-latest
                                    # =>       steps:
                                    # =>         - (deployment steps)
                                    # => Creates workflow file

You: Generate API documentation for all endpoints in src/api/
                                    # => Claude scans all files in src/api/
                                    # => Identifies endpoints:
                                    # =>   - GET    /api/users
                                    # =>   - POST   /api/users
                                    # =>   - GET    /api/users/:id
                                    # =>   - PATCH  /api/users/:id
                                    # =>   - DELETE /api/users/:id
                                    # =>   - (15 more endpoints...)
                                    # => For each endpoint, extracts:
                                    # =>   - HTTP method and path
                                    # =>   - Request body schema (from validation)
                                    # =>   - Response format (from code)
                                    # =>   - Status codes (success + errors)
                                    # =>   - Authentication requirements
                                    # => Generates docs/api-reference.md:
                                    # =>   ## POST /api/users
                                    # =>   Create a new user account.
                                    # =>
                                    # =>   **Request Body:**
                                    # =>   ```json
                                    # =>   { "name": "string", "email": "string", "password": "string" }
                                    # =>   ```
                                    # =>
                                    # =>   **Responses:**
                                    # =>   - 201: User created (returns user object)
                                    # =>   - 400: Validation error
                                    # =>   - 409: Email already exists

You: Create an architecture diagram showing the layers of this application
                                    # => Claude analyzes project structure:
                                    # =>   - src/api/ (HTTP handlers)
                                    # =>   - src/services/ (business logic)
                                    # =>   - src/models/ (data models)
                                    # =>   - src/database/ (data access)
                                    # => Analyzes imports to understand dependencies
                                    # => Generates Mermaid diagram:
                                    # =>   graph TD
                                    # =>     A[HTTP Layer: src/api/] -->|calls| B[Service Layer: src/services/]
                                    # =>     B -->|uses| C[Model Layer: src/models/]
                                    # =>     B -->|accesses| D[Database Layer: src/database/]
                                    # =>     C -->|schema| D
                                    # =>
                                    # =>     style A fill:#0173B2,stroke:#000,color:#fff
                                    # =>     style B fill:#DE8F05,stroke:#000,color:#fff
                                    # =>     style C fill:#029E73,stroke:#000,color:#fff
                                    # =>     style D fill:#CC78BC,stroke:#000,color:#fff
                                    # => Adds to docs/architecture.md

You: Add explanatory comments to the algorithm in src/utils/recommendation.ts
                                    # => Claude reads recommendation.ts
                                    # => Analyzes complex algorithm:
                                    # =>   function calculateSimilarity(userA, userB) {
                                    # =>     const dotProduct = ...
                                    # =>     const magnitudeA = ...
                                    # =>     const magnitudeB = ...
                                    # =>     return dotProduct / (magnitudeA * magnitudeB);
                                    # =>   }
                                    # => Adds explanatory comments:
                                    # =>   /**
                                    # =>    * Calculates cosine similarity between two user preference vectors.
                                    # =>    * Higher values (closer to 1) indicate more similar preferences.
                                    # =>    * Used for collaborative filtering recommendations.
                                    # =>    */
                                    # =>   function calculateSimilarity(userA, userB) {
                                    # =>     // Compute dot product of preference vectors
                                    # =>     const dotProduct = ...
                                    # =>     // Calculate magnitude (Euclidean norm) for normalization
                                    # =>     const magnitudeA = ...
                                    # =>     const magnitudeB = ...
                                    # =>     // Cosine similarity: dot product divided by product of magnitudes
                                    # =>     return dotProduct / (magnitudeA * magnitudeB);
                                    # =>   }

You: Analyze src/services/search.ts for performance issues and suggest optimizations
                                    # => Claude reads search.ts
                                    # => Analyzes code:
                                    # =>   function search(query) {
                                    # =>     const allItems = loadAllItems();  // Loads 10,000+ items
                                    # =>     return allItems.filter(item => item.name.includes(query));
                                    # =>   }
                                    # => Identifies issues:
                                    # =>   1. Loading all items inefficient (O(n) every search)
                                    # =>   2. Linear search through all items
                                    # =>   3. Case-sensitive matching misses results
                                    # => Suggests optimizations:
                                    # =>   1. Add database index on name column
                                    # =>   2. Push filter to SQL WHERE clause (database-level)
                                    # =>   3. Use ILIKE for case-insensitive search
                                    # =>   4. Add pagination to limit result set
                                    # => Provides optimized implementation:
                                    # =>   async function search(query, page = 1, limit = 20) {
                                    # =>     // Database performs filtering (much faster)
                                    # =>     return await db.query(
                                    # =>       'SELECT * FROM items WHERE name ILIKE $1 LIMIT $2 OFFSET $3',
                                    # =>       [`%${query}%`, limit, (page - 1) * limit]
                                    # =>     );
                                    # =>   }

You: Audit src/components/Modal.tsx for accessibility issues
                                    # => Claude reads Modal.tsx
                                    # => Identifies issues:
                                    # =>   1. Missing focus trap (keyboard users can tab outside modal)
                                    # =>   2. Missing ARIA role and labels
                                    # =>   3. No keyboard close (ESC key)
                                    # =>   4. Missing focus management (return focus on close)
                                    # =>   5. Close button has no accessible label (icon only)
                                    # => Suggests fixes:
                                    # =>   1. Add role="dialog" and aria-modal="true"
                                    # =>   2. Add aria-labelledby pointing to title
                                    # =>   3. Implement ESC key handler
                                    # =>   4. Use useEffect to manage focus
                                    # =>   5. Add aria-label="Close" to close button
                                    # => Generates improved component:
                                    # =>   <div role="dialog" aria-modal="true" aria-labelledby="modal-title">
                                    # =>     <h2 id="modal-title">{title}</h2>
                                    # =>     <button onClick={onClose} aria-label="Close">
                                    # =>       <CloseIcon aria-hidden="true" />
                                    # =>     </button>
                                    # =>     {children}
                                    # =>   </div>
                                    # => Adds keyboard handlers and focus management