Claude API × GitHub Actions: Production CI/CD Pipelines for Automated Code Review, Test Generation, and Documentation

# .github/workflows/ai-code-review.yml
name: AI Code Review
 
on:
  pull_request:
    types: [opened, synchronize]
    # Skip lock files and build artifacts to reduce noise and cost
    paths-ignore:
      - '*.lock'
      - '*.json'
      - 'dist/**'
 
jobs:
  ai-review:
    runs-on: ubuntu-latest
    # Cancel in-progress runs when new commits are pushed
    concurrency:
      group: ai-review-${{ github.event.pull_request.number }}
      cancel-in-progress: true
 
    permissions:
      pull-requests: write
      contents: read
 
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'
 
      - name: Install dependencies
        run: pip install anthropic PyGithub
 
      - name: Run AI Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
          BASE_SHA: ${{ github.event.pull_request.base.sha }}
          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
        run: python .github/scripts/ai_code_review.py
        continue-on-error: true
        timeout-minutes: 5

# .github/scripts/ai_code_review.py
import os
import subprocess
import anthropic
from github import Github
 
ANTHROPIC_API_KEY = os.environ["ANTHROPIC_API_KEY"]
GITHUB_TOKEN = os.environ["GITHUB_TOKEN"]
REPO_NAME = os.environ["GITHUB_REPOSITORY"]
PR_NUMBER = int(os.environ["PR_NUMBER"])
BASE_SHA = os.environ["BASE_SHA"]
HEAD_SHA = os.environ["HEAD_SHA"]
 
MAX_DIFF_CHARS = 20000  # Hard cap to prevent token overruns
 
def get_diff() -> str:
    """Retrieve the PR diff, limited to source code files."""
    result = subprocess.run(
        ["git", "diff", f"{BASE_SHA}...{HEAD_SHA}",
         "--", "*.py", "*.ts", "*.tsx", "*.js", "*.jsx",
         "*.go", "*.rs", "*.java", "*.swift"],
        capture_output=True, text=True
    )
    diff = result.stdout
    if len(diff) > MAX_DIFF_CHARS:
        diff = diff[:MAX_DIFF_CHARS] + "\n\n[Diff truncated — too large to display in full]"
    return diff
 
def review_with_claude(diff: str) -> str:
    """Send the diff to Claude for review."""
    client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
 
    # System prompt is cached — same content reused across PRs = major cost savings
    system_prompt = """You are a senior engineer conducting a code review. Analyze the provided diff and identify issues in these areas:
 
1. **Bugs & Logic Errors**: null dereferences, off-by-one errors, race conditions
2. **Security Risks**: injection vulnerabilities, auth bypasses, exposed secrets
3. **Performance Issues**: unnecessary loops, N+1 queries, memory leaks
4. **Readability**: misleading names, overly complex functions, missing error handling
5. **Best Practices**: testability, separation of concerns, SOLID principles
 
If no significant issues exist, clearly state "No critical issues found."
Limit your response to 5 comments maximum. Use Markdown formatting. Be direct and actionable."""
 
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2000,
        system=[
            {
                "type": "text",
                "text": system_prompt,
                "cache_control": {"type": "ephemeral"}  # Cache this prompt
            }
        ],
        messages=[
            {
                "role": "user",
                "content": f"Please review the following code diff:\n\n```diff\n{diff}\n```"
            }
        ]
    )
 
    return response.content[0].text
 
def post_comment(review: str):
    """Post the review as a PR comment, replacing any previous AI review."""
    gh = Github(GITHUB_TOKEN)
    repo = gh.get_repo(REPO_NAME)
    pr = repo.get_pull(PR_NUMBER)
 
    # Remove stale AI review comments to avoid clutter
    for comment in pr.get_issue_comments():
        if comment.body.startswith("## 🤖 AI Code Review"):
            comment.delete()
 
    pr.create_issue_comment(
        f"## 🤖 AI Code Review\n\n{review}\n\n---\n"
        f"*This review was generated automatically by Claude API.*"
    )
 
def main():
    diff = get_diff()
    if not diff.strip():
        print("No diff found. Skipping review.")
        return
 
    print(f"Diff size: {len(diff)} characters")
    review = review_with_claude(diff)
    post_comment(review)
    print("✅ Review comment posted successfully")
 
