How We Integrated Claude Code into Our Development Workflow

name: Claude Code PR Review
on:
  pull_request:
    types: [opened, synchronize, reopened]
  workflow_dispatch:

env:
  CLAUDE_CODE_API_KEY: ${{ secrets.CLAUDE_CODE_API_KEY }}
  NODE_VERSION: '20.x'
  REPO_OWNER: ${{ github.repository_owner }}
  REPO_NAME: ${{ github.event.repository.name }}
  PR_NUMBER: ${{ github.event.pull_request.number }}

jobs:
  claude-review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Fetch full history for accurate diff analysis

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'

      - name: Install Claude Code CLI
        run: |
          npm install -g @anthropic-ai/claude-code@2.3.1
          claude-code --version  # Verify installation

      - name: Authenticate Claude Code
        run: |
          claude-code auth set-key $CLAUDE_CODE_API_KEY
          # Validate auth by checking account status
          AUTH_STATUS=$(claude-code auth status --json | jq -r '.authenticated')
          if [ "$AUTH_STATUS" != "true" ]; then
            echo "::error::Claude Code authentication failed"
            exit 1
          fi

      - name: Run PR Review
        id: review
        run: |
          # Generate diff for the PR
          git diff origin/main...HEAD > pr_diff.patch
          # Run Claude Code review with custom prompt for our team's standards
          claude-code review \
            --diff pr_diff.patch \
            --prompt-file .github/claude-review-prompt.md \
            --output-format json \
            --max-suggestions 15 \
            > review_output.json
          # Check for review errors
          if [ ! -f review_output.json ]; then
            echo "::error::Claude Code review failed to generate output"
            exit 1
          fi
          # Parse review results
          REVIEW_COMMENT=$(jq -r '.summary' review_output.json)
          echo "review_comment=$REVIEW_COMMENT" >> $GITHUB_OUTPUT

      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const reviewComment = `${{ steps.review.outputs.review_comment }}`;
            const fs = require('fs');
            const reviewJson = JSON.parse(fs.readFileSync('review_output.json', 'utf8'));
            let commentBody = `## Claude Code Automated Review\n${reviewComment}\n\n### Detailed Suggestions\n`;
            reviewJson.suggestions.forEach((sug, idx) => {
              commentBody += `#### ${idx+1}. ${sug.title}\n`;
              commentBody += `- File: ${sug.filePath}:${sug.lineNumber}\n`;
              commentBody += `- Severity: ${sug.severity}\n`;
              commentBody += `- Description: ${sug.description}\n`;
              if (sug.suggestedFix) {
                commentBody += `- Suggested Fix:\n\`\`\`${sug.language}\n${sug.suggestedFix}\n\`\`\`\n`;
              }
            });
            // Check if existing comment exists to avoid duplicates
            const existingComments = await github.rest.issues.listComments({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
            });
            const claudeComment = existingComments.data.find(comment => 
              comment.body.includes('## Claude Code Automated Review')
            );
            if (claudeComment) {
              await github.rest.issues.updateComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                comment_id: claudeComment.id,
                body: commentBody
              });
            } else {
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: context.issue.number,
                body: commentBody
              });
            }

      - name: Handle Review Errors
        if: failure()
        uses: actions/github-script@v7
        with:
          script: |
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body: `## Claude Code Review Failed\nAn error occurred during the automated review. Please check the [workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}) for details.`
            });

import os
import json
import time
import csv
import argparse
from datetime import datetime
from github import Github
from anthropic import Anthropic

# Configuration constants
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
CLAUDE_API_KEY = os.getenv("CLAUDE_CODE_API_KEY")
REPO_NAME = "our-org/backend-service"
BENCHMARK_OUTPUT = "claude_benchmark_results.csv"
MAX_PR_AGE_DAYS = 90
MIN_PR_LINES = 50
MAX_PR_LINES = 500

def validate_env_vars():
    """Validate required environment variables are set"""
    missing = []
    if not GITHUB_TOKEN:
        missing.append("GITHUB_TOKEN")
    if not CLAUDE_API_KEY:
        missing.append("CLAUDE_CODE_API_KEY")
    if missing:
        raise ValueError(f"Missing required environment variables: {', '.join(missing)}")

