AI를 활용한 코드 리뷰 자동화 가이드

코드 리뷰는 소프트웨어 품질을 보장하는 핵심 프로세스입니다. 하지만 시간이 많이 소요되고, 일관성을 유지하기 어려우며, 리뷰어의 역량에 따라 품질이 달라집니다. AI를 활용하면 기본적인 코드 품질 검사부터 복잡한 로직 분석까지 자동화하여 개발자가 더 중요한 아키텍처 결정에 집중할 수 있습니다.

1. AI 코드 리뷰 시스템 개요

1.1 시스템 아키텍처

Pull Request 생성
    ↓
GitHub Actions 트리거
    ↓
변경된 코드 추출
    ↓
AI 분석 (GPT-4/Claude)
    ↓
리뷰 코멘트 자동 생성
    ↓
PR에 자동 코멘트

1.2 AI가 검토할 항목

• 코드 품질: 가독성, 복잡도, 네이밍 컨벤션
• 보안 취약점: SQL 인젝션, XSS, 민감 정보 노출
• 성능 이슈: 비효율적 알고리즘, 메모리 누수
• 버그 패턴: 잠재적 에러, 엣지 케이스 미처리
• 베스트 프랙티스: 언어별 관례, 디자인 패턴
• 테스트 커버리지: 누락된 테스트 케이스

1.3 기존 도구와의 비교

도구	장점	한계
ESLint/Prettier	빠름, 일관성	규칙 기반, 컨텍스트 이해 불가
SonarQube	상세한 분석, 메트릭	설정 복잡, 오탐 많음
AI 리뷰	컨텍스트 이해, 자연어 피드백	API 비용, 가끔 부정확

2. 환경 설정

2.1 필요한 것들

• GitHub 계정 및 레포지토리
• OpenAI API 키 또는 Anthropic API 키
• Node.js 18+ 또는 Python 3.9+
• GitHub Actions 사용 권한

2.2 API 키 발급

OpenAI API 키:

1. platform.openai.com 접속
2. API Keys 메뉴에서 새 키 생성
3. 안전한 곳에 저장

Anthropic API 키:

1. console.anthropic.com 접속
2. API Keys에서 키 생성
3. 안전한 곳에 저장

2.3 GitHub Secrets 설정

레포지토리 Settings > Secrets and variables > Actions

• OPENAI_API_KEY: OpenAI API 키
• ANTHROPIC_API_KEY: Anthropic API 키 (선택)
• GITHUB_TOKEN: 자동 제공됨

3. Python 기반 AI 리뷰어 구현

3.1 프로젝트 구조

.github/
  workflows/
    ai-review.yml
scripts/
  ai_reviewer.py
  review_prompt.py
  github_client.py
requirements.txt
README.md

3.2 의존성 설정

requirements.txt:

openai>=1.0.0
anthropic>=0.18.0
PyGithub>=2.1.1
python-dotenv>=1.0.0

3.3 AI 리뷰어 핵심 로직

scripts/ai_reviewer.py:

import os
from typing import List, Dict
from openai import OpenAI
from anthropic import Anthropic

