AI 코드 리뷰와 품질 관리 전략: Amazon 사례로 보는 AI-Assisted 개발 가이드라인

# AI가 생성한 코드: 일반적인 경우는 잘 동작
def calculate_discount(price, discount_percent):
    return price * (1 - discount_percent / 100)

# 문제: 엣지 케이스 미처리
# - discount_percent가 100 이상인 경우 (음수 가격)
# - price가 음수인 경우
# - discount_percent가 None/NaN인 경우

# 시니어 엔지니어가 보완한 코드
def calculate_discount(price, discount_percent):
    if price is None or price < 0:
        raise ValueError(f"Invalid price: {price}")
    if discount_percent is None or not (0 <= discount_percent <= 100):
        raise ValueError(f"Invalid discount: {discount_percent}")
    return round(price * (1 - discount_percent / 100), 2)

// AI가 생성한 코드: SQL 인젝션 취약
public List<User> findUsers(String name) {
    String sql = "SELECT * FROM users WHERE name = '" + name + "'";
    return jdbcTemplate.query(sql, new UserRowMapper());
}

// 시니어 리뷰 후 수정: Prepared Statement 사용
public List<User> findUsers(String name) {
    String sql = "SELECT * FROM users WHERE name = ?";
    return jdbcTemplate.query(sql, new UserRowMapper(), name);
}

// AI가 생성한 코드: N+1 쿼리 문제
async function getOrdersWithProducts(userId) {
  const orders = await db.orders.findMany({ where: { userId } })
  for (const order of orders) {
    order.products = await db.products.findMany({
      where: { orderId: order.id },
    })
  }
  return orders
}

// 최적화된 코드: JOIN 또는 include 사용
async function getOrdersWithProducts(userId) {
  return db.orders.findMany({
    where: { userId },
    include: { products: true },
  })
}

# .amazon/ai-review-policy.yaml (예시 구조)
ai_code_review:
  enabled: true
  detection:
    # AI 생성 코드 자동 감지
    copilot_telemetry: true
    codewhisperer_metadata: true
    commit_message_pattern: 'ai-assisted|copilot|codewhisperer'
  approval_rules:
    junior_mid:
      required_approvers:
        min_level: L6
        count: 1
      test_coverage_threshold: 90
      mandatory_checklist: true
    senior:
      required_approvers:
        min_level: L6
        count: 1 # self-review allowed
      test_coverage_threshold: 85
      mandatory_checklist: true
  notifications:
    slack_channel: '#ai-code-review'
    escalation_timeout: 24h

## AI 코드 리뷰 체크리스트

### 1. 기능 정확성

- [ ] 비즈니스 요구사항과 정확히 일치하는가
- [ ] 엣지 케이스가 모두 처리되었는가 (null, empty, boundary)
- [ ] 에러 핸들링이 적절한가 (예외 유형, 복구 전략)
- [ ] 동시성 이슈가 고려되었는가 (race condition, deadlock)

### 2. 보안

- [ ] 입력 검증이 충분한가 (injection, XSS)
- [ ] 인증/인가 로직이 올바른가
- [ ] 민감 데이터가 적절히 처리되는가 (logging, masking)
- [ ] 암호화/해싱이 올바르게 구현되었는가

### 3. 성능

- [ ] N+1 쿼리 문제가 없는가
- [ ] 불필요한 메모리 할당이 없는가
- [ ] 캐싱 전략이 적절한가
- [ ] 인덱스 사용이 최적화되었는가

### 4. 유지보수성

- [ ] 프로젝트 코딩 컨벤션을 따르는가
- [ ] 의존성이 적절한가 (불필요한 라이브러리 추가 없음)
- [ ] 테스트가 충분한가 (단위, 통합, E2E)
- [ ] 문서화가 필요한 부분이 있는가

### 5. AI 특화 검증

- [ ] AI가 환각한 API/라이브러리가 없는가
- [ ] deprecated된 패턴이 사용되지 않았는가
- [ ] 라이선스 문제가 없는가 (GPL 코드 복사 등)
- [ ] AI가 삽입한 불필요한 코드가 없는가

