Claude Code for CI/CD.

# .github/workflows/claude.yml
name: Claude PR review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          fetch-depth: 2

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

      - name: Per-file review
        env:
          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
          GH_TOKEN: ${{ github.token }}
        run: ./.github/scripts/per-file-review.sh

# .github/scripts/per-file-review.sh
#!/usr/bin/env bash
set -euo pipefail

REVIEW_DIR=$(mktemp -d)
echo "files=$REVIEW_DIR" >> "$GITHUB_OUTPUT"

# Per-file independent sessions. NOT one big session
for f in $(gh pr diff --name-only); do
  echo "::group::Reviewing $f"
  out="$REVIEW_DIR/$(echo "$f" | tr '/' '_').json"
  claude review pr \
    -p \
    --output-format json \
    --custom-instructions ".github/claude-context.md" \
    --allowed-tools "Read,Grep,Glob,Bash(git diff,git log,gh pr diff)" \
    --files "$f" \
    --max-turns 6 \
    > "$out" || echo '{"file":"'"$f"'","verdict":"comment","issues":[],"summary":"review failed"}' > "$out"
  echo "::endgroup::"
done

# Aggregate to one file the next step parses
jq -s '.' "$REVIEW_DIR"/*.json > review-aggregate.json

# .github/claude-context.md (committed; loaded by --custom-instructions)
# Project review rubric
# Stack: Next.js 15 + TypeScript strict + Drizzle. We use Server Actions
# instead of API routes; named exports only; 2-space indent.
#
# Severity rubric:
#   blocker  = type unsafe, secret leaked, missing test for changed code,
#              breaks API contract, server-action without zod validation
#   nit      = naming inconsistency, missing JSDoc, slightly verbose
#   praise   = clever simplification, good test, well-named refactor
#
# Skip (do NOT review):
#   - pnpm-lock.yaml
#   - public/scenarios/*.svg (generated)
#   - any file under .next/, dist/, build/, node_modules/
#
# Output format reminder:
#   Always emit JSON: { file, verdict, issues[], summary }.
#   verdict ∈ {approve, request_changes, comment}.
#   issues[].severity ∈ {blocker, nit, praise}.

# WRONG. Open invitation to prompt injection
# claude review pr -p --allowed-tools "*"
#
# WRONG. Bash with no whitelist
# claude review pr -p --allowed-tools "Read,Bash"
#
# RIGHT. Every tool explicit, Bash narrowly scoped to read-only commands
ALLOWED='Read,Grep,Glob,Bash(git diff,git log --oneline -20,gh pr diff,gh pr view)'
claude review pr -p \
  --allowed-tools "$ALLOWED" \
  --files "$f" \
  --max-turns 6 \
  --output-format json
#
# Periodically audit: grep workflows for any "*" or unscoped Bash
# rg -n 'allowed-tools.*"[^"]*\*' .github/workflows/

# .github/scripts/post-comments.sh
#!/usr/bin/env bash
set -euo pipefail

# Aggregate file from previous step
agg=review-aggregate.json

# Per-issue inline comments
jq -c '.[].issues[] as $i | { file: .[].file, line: $i.line, body: $i.message }' "$agg" \
  | while read -r row; do
      file=$(echo "$row" | jq -r .file)
      line=$(echo "$row" | jq -r .line)
      body=$(echo "$row" | jq -r .body)
      gh pr review --comment --body "$body" --comment-line "$line" -- "$file"
    done

# Summary verdict
blockers=$(jq '[.[] | .issues[] | select(.severity=="blocker")] | length' "$agg")
if [ "$blockers" -gt 0 ]; then
  gh pr review --request-changes --body "$blockers blocker(s) found. See inline comments."
else
  gh pr review --approve --body "LGTM. Inline nits/praise where applicable."
fi

# In per-file-review.sh. Bounded concurrency via xargs -P
gh pr diff --name-only \
  | xargs -n 1 -P 4 -I {} bash -c '
      file="$1"
      out="$REVIEW_DIR/$(echo "$file" | tr / _).json"
      claude review pr -p --output-format json --files "$file" \
        --custom-instructions ".github/claude-context.md" \
        --allowed-tools "Read,Grep,Glob,Bash(git diff,git log,gh pr diff)" \
        --max-turns 6 > "$out"
    ' _ {}

# Per-PR token budget guard (run before the loop)
TOKEN_BUDGET=${CLAUDE_PR_TOKEN_BUDGET:-200000}
estimated=$(gh pr diff --name-only | wc -l | awk -v b="$TOKEN_BUDGET" '{ print int(b / NR) }')
if [ "$estimated" -lt 5000 ]; then
  echo "::warning::PR has too many files for budget $TOKEN_BUDGET; consider splitting"
  exit 0
fi

# Sync API. Pre-merge blocking review (latency matters)
# (this is what the per-file-review.sh script above uses)

# Batch API. Overnight audit job (latency doesn't matter, cost does)
import anthropic, json

client = anthropic.Anthropic()

# Build a batch from yesterday's merged PRs
requests = []
for pr in get_merged_prs(since="24h"):
    for f in pr.changed_files:
        requests.append({
            "custom_id": f"audit-{pr.number}-{f.path}",
            "params": {
                "model": "claude-sonnet-4.5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": f.diff}],
            },
        })

batch = client.messages.batches.create(requests=requests)
print(f"Submitted batch {batch.id}; will be ready in ~24h")
# Tomorrow morning, fetch results, write to a Slack #audit-drift channel.

# .claude/hooks/ci_cost_guard.py
import sys, json, subprocess

MAX_TOKENS_PER_PR = 200_000

def main():
    payload = json.loads(sys.stdin.read())
    if payload["tool_name"] != "claude_review_pr":
        sys.exit(0)
    diff = subprocess.check_output(["gh", "pr", "diff"], text=True)
    estimated = len(diff) // 4  # ~4 chars per token rule of thumb
    if estimated > MAX_TOKENS_PER_PR:
        print(
            f"PR exceeds token budget: ~{estimated} tokens > "
            f"{MAX_TOKENS_PER_PR}. Split the PR or raise the limit "
            f"deliberately.",
            file=sys.stderr,
        )
        sys.exit(2)  # DENY
    sys.exit(0)