class AIReviewer:
    def __init__(self, provider: str = "openai"):
        """
        AI 리뷰어 초기화

        Args:
            provider: "openai" 또는 "anthropic"
        """
        self.provider = provider

        if provider == "openai":
            self.client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
            self.model = "gpt-4-turbo-preview"
        else:
            self.client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
            self.model = "claude-3-5-sonnet-20241022"

    def review_code(
        self,
        file_path: str,
        old_code: str,
        new_code: str,
        diff: str
    ) -> Dict:
        """
        코드 변경사항을 분석하고 리뷰를 생성합니다.

        Args:
            file_path: 파일 경로
            old_code: 변경 전 코드
            new_code: 변경 후 코드
            diff: Git diff

        Returns:
            리뷰 결과 딕셔너리
        """
        prompt = self._create_review_prompt(file_path, old_code, new_code, diff)

        if self.provider == "openai":
            return self._review_with_openai(prompt)
        else:
            return self._review_with_anthropic(prompt)

    def _create_review_prompt(
        self,
        file_path: str,
        old_code: str,
        new_code: str,
        diff: str
    ) -> str:
        """리뷰 프롬프트 생성"""
        return f"""당신은 경험 많은 시니어 개발자입니다. 다음 코드 변경사항을 리뷰해주세요.

파일: {file_path}

변경 사항 (Git Diff):
```
{diff}
```

전체 변경 후 코드:
```
{new_code}
```

다음 관점에서 리뷰해주세요:
1. **코드 품질**: 가독성, 유지보수성, 네이밍
2. **보안**: 잠재적 보안 취약점
3. **성능**: 비효율적인 코드 패턴
4. **버그**: 잠재적 에러나 엣지 케이스
5. **베스트 프랙티스**: 언어별 관례 및 패턴
6. **테스트**: 추가 필요한 테스트

응답 형식 (JSON):
{{
  "summary": "전체 요약 (2-3 문장)",
  "severity": "critical|major|minor|info",
  "issues": [
    {{
      "type": "security|performance|bug|style|test",
      "severity": "critical|major|minor|info",
      "line": 줄 번호,
      "message": "구체적인 피드백",
      "suggestion": "개선 제안 (옵션)"
    }}
  ],
  "positive_points": ["잘한 점들"],
  "overall_score": 0-10 점수
}}

중요: 실제 문제가 있을 때만 지적하고, 사소한 스타일 이슈는 무시하세요."""

    def _review_with_openai(self, prompt: str) -> Dict:
        """OpenAI로 리뷰"""
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {
                        "role": "system",
                        "content": "You are an expert code reviewer."
                    },
                    {
                        "role": "user",
                        "content": prompt
                    }
                ],
                temperature=0.3,
                response_format={ "type": "json_object" }
            )

            import json
            return json.loads(response.choices[0].message.content)
        except Exception as e:
            print(f"OpenAI API error: {e}")
            return self._get_error_response(str(e))

    def _review_with_anthropic(self, prompt: str) -> Dict:
        """Anthropic Claude로 리뷰"""
        try:
            message = self.client.messages.create(
                model=self.model,
                max_tokens=4096,
                messages=[
                    {
                        "role": "user",
                        "content": prompt
                    }
                ],
                temperature=0.3
            )

            import json
            return json.loads(message.content[0].text)
        except Exception as e:
            print(f"Anthropic API error: {e}")
            return self._get_error_response(str(e))

    def _get_error_response(self, error_msg: str) -> Dict:
        """에러 응답 생성"""
        return {
            "summary": f"리뷰 중 오류 발생: {error_msg}",
            "severity": "info",
            "issues": [],
            "positive_points": [],
            "overall_score": 0
        }

    def format_review_comment(self, review: Dict, file_path: str) -> str:
        """
        리뷰 결과를 GitHub 코멘트 형식으로 변환
        """
        severity_emoji = {
            "critical": "🚨",
            "major": "⚠️",
            "minor": "💡",
            "info": "ℹ️"
        }

        type_emoji = {
            "security": "🔒",
            "performance": "⚡",
            "bug": "🐛",
            "style": "🎨",
            "test": "🧪"
        }

        comment = f"## {severity_emoji.get(review['severity'], '📝')} AI Code Review: `{file_path}`\n\n"
        comment += f"**Overall Score**: {review['overall_score']}/10\n\n"
        comment += f"### Summary\n{review['summary']}\n\n"

        if review.get('issues'):
            comment += "### Issues Found\n\n"
            for issue in review['issues']:
                emoji = type_emoji.get(issue['type'], '•')
                sev = severity_emoji.get(issue['severity'], '•')
                comment += f"{emoji} {sev} **{issue['type'].upper()}** "
                if issue.get('line'):
                    comment += f"(Line {issue['line']})\n"
                else:
                    comment += "\n"
                comment += f"   {issue['message']}\n"
                if issue.get('suggestion'):
                    comment += f"   💡 *Suggestion: {issue['suggestion']}*\n"
                comment += "\n"

        if review.get('positive_points'):
            comment += "### ✅ Positive Points\n\n"
            for point in review['positive_points']:
                comment += f"- {point}\n"
            comment += "\n"

        comment += "---\n"
        comment += "*🤖 This review was automatically generated by AI. "
        comment += "Please use your judgment when addressing these suggestions.*"

        return comment

3.4 GitHub API 클라이언트

scripts/github_client.py:

import os
from github import Github
from typing import List, Dict