# .github/workflows/ai-code-review.yml
name: AI Code Review Pipeline

on:
  pull_request:
    types: [opened, synchronize, reopened]

permissions:
  contents: read
  pull-requests: write

jobs:
  detect-ai-code:
    runs-on: ubuntu-latest
    outputs:
      is_ai_assisted: ${{ steps.detect.outputs.ai_assisted }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Detect AI-assisted changes
        id: detect
        run: |
          # AI 도구 메타데이터 확인
          AI_MARKERS=$(git log --format="%B" origin/main..HEAD | \
            grep -ciE "copilot|codewhisperer|cursor|ai-assisted" || true)

          if [ "$AI_MARKERS" -gt 0 ]; then
            echo "ai_assisted=true" >> "$GITHUB_OUTPUT"
          else
            echo "ai_assisted=false" >> "$GITHUB_OUTPUT"
          fi

  static-analysis:
    runs-on: ubuntu-latest
    needs: detect-ai-code
    steps:
      - uses: actions/checkout@v4

      - name: Run ESLint with AI-specific rules
        run: npx eslint . --config .eslintrc.ai.json --format json > eslint-report.json

      - name: Run Semgrep security scan
        uses: returntocorp/semgrep-action@v1
        with:
          config: >-
            p/owasp-top-ten
            p/javascript
            p/typescript

      - name: Upload analysis results
        uses: actions/upload-artifact@v4
        with:
          name: static-analysis
          path: |
            eslint-report.json
            semgrep-results.json

  llm-review:
    runs-on: ubuntu-latest
    needs: [detect-ai-code, static-analysis]
    if: needs.detect-ai-code.outputs.is_ai_assisted == 'true'
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Run CodeRabbit review
        uses: coderabbit-ai/coderabbit-action@v2
        with:
          token: ${{ secrets.CODERABBIT_TOKEN }}
          review_level: comprehensive

      - name: Run custom LLM review
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: |
          python scripts/ai_review.py \
            --diff "$(git diff origin/main...HEAD)" \
            --checklist .github/ai-review-checklist.md \
            --output review-comments.json

  coverage-gate:
    runs-on: ubuntu-latest
    needs: detect-ai-code
    if: needs.detect-ai-code.outputs.is_ai_assisted == 'true'
    steps:
      - uses: actions/checkout@v4

      - name: Run tests with coverage
        run: |
          npm ci
          npm run test:coverage -- --reporter=json > coverage.json

      - name: Check AI code coverage threshold
        run: |
          COVERAGE=$(jq '.total.lines.pct' coverage.json)
          THRESHOLD=90
          echo "Coverage: ${COVERAGE}%, Threshold: ${THRESHOLD}%"
          if (( $(echo "$COVERAGE < $THRESHOLD" | bc -l) )); then
            echo "FAIL: AI-assisted code coverage ${COVERAGE}% < ${THRESHOLD}%"
            exit 1
          fi

  senior-approval:
    runs-on: ubuntu-latest
    needs: [llm-review, coverage-gate]
    if: needs.detect-ai-code.outputs.is_ai_assisted == 'true'
    steps:
      - name: Require senior approval
        uses: actions/github-script@v7
        with:
          script: |
            const reviews = await github.rest.pulls.listReviews({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.issue.number,
            });

            const seniorTeamMembers = ['senior-eng-1', 'senior-eng-2', 'tech-lead'];
            const seniorApproval = reviews.data.some(
              review => review.state === 'APPROVED' &&
                        seniorTeamMembers.includes(review.user.login)
            );

            if (!seniorApproval) {
              core.setFailed('AI-assisted code requires senior engineer approval');
            }

#!/usr/bin/env python3
"""AI 코드 리뷰 자동화 스크립트"""

import json
import sys
from dataclasses import dataclass
from openai import OpenAI


@dataclass
class ReviewComment:
    file: str
    line: int
    severity: str  # critical, warning, info
    category: str  # security, performance, correctness, style
    message: str
    suggestion: str


REVIEW_PROMPT = """당신은 시니어 소프트웨어 엔지니어입니다.
다음 코드 변경사항을 리뷰해주세요. 특히 AI가 생성한 코드에서 자주 발생하는 문제에 집중하세요:

1. 엣지 케이스 누락
2. 보안 취약점 (SQL injection, XSS, SSRF 등)
3. 성능 안티패턴 (N+1, 불필요한 할당 등)
4. 동시성 이슈 (race condition, deadlock)
5. 환각 코드 (존재하지 않는 API 호출)
6. 에러 핸들링 미흡

리뷰 결과를 JSON 형식으로 반환하세요.
"""


def review_diff(diff_content: str, checklist_path: str) -> list[ReviewComment]:
    client = OpenAI()

    with open(checklist_path) as f:
        checklist = f.read()

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": REVIEW_PROMPT},
            {"role": "user", "content": f"체크리스트:\n{checklist}\n\n코드 변경:\n{diff_content}"},
        ],
        response_format={"type": "json_object"},
        temperature=0.1,
    )

    result = json.loads(response.choices[0].message.content)
    return [ReviewComment(**comment) for comment in result.get("comments", [])]