if __name__ == "__main__":
    main()

# .github/workflows/ai-test-generation.yml
name: AI Test Generation
 
on:
  pull_request:
    types: [opened, synchronize]
    paths:
      - 'src/**/*.py'
 
jobs:
  generate-tests:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
 
    steps:
      - uses: actions/checkout@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          ref: ${{ github.head_ref }}
          fetch-depth: 0
 
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
 
      - run: pip install anthropic
 
      - name: Generate Tests
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          BASE_SHA: ${{ github.event.pull_request.base.sha }}
        run: python .github/scripts/generate_tests.py
        continue-on-error: true
 
      - name: Commit generated tests
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add tests/
          git diff --staged --quiet || git commit -m "test: add AI-generated unit tests [skip ci]"
          git push

# .github/scripts/generate_tests.py
import os
import subprocess
import anthropic
from pathlib import Path
 
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
BASE_SHA = os.environ.get("BASE_SHA", "HEAD~1")
 
def get_new_python_files() -> list[str]:
    """Find Python files that were added (not modified) in this PR."""
    result = subprocess.run(
        ["git", "diff", "--name-only", "--diff-filter=A", f"{BASE_SHA}...HEAD"],
        capture_output=True, text=True
    )
    return [f for f in result.stdout.strip().split("\n")
            if f.endswith(".py") and f.startswith("src/") and f]
 
def generate_test(source_file: str) -> str | None:
    """Ask Claude to generate pytest tests for the given source file."""
    source_code = Path(source_file).read_text()
    if len(source_code) > 10000:
        return None  # Skip very large files
 
    # Use Haiku for speed and cost efficiency — test generation doesn't need Sonnet
    response = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=3000,
        system="""You are a Python testing expert. Generate pytest unit tests for the provided source code.
Requirements:
- Cover both happy path and edge cases for each function
- Use unittest.mock for external dependencies
- Each test must be independent and self-contained
- Add docstrings explaining each test's intent
- Output only code — no explanations""",
        messages=[
            {"role": "user", "content": f"Generate tests for:\n\n```python\n{source_code}\n```"}
        ]
    )
 
    test_code = response.content[0].text
    # Strip markdown code fences if present
    if "```python" in test_code:
        test_code = test_code.split("```python")[1].split("```")[0].strip()
    return test_code
 
def main():
    new_files = get_new_python_files()
    if not new_files:
        print("No new Python files found. Skipping.")
        return
 
    Path("tests").mkdir(exist_ok=True)
 
    for source_file in new_files:
        print(f"Generating tests for: {source_file}")
        test_code = generate_test(source_file)
        if not test_code:
            continue
 
        # src/module/utils.py → tests/test_module_utils.py
        test_name = "test_" + source_file.replace("src/", "").replace("/", "_")
        test_path = Path("tests") / test_name
        test_path.write_text(test_code)
        print(f"✅ Written: {test_path}")
 
if __name__ == "__main__":
    main()

# .github/workflows/ai-pr-summary.yml
name: AI PR Summary
 
on:
  pull_request:
    types: [opened]  # Only on creation, not every push
 
jobs:
  summarize:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read
 
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
 
      - run: pip install anthropic PyGithub
 
      - name: Generate PR Summary
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
          PR_TITLE: ${{ github.event.pull_request.title }}
          BASE_SHA: ${{ github.event.pull_request.base.sha }}
          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
        run: |
          python - <<'EOF'
          import os, subprocess, anthropic
          from github import Github
 
          client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
          gh = Github(os.environ["GITHUB_TOKEN"])
          repo = gh.get_repo(os.environ["GITHUB_REPOSITORY"])
          pr = repo.get_pull(int(os.environ["PR_NUMBER"]))
 
          commits = [c.commit.message.split("\n")[0] for c in pr.get_commits()]
          diff_stat = subprocess.run(
              ["git", "diff", "--stat", f"{os.environ['BASE_SHA']}...{os.environ['HEAD_SHA']}"],
              capture_output=True, text=True
          ).stdout[:3000]
 
          response = client.messages.create(
              model="claude-haiku-4-5-20251001",
              max_tokens=1500,
              messages=[{
                  "role": "user",
                  "content": f"""Generate a reviewer-friendly PR summary.
 
  **PR Title**: {os.environ['PR_TITLE']}
 
  **Commits**:
  {chr(10).join(f'- {m}' for m in commits[:10])}
 
  **Files Changed**:
  {diff_stat}
 
  Include:
  1. The purpose of this change (1-2 sentences)
  2. Key changes made (3-5 bullet points)
  3. Suggested testing approach
  4. Areas that deserve extra reviewer attention"""
              }]
          )
 
          pr.create_issue_comment(
              f"## 📋 AI PR Summary\n\n{response.content[0].text}\n\n---\n"
              f"*Generated automatically by Claude API*"
          )
          EOF
        continue-on-error: true