class GitHubClient:
    def __init__(self):
        self.token = os.environ.get("GITHUB_TOKEN")
        self.client = Github(self.token)

    def get_pr_files(self, repo_name: str, pr_number: int) -> List[Dict]:
        """
        PR의 변경된 파일 목록과 내용을 가져옵니다.
        """
        repo = self.client.get_repo(repo_name)
        pr = repo.get_pull(pr_number)

        files_data = []
        for file in pr.get_files():
            # 리뷰 대상 파일만 (바이너리, 생성된 파일 제외)
            if self._should_review_file(file.filename):
                files_data.append({
                    "filename": file.filename,
                    "status": file.status,
                    "additions": file.additions,
                    "deletions": file.deletions,
                    "patch": file.patch if hasattr(file, 'patch') else None,
                    "previous_content": self._get_file_content(
                        repo, file.filename, pr.base.sha
                    ),
                    "new_content": self._get_file_content(
                        repo, file.filename, pr.head.sha
                    )
                })

        return files_data

    def _should_review_file(self, filename: str) -> bool:
        """파일 리뷰 여부 결정"""
        # 리뷰에서 제외할 파일 패턴
        exclude_patterns = [
            'package-lock.json',
            'yarn.lock',
            'pnpm-lock.yaml',
            '.min.js',
            '.min.css',
            '.map',
            'dist/',
            'build/',
            'node_modules/',
            '.png',
            '.jpg',
            '.jpeg',
            '.gif',
            '.svg'
        ]

        return not any(pattern in filename for pattern in exclude_patterns)

    def _get_file_content(self, repo, filename: str, sha: str) -> str:
        """특정 커밋의 파일 내용 가져오기"""
        try:
            content = repo.get_contents(filename, ref=sha)
            return content.decoded_content.decode('utf-8')
        except:
            return ""

    def post_review_comment(
        self,
        repo_name: str,
        pr_number: int,
        comment: str
    ):
        """PR에 리뷰 코멘트 작성"""
        repo = self.client.get_repo(repo_name)
        pr = repo.get_pull(pr_number)
        pr.create_issue_comment(comment)

    def post_review(
        self,
        repo_name: str,
        pr_number: int,
        comments: List[Dict],
        event: str = "COMMENT"
    ):
        """
        PR에 리뷰 생성 (개별 라인 코멘트 포함)

        Args:
            event: "APPROVE", "REQUEST_CHANGES", "COMMENT"
        """
        repo = self.client.get_repo(repo_name)
        pr = repo.get_pull(pr_number)

        # 코멘트 형식 변환
        review_comments = []
        for comment in comments:
            if comment.get('line') and comment.get('path'):
                review_comments.append({
                    "path": comment['path'],
                    "line": comment['line'],
                    "body": comment['body']
                })

        if review_comments:
            pr.create_review(
                body="AI Code Review completed. See comments below.",
                event=event,
                comments=review_comments
            )

3.5 메인 스크립트

scripts/main.py:

#!/usr/bin/env python3
import os
import sys
from ai_reviewer import AIReviewer
from github_client import GitHubClient

def main():
    # 환경 변수에서 정보 가져오기
    repo_name = os.environ.get("GITHUB_REPOSITORY")
    pr_number = int(os.environ.get("PR_NUMBER", 0))

    if not repo_name or not pr_number:
        print("Error: GITHUB_REPOSITORY or PR_NUMBER not set")
        sys.exit(1)

    print(f"Reviewing PR #{pr_number} in {repo_name}")

    # 클라이언트 초기화
    github = GitHubClient()
    reviewer = AIReviewer(provider="openai")  # 또는 "anthropic"

    # PR 파일 가져오기
    files = github.get_pr_files(repo_name, pr_number)
    print(f"Found {len(files)} files to review")

    # 각 파일 리뷰
    all_reviews = []
    for file_data in files:
        print(f"Reviewing {file_data['filename']}...")

        if not file_data['patch']:
            print(f"  Skipping (no diff)")
            continue

        review = reviewer.review_code(
            file_path=file_data['filename'],
            old_code=file_data['previous_content'],
            new_code=file_data['new_content'],
            diff=file_data['patch']
        )

        # 심각한 이슈가 있는 경우만 코멘트
        if review.get('issues') or review.get('overall_score', 10) < 7:
            comment = reviewer.format_review_comment(
                review, file_data['filename']
            )
            all_reviews.append(comment)

    # 리뷰 결과 포스팅
    if all_reviews:
        print(f"Posting {len(all_reviews)} review comments")
        for comment in all_reviews:
            github.post_review_comment(repo_name, pr_number, comment)
        print("✅ Review completed!")
    else:
        print("✅ No issues found. Code looks good!")
        github.post_review_comment(
            repo_name,
            pr_number,
            "## ✅ AI Code Review\n\n"
            "No significant issues found. Great work! 🎉\n\n"
            "*🤖 This review was automatically generated by AI.*"
        )