def main():
    import argparse

    parser = argparse.ArgumentParser()
    parser.add_argument("--diff", required=True)
    parser.add_argument("--checklist", required=True)
    parser.add_argument("--output", required=True)
    args = parser.parse_args()

    comments = review_diff(args.diff, args.checklist)

    critical_count = sum(1 for c in comments if c.severity == "critical")

    with open(args.output, "w") as f:
        json.dump([vars(c) for c in comments], f, indent=2, ensure_ascii=False)

    print(f"리뷰 완료: {len(comments)}개 코멘트 ({critical_count}개 critical)")

    if critical_count > 0:
        print("CRITICAL 이슈가 발견되었습니다. 시니어 리뷰가 필요합니다.")
        sys.exit(1)


if __name__ == "__main__":
    main()

"""시맨틱 디프 분석 예시 (Python AST 기반)"""

import ast
import difflib
from dataclasses import dataclass


@dataclass
class SemanticChange:
    change_type: str  # added, removed, modified, moved
    entity_type: str  # function, class, variable, import
    name: str
    risk_level: str   # low, medium, high
    description: str


def analyze_semantic_diff(old_source: str, new_source: str) -> list[SemanticChange]:
    old_tree = ast.parse(old_source)
    new_tree = ast.parse(new_source)

    old_functions = {
        node.name: ast.dump(node)
        for node in ast.walk(old_tree)
        if isinstance(node, ast.FunctionDef)
    }
    new_functions = {
        node.name: ast.dump(node)
        for node in ast.walk(new_tree)
        if isinstance(node, ast.FunctionDef)
    }

    changes = []

    # 새로 추가된 함수
    for name in set(new_functions) - set(old_functions):
        changes.append(SemanticChange(
            change_type="added",
            entity_type="function",
            name=name,
            risk_level="medium",
            description=f"새 함수 '{name}'이 추가됨 - AI 생성 코드 검증 필요",
        ))

    # 수정된 함수
    for name in set(old_functions) & set(new_functions):
        if old_functions[name] != new_functions[name]:
            changes.append(SemanticChange(
                change_type="modified",
                entity_type="function",
                name=name,
                risk_level="high",
                description=f"함수 '{name}'의 로직이 변경됨 - 엣지 케이스 검증 필요",
            ))

    # 삭제된 함수
    for name in set(old_functions) - set(new_functions):
        changes.append(SemanticChange(
            change_type="removed",
            entity_type="function",
            name=name,
            risk_level="high",
            description=f"함수 '{name}'이 삭제됨 - 의존성 확인 필요",
        ))

    return changes

# .github/workflows/quality-gates.yml
name: Multi-stage Quality Gates