def get_benchmark_prs(github_client):
    """Fetch merged PRs from the last 90 days within line change bounds"""
    repo = github_client.get_repo(REPO_NAME)
    prs = []
    for pr in repo.get_pulls(state="closed", sort="merged", direction="desc"):
        # Skip unmerged PRs
        if not pr.merged:
            continue
        # Skip PRs older than MAX_PR_AGE_DAYS
        age_days = (datetime.now() - pr.merged_at).days
        if age_days > MAX_PR_AGE_DAYS:
            break
        # Get PR diff stats
        diff = pr.get_diff()
        lines_changed = len(diff.splitlines())
        if lines_changed < MIN_PR_LINES or lines_changed > MAX_PR_LINES:
            continue
        # Get human review time (time from first review to merge)
        reviews = list(pr.get_reviews())
        if not reviews:
            continue
        first_review_time = min([r.submitted_at for r in reviews])
        review_duration = (pr.merged_at - first_review_time).total_seconds() / 3600  # Hours
        prs.append({
            "pr_number": pr.number,
            "lines_changed": lines_changed,
            "human_review_hours": round(review_duration, 2),
            "diff": diff
        })
        if len(prs) >= 100:  # Limit to 100 PRs for benchmark
            break
    return prs

def run_claude_review(pr_diff, anthropic_client):
    """Run Claude Code review on PR diff and return duration"""
    start_time = time.time()
    try:
        response = anthropic_client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=4096,
            messages=[{
                "role": "user",
                "content": f"Review the following PR diff for bugs, security issues, and style violations. Return a JSON object with 'review_duration_hours' (estimated human equivalent time) and 'suggestions' array.\n\nDiff:\n{pr_diff}"
            }]
        )
        # Parse response
        result = json.loads(response.content[0].text)
        claude_duration = result.get("review_duration_hours", 0)
        return round(claude_duration, 2), True
    except Exception as e:
        print(f"Error running Claude review: {str(e)}")
        return 0, False
    finally:
        end_time = time.time()
        print(f"Claude review completed in {round(end_time - start_time, 2)} seconds")

def write_benchmark_results(results):
    """Write benchmark results to CSV"""
    with open(BENCHMARK_OUTPUT, 'w', newline='') as csvfile:
        fieldnames = ["pr_number", "lines_changed", "human_review_hours", "claude_review_hours", "success"]
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        for row in results:
            writer.writerow(row)
    print(f"Benchmark results written to {BENCHMARK_OUTPUT}")

def main():
    parser = argparse.ArgumentParser(description="Benchmark Claude Code vs human PR review times")
    parser.add_argument("--pr-count", type=int, default=100, help="Number of PRs to benchmark")
    args = parser.parse_args()

    try:
        validate_env_vars()
        github_client = Github(GITHUB_TOKEN)
        anthropic_client = Anthropic(api_key=CLAUDE_API_KEY)

        print(f"Fetching {args.pr_count} merged PRs from {REPO_NAME}...")
        benchmark_prs = get_benchmark_prs(github_client)[:args.pr_count]
        print(f"Fetched {len(benchmark_prs)} PRs for benchmarking")

        results = []
        for idx, pr in enumerate(benchmark_prs, 1):
            print(f"Processing PR {pr['pr_number']} ({idx}/{len(benchmark_prs)})...")
            claude_hours, success = run_claude_review(pr["diff"], anthropic_client)
            results.append({
                "pr_number": pr["pr_number"],
                "lines_changed": pr["lines_changed"],
                "human_review_hours": pr["human_review_hours"],
                "claude_review_hours": claude_hours,
                "success": success
            })
            # Rate limit buffer
            time.sleep(1)

        write_benchmark_results(results)
        # Print summary stats
        successful = [r for r in results if r["success"]]
        avg_human = sum(r["human_review_hours"] for r in successful) / len(successful)
        avg_claude = sum(r["claude_review_hours"] for r in successful) / len(successful)
        print(f"\nBenchmark Summary:")
        print(f"Total PRs processed: {len(results)}")
        print(f"Successful Claude reviews: {len(successful)}")
        print(f"Average human review time: {round(avg_human, 2)} hours")
        print(f"Average Claude equivalent review time: {round(avg_claude, 2)} hours")
        print(f"Time savings: {round((1 - avg_claude/avg_human)*100, 2)}%")

    except Exception as e:
        print(f"Benchmark failed: {str(e)}")
        exit(1)

if __name__ == "__main__":
    main()

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');
const readline = require('readline');

// Configuration
const CLAUDE_CODE_BIN = 'claude-code';
const TEST_DIR = path.join(__dirname, 'src', '__tests__');
const SUPPORTED_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx'];
const MAX_FILE_LINES = 1000;
const OUTPUT_FORMAT = 'jest';

// Validate Claude Code is installed
function validateClaudeCode() {
  try {
    const version = execSync(`${CLAUDE_CODE_BIN} --version`).toString().trim();
    console.log(`Using Claude Code version: ${version}`);
    return true;
  } catch (error) {
    console.error('::error::Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code@2.3.1');
    return false;
  }
}