if __name__ == "__main__":
    main()

4. GitHub Actions 워크플로우

4.1 기본 워크플로우

.github/workflows/ai-review.yml:

name: AI Code Review

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

jobs:
  ai-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # 전체 히스토리 가져오기

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt

      - name: Run AI Code Review
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          GITHUB_REPOSITORY: ${{ github.repository }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
        run: |
          python scripts/main.py

      - name: Comment on PR
        if: failure()
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: '❌ AI Code Review failed. Please check the logs.'
            })

4.2 조건부 실행 워크플로우

특정 파일이 변경되었을 때만 실행:

on:
  pull_request:
    types: [opened, synchronize]
    paths:
      - 'src/**'
      - 'lib/**'
      - '**.ts'
      - '**.tsx'
      - '**.js'
      - '**.jsx'
      - '**.py'

5. TypeScript/Node.js 버전

5.1 프로젝트 설정

package.json:

{
  "name": "ai-code-reviewer",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "review": "tsx src/main.ts"
  },
  "dependencies": {
    "@anthropic-ai/sdk": "^0.18.0",
    "@octokit/rest": "^20.0.0",
    "openai": "^4.0.0",
    "dotenv": "^16.0.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "tsx": "^4.0.0",
    "typescript": "^5.0.0"
  }
}

5.2 AI 리뷰어 구현

src/ai-reviewer.ts:

import OpenAI from 'openai';
import Anthropic from '@anthropic-ai/sdk';

interface ReviewResult {
  summary: string;
  severity: 'critical' | 'major' | 'minor' | 'info';
  issues: Array<{
    type: 'security' | 'performance' | 'bug' | 'style' | 'test';
    severity: 'critical' | 'major' | 'minor' | 'info';
    line?: number;
    message: string;
    suggestion?: string;
  }>;
  positive_points: string[];
  overall_score: number;
}

export class AIReviewer {
  private openai?: OpenAI;
  private anthropic?: Anthropic;
  private provider: 'openai' | 'anthropic';

  constructor(provider: 'openai' | 'anthropic' = 'openai') {
    this.provider = provider;

    if (provider === 'openai') {
      this.openai = new OpenAI({
        apiKey: process.env.OPENAI_API_KEY,
      });
    } else {
      this.anthropic = new Anthropic({
        apiKey: process.env.ANTHROPIC_API_KEY,
      });
    }
  }

  async reviewCode(
    filePath: string,
    oldCode: string,
    newCode: string,
    diff: string
  ): Promise {
    const prompt = this.createReviewPrompt(filePath, oldCode, newCode, diff);

    if (this.provider === 'openai') {
      return this.reviewWithOpenAI(prompt);
    } else {
      return this.reviewWithAnthropic(prompt);
    }
  }

  private createReviewPrompt(
    filePath: string,
    oldCode: string,
    newCode: string,
    diff: string
  ): string {
    return `당신은 경험 많은 시니어 개발자입니다. 다음 코드 변경사항을 리뷰해주세요.

파일: ${filePath}

변경 사항:
\`\`\`
${diff}
\`\`\`

다음 관점에서 리뷰하고 JSON 형식으로 응답해주세요:
- 코드 품질 (가독성, 유지보수성)
- 보안 취약점
- 성능 이슈
- 잠재적 버그
- 베스트 프랙티스
- 테스트 필요성

중요한 이슈만 지적하세요.`;
  }

  private async reviewWithOpenAI(prompt: string): Promise {
    try {
      const response = await this.openai!.chat.completions.create({
        model: 'gpt-4-turbo-preview',
        messages: [
          { role: 'system', content: 'You are an expert code reviewer.' },
          { role: 'user', content: prompt },
        ],
        temperature: 0.3,
        response_format: { type: 'json_object' },
      });

      return JSON.parse(response.choices[0].message.content!);
    } catch (error) {
      console.error('OpenAI API error:', error);
      throw error;
    }
  }