on:
  pull_request:
    branches: [main, release/*]

jobs:
  # Gate 1: 기본 린트 및 타입 체크 (모든 코드)
  gate-1-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run lint
      - run: npm run typecheck

  # Gate 2: 테스트 커버리지 (AI 코드는 높은 임계값)
  gate-2-test:
    needs: gate-1-lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm run test:coverage
      - name: Enforce coverage thresholds
        run: |
          node -e "
            const report = require('./coverage/coverage-summary.json');
            const total = report.total;
            const threshold = process.env.AI_ASSISTED === 'true' ? 90 : 80;
            if (total.lines.pct < threshold) {
              console.error('Coverage ' + total.lines.pct + '% < ' + threshold + '%');
              process.exit(1);
            }
          "

  # Gate 3: 보안 스캔 (SAST + Dependency)
  gate-3-security:
    needs: gate-1-lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Semgrep SAST
        uses: returntocorp/semgrep-action@v1
        with:
          config: p/owasp-top-ten

      - name: Dependency audit
        run: npm audit --audit-level=high

      - name: Trivy filesystem scan
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: fs
          severity: CRITICAL,HIGH

  # Gate 4: AI-specific review (AI 코드만)
  gate-4-ai-review:
    needs: [gate-2-test, gate-3-security]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: AI hallucination check
        run: |
          python scripts/check_hallucinations.py \
            --diff "$(git diff origin/main...HEAD)" \
            --package-lock package-lock.json

      - name: Semantic diff analysis
        run: |
          python scripts/semantic_diff.py \
            --base origin/main \
            --head HEAD \
            --report semantic-diff-report.json

  # Gate 5: 시니어 승인 (AI 코드 + 핵심 서비스)
  gate-5-approval:
    needs: gate-4-ai-review
    runs-on: ubuntu-latest
    environment: production
    steps:
      - name: Verify senior approval
        uses: actions/github-script@v7
        with:
          script: |
            // 시니어 엔지니어 목록 (CODEOWNERS에서 관리)
            const response = await github.rest.pulls.listReviews({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.issue.number,
            });
            const approved = response.data.filter(r => r.state === 'APPROVED');
            if (approved.length === 0) {
              core.setFailed('Senior engineer approval required');
            }

"""AI 환각 코드 탐지: 존재하지 않는 패키지/API 호출 검출"""

import json
import re
import subprocess


def check_import_hallucinations(diff_content: str, package_lock_path: str) -> list[dict]:
    """새로 추가된 import가 실제 설치된 패키지에 존재하는지 확인"""
    issues = []

    # diff에서 새로 추가된 import 추출
    added_imports = re.findall(
        r"^\+.*(?:import|require)\s*\(?['\"]([^'\"]+)['\"]",
        diff_content,
        re.MULTILINE,
    )

    # package-lock.json에서 설치된 패키지 목록 추출
    with open(package_lock_path) as f:
        lock_data = json.load(f)

    installed = set(lock_data.get("packages", {}).keys())
    installed_names = set()
    for pkg in installed:
        # node_modules/package-name 형식에서 이름 추출
        name = pkg.replace("node_modules/", "")
        if name:
            installed_names.add(name)

    for imp in added_imports:
        # 스코프 패키지 및 서브패스 처리
        base_package = imp.split("/")[0]
        if imp.startswith("@"):
            base_package = "/".join(imp.split("/")[:2])

        # 상대 경로는 제외
        if base_package.startswith("."):
            continue

        # Node.js 내장 모듈은 제외
        builtin_modules = [
            "fs", "path", "os", "http", "https", "crypto",
            "stream", "url", "util", "events", "child_process",
            "buffer", "querystring", "assert", "net",
        ]
        if base_package in builtin_modules:
            continue

        if base_package not in installed_names:
            issues.append({
                "type": "hallucinated_import",
                "package": base_package,
                "severity": "critical",
                "message": f"패키지 '{base_package}'이(가) 설치되어 있지 않습니다. "
                           f"AI가 존재하지 않는 패키지를 참조했을 수 있습니다.",
            })

    return issues

# prometheus/ai-code-review-rules.yml
groups:
  - name: ai_code_review
    rules:
      - record: ai_code:defect_rate:ratio
        expr: |
          sum(rate(code_defects_total{source="ai_assisted"}[7d]))
          /
          sum(rate(code_changes_total{source="ai_assisted"}[7d]))

      - record: ai_code:review_turnaround:p95
        expr: |
          histogram_quantile(0.95,
            sum(rate(pr_review_duration_seconds_bucket{ai_assisted="true"}[7d]))
            by (le)
          )

      - alert: AICodeDefectRateHigh
        expr: ai_code:defect_rate:ratio > 0.05
        for: 7d
        labels:
          severity: warning
        annotations:
          summary: 'AI 생성 코드의 결함률이 5%를 초과했습니다'
          description: '최근 7일간 AI 코드 결함률: {{ $value | humanizePercentage }}'

      - alert: SeniorReviewBacklogHigh
        expr: ai_code:pending_senior_reviews > 10
        for: 2h
        labels:
          severity: warning
        annotations:
          summary: '시니어 리뷰 대기열이 10개를 초과했습니다'

{
  "dashboard": {
    "title": "AI Code Quality Dashboard",
    "panels": [
      {
        "title": "AI vs Manual Code Defect Rate (7d rolling)",
        "type": "timeseries",
        "targets": [
          {
            "expr": "ai_code:defect_rate:ratio",
            "legendFormat": "AI-assisted"
          },
          {
            "expr": "manual_code:defect_rate:ratio",
            "legendFormat": "Manual"
          }
        ]
      },
      {
        "title": "Review Turnaround Time (p95)",
        "type": "gauge",
        "targets": [
          {
            "expr": "ai_code:review_turnaround:p95 / 3600",
            "legendFormat": "Hours"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "thresholds": {
              "steps": [
                { "value": 0, "color": "green" },
                { "value": 4, "color": "yellow" },
                { "value": 8, "color": "red" }
              ]
            }
          }
        }
      },
      {
        "title": "Senior Review Queue Depth",
        "type": "stat",
        "targets": [
          {
            "expr": "ai_code:pending_senior_reviews"
          }
        ]
      }
    ]
  }
}

// AI가 생성한 취약한 코드
const decoded = jwt.verify(token, secret)

// 올바른 코드: 알고리즘 명시
const decoded = jwt.verify(token, secret, { algorithms: ['HS256'] })

Phase 1 (1-2주): 기반 구축
├── AI 코드 감지 메커니즘 도입
├── 기본 체크리스트 배포
└── 시니어 리뷰 프로세스 정의

Phase 2 (3-4주): 자동화
├── CI/CD 품질 게이트 구성
├── LLM 기반 리뷰 도구 통합
├── 커버리지 임계값 강제
└── 보안 스캔 파이프라인 구성

Phase 3 (5-8주): 최적화
├── 메트릭 대시보드 구축
├── False positive 튜닝
├── 시맨틱 디프 분석 고도화
└── 팀별 커스텀 규칙 설정

Phase 4 (9-12주): 성숙
├── DORA 메트릭과 연계
├── AI 코드 품질 리포트 자동화
├── 조직 전체 거버넌스 체계 확립
└── 타 팀 베스트 프랙티스 공유

#!/bin/bash
# AI 코드 인시던트 복구 런북

# 1. 즉시 롤백
echo "Step 1: 프로덕션 롤백 실행"
kubectl rollout undo deployment/affected-service -n production

# 2. 영향 범위 확인
echo "Step 2: 영향 범위 파악"
kubectl logs -l app=affected-service -n production --since=1h | \
  grep -c "ERROR"

# 3. AI 생성 코드 변경 이력 추적
echo "Step 3: AI 코드 변경 이력 확인"
git log --oneline --all --grep="ai-assisted" --since="7 days ago"

# 4. 해당 PR의 리뷰 이력 확인
echo "Step 4: 리뷰 이력 확인"
gh pr list --state merged --label "ai-assisted" --json number,title,mergedAt

# 5. 인시던트 타임라인 기록
echo "Step 5: 인시던트 타임라인 기록 시작"
cat <<'TEMPLATE'
## 인시던트 타임라인
- 감지 시각:
- 롤백 시각:
- 복구 확인 시각:
- 근본 원인:
- AI 도구:
- 리뷰 이력:
- 재발 방지 대책:
TEMPLATE