// Get list of staged files from git
function getStagedFiles() {
  try {
    const output = execSync('git diff --cached --name-only --diff-filter=ACM').toString().trim();
    if (!output) return [];
    return output.split('\n').filter(file => {
      const ext = path.extname(file);
      return SUPPORTED_EXTENSIONS.includes(ext) && fs.existsSync(file);
    });
  } catch (error) {
    console.error('Failed to get staged files:', error.message);
    return [];
  }
}

// Generate unit tests for a single file
function generateTestsForFile(filePath) {
  const fileStats = fs.statSync(filePath);
  if (fileStats.size > MAX_FILE_LINES * 100) {  // Rough line count check
    console.warn(`Skipping ${filePath}: exceeds max line limit of ${MAX_FILE_LINES}`);
    return null;
  }

  const fileContent = fs.readFileSync(filePath, 'utf8');
  const fileName = path.basename(filePath);
  const testFileName = fileName.replace(/\.(js|ts|jsx|tsx)$/, '.test.$1');
  const testFilePath = path.join(TEST_DIR, testFileName);

  console.log(`Generating tests for ${filePath}...`);
  try {
    // Run Claude Code to generate tests
    const command = `${CLAUDE_CODE_BIN} generate-tests \
      --file ${filePath} \
      --output-format ${OUTPUT_FORMAT} \
      --prompt "Generate comprehensive unit tests for the above file, covering edge cases, error handling, and happy paths. Use Jest and follow our team's testing conventions." \
      --json`;
    const output = execSync(command).toString();
    const result = JSON.parse(output);

    if (!result.success) {
      console.error(`Failed to generate tests for ${filePath}: ${result.error}`);
      return null;
    }

    // Ensure test directory exists
    if (!fs.existsSync(TEST_DIR)) {
      fs.mkdirSync(TEST_DIR, { recursive: true });
    }

    // Write test file
    fs.writeFileSync(testFilePath, result.testCode);
    console.log(`✅ Generated test file: ${testFilePath}`);
    return testFilePath;
  } catch (error) {
    console.error(`Error generating tests for ${filePath}: ${error.message}`);
    return null;
  }
}

// Main execution
async function main() {
  if (!validateClaudeCode()) {
    process.exit(1);
  }

  const stagedFiles = getStagedFiles();
  if (stagedFiles.length === 0) {
    console.log('No staged files to generate tests for.');
    process.exit(0);
  }

  console.log(`Found ${stagedFiles.length} staged files for test generation:`);
  stagedFiles.forEach(file => console.log(`  - ${file}`));

  // Prompt user to confirm
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  const answer = await new Promise(resolve => {
    rl.question('Proceed with test generation? (y/N) ', resolve);
  });
  rl.close();

  if (answer.toLowerCase() !== 'y') {
    console.log('Test generation cancelled.');
    process.exit(0);
  }

  // Generate tests for each file
  const generatedTests = [];
  for (const file of stagedFiles) {
    const testFile = generateTestsForFile(file);
    if (testFile) {
      generatedTests.push(testFile);
      // Stage the generated test file
      try {
        execSync(`git add ${testFile}`);
        console.log(`Staged test file: ${testFile}`);
      } catch (error) {
        console.warn(`Failed to stage ${testFile}: ${error.message}`);
      }
    }
  }

  console.log(`\nTest generation complete. Generated ${generatedTests.length} test files.`);
  if (generatedTests.length > 0) {
    console.log('Run tests with: npm test');
  }
}

main().catch(error => {
  console.error('Fatal error:', error.message);
  process.exit(1);
});

# Custom Claude Code Review Prompt
You are reviewing PRs for a fintech engineering team. Follow these rules strictly:
1. All async functions must use try/catch with structured error logging to Datadog
2. No use of console.log, console.warn, or console.error in production code
3. All database queries must include parameterized inputs to prevent SQL injection
4. Payments-related code must not log raw credit card numbers, CVV, or expiration dates
5. API endpoints must include rate limiting middleware
6. Flag any N+1 query patterns in ORM usage (we use Sequelize v6.35.x)
7. Suggest Redis caching for read-heavy endpoints with >100 req/min traffic

claude-code batch \
  --input-dir ./services \
  --output-dir ./services-esm \
  --prompt "Migrate all CommonJS files to ESM, update imports/exports, preserve JSDoc comments, ensure compatibility with Vite v5.x" \
  --max-concurrent 10 \
  --test-command "npm test" \
  --output-format diff

# Fetch Jira context for PR
PR_TITLE=$(git log -1 --pretty=%B)
JIRA_ID=$(echo $PR_TITLE | grep -oP '\[JIRA-\d+\]' | tr -d '[]')
if [ -n "$JIRA_ID" ]; then
  jira-cli get-issue $JIRA_ID --output json > jira_context.json
  claude-code review --diff pr_diff.patch --context jira_context.json
fi