  private async reviewWithAnthropic(prompt: string): Promise {
    try {
      const message = await this.anthropic!.messages.create({
        model: 'claude-3-5-sonnet-20241022',
        max_tokens: 4096,
        messages: [{ role: 'user', content: prompt }],
        temperature: 0.3,
      });

      const content = message.content[0];
      if (content.type === 'text') {
        return JSON.parse(content.text);
      }

      throw new Error('Unexpected response format');
    } catch (error) {
      console.error('Anthropic API error:', error);
      throw error;
    }
  }

  formatReviewComment(review: ReviewResult, filePath: string): string {
    const severityEmoji = {
      critical: '🚨',
      major: '⚠️',
      minor: '💡',
      info: 'ℹ️',
    };

    let comment = `## ${severityEmoji[review.severity]} AI Code Review: \`${filePath}\`\n\n`;
    comment += `**Overall Score**: ${review.overall_score}/10\n\n`;
    comment += `### Summary\n${review.summary}\n\n`;

    if (review.issues.length > 0) {
      comment += '### Issues Found\n\n';
      review.issues.forEach((issue) => {
        comment += `- ${severityEmoji[issue.severity]} **${issue.type.toUpperCase()}**`;
        if (issue.line) comment += ` (Line ${issue.line})`;
        comment += `\n  ${issue.message}\n`;
        if (issue.suggestion) {
          comment += `  💡 *Suggestion: ${issue.suggestion}*\n`;
        }
      });
    }

    if (review.positive_points.length > 0) {
      comment += '\n### ✅ Positive Points\n';
      review.positive_points.forEach((point) => {
        comment += `- ${point}\n`;
      });
    }

    comment += '\n---\n*🤖 This review was automatically generated by AI.*';

    return comment;
  }
}

6. 고급 기능 추가

6.1 코드베이스 컨텍스트 인식

관련 파일들을 분석에 포함시켜 더 정확한 리뷰 제공:

async function getRelatedFiles(
  repo: Repository,
  changedFile: string
): Promise {
  const relatedFiles: string[] = [];

  // import 문 분석
  const content = await getFileContent(repo, changedFile);
  const importRegex = /import.*from ['"](.*)['"];/g;
  let match;

  while ((match = importRegex.exec(content)) !== null) {
    const importPath = match[1];
    // 상대 경로를 절대 경로로 변환
    const absolutePath = resolvePath(changedFile, importPath);
    relatedFiles.push(absolutePath);
  }

  return relatedFiles;
}

6.2 점진적 리뷰 (대규모 PR)

변경 사항이 많을 때 청크로 나누어 리뷰:

async function reviewLargePR(
  files: FileChange[],
  maxFilesPerBatch: number = 5
): Promise {
  const results: ReviewResult[] = [];

  for (let i = 0; i < files.length; i += maxFilesPerBatch) {
    const batch = files.slice(i, i + maxFilesPerBatch);
    const batchResults = await Promise.all(
      batch.map(file => reviewer.reviewCode(
        file.filename,
        file.oldContent,
        file.newContent,
        file.diff
      ))
    );
    results.push(...batchResults);

    // Rate limit 방지를 위한 딜레이
    if (i + maxFilesPerBatch < files.length) {
      await sleep(2000);
    }
  }

  return results;
}

6.3 커스텀 체크리스트

프로젝트별 체크리스트 추가:

// .ai-review-config.json
{
  "checklist": [
    "TypeScript 타입이 제대로 정의되었는가?",
    "에러 핸들링이 구현되었는가?",
    "보안 취약점(SQL injection, XSS 등)이 없는가?",
    "성능에 영향을 줄 수 있는 코드가 있는가?",
    "테스트가 추가되었는가?",
    "문서화가 필요한가?"
  ],
  "severity_threshold": "major",
  "auto_approve_score": 9
}

7. 실전 팁과 모범 사례

7.1 효과적인 프롬프트 작성

• 구체적인 컨텍스트 제공: 프로젝트 성격, 사용 기술 스택 명시
• 우선순위 설정: 보안 > 버그 > 성능 > 스타일
• 출력 형식 명확히: JSON 스키마 제공
• 예시 포함: 원하는 리뷰 스타일의 예시 제공

7.2 비용 최적화

• 작은 파일 변경은 로컬 린터로만 검사
• 대규모 PR은 청크로 나누어 처리
• 캐싱 활용 (동일 파일 재리뷰 방지)
• 저렴한 모델 우선 사용 (GPT-3.5, Claude Haiku)

7.3 False Positive 줄이기

// 신뢰도 점수 추가
interface ReviewIssue {
  // ... 기존 필드
  confidence: number; // 0-1
}

// 낮은 신뢰도 이슈 필터링
const significantIssues = review.issues.filter(
  issue => issue.confidence > 0.7 && issue.severity !== 'info'
);

7.4 팀 컨벤션 학습

과거 리뷰 데이터를 프롬프트에 포함:

const teamConventions = `
우리 팀의 코드 컨벤션:
- 함수는 camelCase, 컴포넌트는 PascalCase
- async 함수는 반드시 try-catch 사용
- API 호출은 반드시 타임아웃 설정
- 모든 컴포넌트에 PropTypes 또는 TypeScript 타입 필수
`;

// 프롬프트에 추가
prompt += `\n\n팀 컨벤션:\n${teamConventions}`;

8. 트러블슈팅

문제 1: API Rate Limit 초과

해결책:

• 재시도 로직에 지수 백오프 구현
• 큐 시스템 도입 (파일당 딜레이)
• 여러 API 키 로테이션

문제 2: 부정확한 리뷰

해결책:

• 프롬프트에 더 많은 컨텍스트 추가
• Few-shot learning 예시 포함
• Temperature 낮추기 (0.2-0.3)

문제 3: GitHub Actions 타임아웃

해결책:

• 대규모 PR은 병렬 처리
• 타임아웃 시간 증가 (timeout-minutes: 30)
• Self-hosted runner 사용

9. 보안 고려사항

9.1 민감 정보 보호

function sanitizeCode(code: string): string {
  // API 키, 비밀번호 등 제거
  return code
    .replace(/api[_-]?key['"]\s*[:=]\s*['"][^'"]+['"]/gi, 'API_KEY=***')
    .replace(/password['"]\s*[:=]\s*['"][^'"]+['"]/gi, 'PASSWORD=***')
    .replace(/secret['"]\s*[:=]\s*['"][^'"]+['"]/gi, 'SECRET=***');
}

9.2 프라이빗 레포지토리

코드가 외부 API로 전송되므로:

• 회사 정책 확인
• 필요시 자체 호스팅 LLM 사용 고려
• 민감한 파일은 리뷰에서 제외

10. 측정 가능한 개선

10.1 메트릭 추적

// 리뷰 통계 수집
interface ReviewMetrics {
  totalReviews: number;
  issuesFound: number;
  falsePositives: number;
  averageScore: number;
  timeSaved: number; // 시간 (분)
}

// 매주 리포트 생성
async function generateWeeklyReport(): Promise {
  const metrics = await collectMetrics();

  const report = `
## 📊 AI Code Review Weekly Report

- **Total Reviews**: ${metrics.totalReviews}
- **Issues Found**: ${metrics.issuesFound}
- **Average Code Score**: ${metrics.averageScore.toFixed(1)}/10
- **Estimated Time Saved**: ${metrics.timeSaved} hours

Top Issue Categories:
${getTopIssueCategories(metrics)}
  `;

  await postToSlack(report);
}

"AI 코드 리뷰는 인간 리뷰어를 대체하는 것이 아니라, 보완하는 도구입니다. 기계적인 검사는 AI가 하고, 아키텍처와 비즈니스 로직은 인간이 집중하세요."

마치며

AI 코드 리뷰 자동화는 개발팀의 생산성을 크게 향상시킬 수 있습니다. 처음에는 작은 프로젝트에 적용해보고, 팀의 피드백을 반영하여 점진적으로 개선해 나가세요. AI는 도구일 뿐, 최종 판단은 항상 개발자의 몫입니다.

참고 자료

• GitHub Actions Documentation - 공식 문서
• GitHub Pull Requests API - PR API 문서
• OpenAI Code Guide - 코드 분석 가이드
• Anthropic Prompt Engineering - 프롬프트 엔지니어링 리소스
• GitHub Actions Marketplace - 코드 리뷰 관련 액션들