# .github/workflows/ai-release-notes.yml
name: AI Release Notes
 
on:
  push:
    tags:
      - 'v*'
 
jobs:
  release-notes:
    runs-on: ubuntu-latest
    permissions:
      contents: write
 
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
 
      - run: pip install anthropic PyGithub
 
      - name: Generate Release Notes
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          TAG_NAME: ${{ github.ref_name }}
        run: |
          python - <<'EOF'
          import os, subprocess, anthropic
          from github import Github
 
          client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
          gh = Github(os.environ["GITHUB_TOKEN"])
          repo = gh.get_repo(os.environ["GITHUB_REPOSITORY"])
          tag = os.environ["TAG_NAME"]
 
          tags = list(repo.get_tags())
          prev_tag = tags[1].name if len(tags) > 1 else ""
 
          if prev_tag:
              commits_output = subprocess.run(
                  ["git", "log", f"{prev_tag}..{tag}", "--pretty=format:%s"],
                  capture_output=True, text=True
              ).stdout
          else:
              commits_output = subprocess.run(
                  ["git", "log", tag, "--pretty=format:%s", "-50"],
                  capture_output=True, text=True
              ).stdout
 
          response = client.messages.create(
              model="claude-sonnet-4-6",
              max_tokens=2000,
              messages=[{
                  "role": "user",
                  "content": f"""Generate release notes from these commits.
 
  **Version**: {tag} (previous: {prev_tag or 'initial release'})
 
  **Commits**:
  {commits_output[:5000]}
 
  Format as Markdown with these sections (omit empty ones):
  - ## 🚀 New Features
  - ## 🐛 Bug Fixes
  - ## ⚡ Improvements
  - ## 🔧 Internal Changes
  - ## ⚠️ Breaking Changes"""
              }]
          )
 
          repo.create_git_release(
              tag=tag,
              name=f"Release {tag}",
              message=response.content[0].text,
              draft=False,
              prerelease=any(x in tag for x in ["rc", "beta", "alpha"])
          )
          print(f"✅ Release {tag} created")
          EOF

import time
import anthropic
from anthropic import RateLimitError
 
def call_claude_with_retry(client, max_retries=3, **kwargs):
    """Wrap any Claude API call with retry logic."""
    for attempt in range(max_retries):
        try:
            return client.messages.create(**kwargs)
        except RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # 1s → 2s → 4s
            print(f"Rate limited. Retrying in {wait}s ({attempt+1}/{max_retries})")
            time.sleep(wait)
        except anthropic.APIStatusError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise

jobs:
  ai-review:
    timeout-minutes: 10    # Job-level timeout
    steps:
      - name: Run AI Code Review
        timeout-minutes: 5  # Step-level timeout
        continue-on-error: true

def get_changed_services(base_sha: str, head_sha: str) -> list[str]:
    """Identify which services were touched by this PR."""
    result = subprocess.run(
        ["git", "diff", "--name-only", f"{base_sha}...{head_sha}"],
        capture_output=True, text=True
    )
    services = set()
    for filepath in result.stdout.strip().split("\n"):
        parts = filepath.split("/")
        if len(parts) >= 2 and parts[0] == "services":
            services.add(parts[1])
    return list(services)
 
def build_service_context(service: str) -> str:
    """Inject service-specific context into the review prompt."""
    contexts = {
        "auth-service": "This service handles authentication. Pay special attention to token validation and session management.",
        "payment-service": "This service processes payments. Data integrity and error handling are critical.",
    }
    return contexts.get(service, "")