Claude.ai + MCP + Skills 통합 코드 리뷰 가이드

게시 2025/11/05 업데이트 2026/01/17

By BLUEBUG

44 분읽는 시간

📋 목차

개요: 세 가지 도구의 시너지
기술 스택 이해하기
통합 아키텍처
단계별 구축 가이드
실전 시나리오
고급 패턴
보안 및 거버넌스
트러블슈팅

개요: 세 가지 도구의 시너지

왜 통합이 필요한가?

각각의 도구는 고유한 강점이 있지만, 함께 사용할 때 진정한 힘이 발휘됩니다:

Claude.ai (인터페이스)
    ↓
    대화형 상호작용, 웹 접근성
    
MCP (데이터 연결)
    ↓
    Google Drive, Slack, GitHub, DB 등 외부 시스템 연결
    
Skills (전문 지식)
    ↓
    도메인별 전문성, 재사용 가능한 워크플로우

실제 사례

시나리오: PR 코드 리뷰 자동화

[MCP] GitHub에서 PR 데이터 가져오기
[Skills] 보안 리뷰 Skill로 취약점 체크
[Skills] 성능 리뷰 Skill로 병목 탐지
[MCP] Slack으로 리뷰 결과 전송
[Claude.ai] 사용자와 대화형으로 개선 논의

기술 스택 이해하기

1. Claude.ai

역할: 사용자 인터페이스 및 AI 엔진

특징:

웹/모바일 앱을 통한 접근
자연어 대화 인터페이스
프로젝트 기반 컨텍스트 관리
파일 업로드 및 다운로드

제한사항:

외부 시스템 직접 접근 불가 (MCP 필요)
전문 지식은 프롬프트나 Skills로 제공 필요

2. Model Context Protocol (MCP)

역할: 데이터 소스와 AI의 표준 연결 프로토콜

특징: MCP는 2024년 11월 Anthropic이 도입한 개방형 표준으로, AI 시스템이 외부 데이터 소스와 통합하는 방식을 표준화합니다

Google Drive, Slack, GitHub, Git, Postgres, Puppeteer 등을 위한 사전 구축된 MCP 서버 제공
양방향 통신 지원
stdio 및 HTTP(SSE) 전송 지원

장점:

단일 프로토콜로 데이터 소스와 연결, 파편화된 통합 대체
커뮤니티가 만든 수천 개의 MCP 서버 사용 가능
OpenAI와 Google DeepMind를 포함한 주요 AI 제공업체가 채택

제한사항:

많은 서버를 연결하면 도구 정의와 결과가 과도한 토큰을 소비하여 에이전트 효율성 감소
서버 개발 및 호스팅 필요

3. Claude Skills

역할: 재사용 가능한 전문 작업 패키지

특징:

지침, 스크립트, 리소스가 포함된 폴더
Claude가 작업과 관련이 있을 때만 로딩
YAML 프론트매터와 지침이 포함된 마크다운 파일

장점:

반복적인 프롬프트 엔지니어링 시간을 73% 줄임
컨텍스트 효율적 (관련 시에만 로드)
MCP보다 간단 - 마크다운과 약간의 YAML

제한사항:

코드 실행 환경 필요
Pro, Max, Team, Enterprise 사용자만 사용 가능

비교 표

특성	Claude.ai	MCP	Skills
목적	인터페이스	데이터 연결	전문 지식
복잡도	낮음	중간	낮음
설정	없음	서버 설정 필요	폴더 생성
재사용성	낮음	높음	높음
토큰 사용	변동	높을 수 있음	효율적
외부 시스템	불가	가능 (핵심)	제한적

통합 아키텍처

전체 흐름도

┌─────────────────────────────────────────────────────────┐
│                      사용자                              │
│                   (자연어 요청)                          │
└───────────────────────┬─────────────────────────────────┘
                        │
                        ↓
┌─────────────────────────────────────────────────────────┐
│                   Claude.ai                              │
│  ┌──────────────────────────────────────────────────┐   │
│  │  대화 관리, 프로젝트 컨텍스트, 사용자 경험       │   │
│  └──────────────────────────────────────────────────┘   │
└────────┬───────────────────────────────────┬────────────┘
         │                                   │
         │                                   │
    [Skills 호출]                       [MCP 호출]
         │                                   │
         ↓                                   ↓
┌─────────────────────┐           ┌──────────────────────┐
│   Skills 시스템      │           │    MCP 서버들         │
│                     │           │                      │
│  ┌───────────────┐  │           │  ┌────────────────┐  │
│  │ 보안 리뷰     │  │           │  │ GitHub MCP     │  │
│  │ Skill        │  │           │  │                │  │
│  └───────────────┘  │           │  └────────────────┘  │
│                     │           │                      │
│  ┌───────────────┐  │           │  ┌────────────────┐  │
│  │ 성능 리뷰     │  │           │  │ Slack MCP      │  │
│  │ Skill        │  │           │  │                │  │
│  └───────────────┘  │           │  └────────────────┘  │
│                     │           │                      │
│  ┌───────────────┐  │           │  ┌────────────────┐  │
│  │ Python 코드   │  │           │  │ PostgreSQL     │  │
│  │ 리뷰 Skill   │  │           │  │ MCP            │  │
│  └───────────────┘  │           │  └────────────────┘  │
└─────────────────────┘           └──────────────────────┘
         │                                   │
         │                                   │
         └───────────────┬───────────────────┘
                         │
                         ↓
               ┌──────────────────┐
               │  결과 통합 및     │
               │  사용자에게 반환  │
               └──────────────────┘

데이터 흐름

1. 사용자 요청
   "이번 주 PR들을 보안 중심으로 리뷰해줘"
   
2. Claude.ai가 요청 분석
   - 필요한 데이터: GitHub PR (MCP)
   - 필요한 전문성: 보안 리뷰 (Skill)
   
3. MCP로 데이터 수집
   GitHub MCP → 이번 주 PR 목록 가져오기
   
4. Skills로 분석
   보안 리뷰 Skill → 각 PR의 변경사항 검토
   
5. 결과 통합
   Claude.ai → 발견된 이슈 정리, 우선순위 지정
   
6. 선택적 액션
   Slack MCP → 팀에 알림 전송

단계별 구축 가이드

Phase 1: Claude.ai 설정

1.1 프로젝트 생성

Claude.ai 접속
새 프로젝트 생성: "Code Review Automation"
프로젝트 지침 설정:

프로젝트 지침 예시:

  
# Code Review Automation Project

## 목적
PR 코드 리뷰를 자동화하여 보안, 성능, 품질을 보장합니다.

## 사용 가능한 도구
- MCP: GitHub, Slack, PostgreSQL 연결
- Skills: 보안 리뷰, 성능 리뷰, Python 코드 리뷰

## 워크플로우
1. GitHub MCP로 PR 데이터 수집
2. 적절한 Skills로 코드 분석
3. 결과를 Slack으로 전송

## 우선순위
Critical > High > Medium > Low

1.2 필요한 문서 업로드

  
프로젝트에 업로드할 문서들:
- 코딩 스타일 가이드
- 보안 정책 문서
- 아키텍처 다이어그램
- 팀 컨벤션 문서

Phase 2: MCP 서버 설정

2.1 Claude Desktop 앱 설치

  
# macOS
brew install --cask claude

# Windows
# https://claude.ai/download 에서 다운로드

# Linux
# AppImage 다운로드

2.2 MCP 서버 설정

설정 파일 위치:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

예시 설정:

  
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "slack": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-slack"
      ],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-token-here",
        "SLACK_TEAM_ID": "T01234567"
      }
    },
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres"
      ],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost:5432/dbname"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/directory"
      ]
    }
  }
}

2.3 MCP 서버 테스트

Claude Desktop 재시작 후:

Claude에게 요청:
"GitHub MCP가 작동하는지 확인해줘"
"내 최근 GitHub 리포지토리 목록 보여줘"

Phase 3: Skills 생성

3.1 보안 리뷰 Skill

위치: ~/.claude/skills/security-review/SKILL.md

  
---
name: security-review
description: OWASP Top 10과 일반적인 보안 취약점을 검토합니다. 코드 보안, 인증, SQL 인젝션, XSS 취약점을 찾을 때 사용하세요.
version: 2.0.0
---

# Security Review Skill

## 목적
코드의 보안 취약점을 체계적으로 검토하고 OWASP Top 10 기준으로 평가합니다.

## 검토 프로세스

### 1단계: 자동 스캔
```python
#!/usr/bin/env python3
# scripts/security-scan.py

import subprocess
import json

def run_bandit(file_path):
    """Python 보안 취약점 스캔"""
    result = subprocess.run(
        ['bandit', '-r', file_path, '-f', 'json'],
        capture_output=True,
        text=True
    )
    return json.loads(result.stdout)

def run_semgrep(file_path):
    """다중 언어 보안 패턴 검사"""
    result = subprocess.run(
        ['semgrep', '--config=auto', '--json', file_path],
        capture_output=True,
        text=True
    )
    return json.loads(result.stdout)

def main():
    import sys
    file_path = sys.argv[1]
    
    print("=== Bandit Results ===")
    bandit_results = run_bandit(file_path)
    print(json.dumps(bandit_results, indent=2))
    
    print("\n=== Semgrep Results ===")
    semgrep_results = run_semgrep(file_path)
    print(json.dumps(semgrep_results, indent=2))

if __name__ == '__main__':
    main()

2단계: 수동 검토

A. SQL 인젝션

  
# ❌ 위험한 패턴
query = f"SELECT * FROM users WHERE id = {user_id}"
cursor.execute(query)

# ❌ 위험한 패턴 2
query = "SELECT * FROM users WHERE name = '" + name + "'"

# ✅ 안전한 패턴
query = "SELECT * FROM users WHERE id = %s"
cursor.execute(query, (user_id,))

# ✅ ORM 사용
user = db.query(User).filter(User.id == user_id).first()

B. 인증 및 인가

  
# ❌ 권한 체크 누락
def get_all_users():
    return db.query(User).all()

# ✅ 권한 체크
def get_all_users(current_user: User = Depends(get_current_admin_user)):
    if not current_user.is_admin:
        raise HTTPException(403, "Admin only")
    return db.query(User).all()

C. 민감 정보 노출

  
# ❌ 패스워드 노출
class UserResponse(BaseModel):
    id: int
    email: str
    password_hash: str  # 절대 안됨!

# ✅ 안전한 응답
class UserResponse(BaseModel):
    id: int
    email: str
    # password_hash 제외

# ❌ 로그에 민감 정보
logger.info(f"User login: {email}, password: {password}")

# ✅ 안전한 로깅
logger.info(f"User login: {email}, password: [REDACTED]")

3단계: 보안 체크리스트

🔴 Critical (즉시 수정)

SQL 인젝션 취약점 없음
인증/인가 검증 존재
민감 정보 노출 없음
XSS 취약점 없음
하드코딩된 시크릿 없음

🟡 High (우선 수정)

CSRF 보호 적용
Rate limiting 구현
입력 검증 적절
에러 메시지 안전 (스택 트레이스 노출 없음)
HTTPS 강제 사용

🟢 Medium (권장)

보안 헤더 설정 (CSP, HSTS 등)
의존성 최신 버전 사용
로깅 및 모니터링 적절
세션 관리 안전

출력 형식

  
## 🔒 보안 리뷰 결과

### 📊 요약
- 🔴 Critical: X개
- 🟡 High: X개
- 🟢 Medium: X개
- ⚪ Low: X개

### 자동 스캔 결과
[Bandit/Semgrep 결과]

### 🔴 Critical Issues

#### 1. SQL 인젝션 취약점
- **위치**: `src/api/users.py:45`
- **코드**: 
```python
query = f"SELECT * FROM users WHERE name = '{name}'"

위험도: Critical
영향: 데이터베이스 전체 노출 가능

해결방안:

  
query = select(User).where(User.name == name)

[추가 이슈들…]

✅ 통과 항목

HTTPS 강제 사용
CSRF 토큰 검증
Rate limiting 적용

💡 개선 제안

WAF(Web Application Firewall) 도입 고려
정기 보안 감사 스케줄
의존성 자동 업데이트 설정 ```

사용 방법

보안 검토가 필요한 파일을 제공
“이 코드를 security-review Skill로 검토해줘” 요청
자동 스캔 + 수동 검토 결과 확인
Critical/High 이슈 즉시 수정

도구 요구사항

  
# Python 보안 도구 설치
pip install bandit semgrep

# 사용
bandit -r ./src
semgrep --config=auto ./src

#### 3.2 GitHub PR 리뷰 통합 Skill

**위치**: `~/.claude/skills/github-pr-review/SKILL.md`

```markdown
---
name: github-pr-review
description: GitHub PR을 자동으로 리뷰하고 코멘트를 작성합니다. MCP GitHub 서버와 보안/성능 Skills를 조합합니다. Pull request, code review, GitHub 작업 시 사용하세요.
version: 1.0.0
---

# GitHub PR Review Integration Skill

## 목적
GitHub PR을 자동으로 가져와서 보안 및 성능 리뷰를 수행하고 결과를 PR에 코멘트로 작성합니다.

## 필수 요구사항
- MCP GitHub 서버가 설정되어 있어야 함
- `security-review` Skill 사용 가능
- `performance-review` Skill 사용 가능

## 워크플로우

### 1단계: PR 목록 가져오기

MCP GitHub 도구를 사용하여 PR 목록을 가져옵니다.

사용자 요청 예시: “이번 주 생성된 PR 목록을 보여줘” “Open 상태인 PR들을 리뷰해줘”

### 2단계: PR 변경사항 분석

각 PR에 대해:
1. 변경된 파일 목록 확인
2. Diff 가져오기
3. 파일 타입별로 분류

### 3단계: 적절한 Skill 적용

```python
# 의사 코드
for pr in pull_requests:
    changed_files = get_pr_files(pr.number)
    
    for file in changed_files:
        if file.endswith('.py'):
            # Python 파일 → 보안 + 성능 리뷰
            security_issues = apply_skill('security-review', file)
            performance_issues = apply_skill('performance-review', file)
            
        elif file.endswith('.js') or file.endswith('.ts'):
            # JavaScript/TypeScript → 프론트엔드 Skill
            issues = apply_skill('frontend-review', file)

4단계: 리뷰 결과 정리

  
# PR 리뷰 템플릿

## 🔍 자동 코드 리뷰 결과

### 📊 전체 요약
- 검토한 파일: X개
- 발견된 이슈: Y개
  - 🔴 Critical: A개
  - 🟡 High: B개
  - 🟢 Medium: C개

### 파일별 상세 리뷰

#### `src/api/users.py`

**🔴 Critical Issues (2)**

1. **SQL 인젝션 취약점** (Line 45)
   ```python
   # 현재 코드
   query = f"SELECT * FROM users WHERE id = {user_id}"
   
   # 권장 수정
   query = select(User).where(User.id == user_id)

영향: 데이터베이스 전체 노출 가능 우선순위: 즉시 수정 필요

[추가 이슈들…]

✅ 잘된 부분

일관된 코드 스타일
적절한 테스트 커버리지
명확한 변수명

💡 개선 제안

Type hints 추가 고려
Docstring 작성 권장
에러 핸들링 강화

🤖 이 리뷰는 Claude AI + Skills로 자동 생성되었습니다.

### 5단계: GitHub에 코멘트 작성

MCP GitHub 도구를 사용하여 PR에 코멘트를 작성합니다.

```python
# 의사 코드
review_comment = generate_review_markdown(issues)
post_pr_comment(pr_number, review_comment)

사용 예시

예시 1: 단일 PR 리뷰

사용자: "PR #123을 리뷰해줘"

Claude:
[MCP GitHub] PR #123 정보 가져오기
[MCP GitHub] 변경된 파일 목록 확인
[security-review Skill] 보안 검토
[performance-review Skill] 성능 검토
[MCP GitHub] 리뷰 코멘트 작성
사용자에게 결과 요약 제공

예시 2: 일괄 PR 리뷰

사용자: "이번 주 모든 PR을 리뷰하고 Slack에 요약 보내줘"

Claude:
1. [MCP GitHub] 이번 주 PR 목록 가져오기
2. 각 PR마다:
   - [Skills] 리뷰 수행
   - [MCP GitHub] 코멘트 작성
3. [MCP Slack] 전체 요약을 Slack에 전송

환경 설정

GitHub Personal Access Token

  
# 필요한 권한:
# - repo (전체 접근)
# - read:org (조직 정보 읽기)
# - write:discussion (PR 코멘트 작성)

export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_your_token"

MCP 설정 확인

  
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
      }
    }
  }
}

커스터마이징

리뷰 기준 조정

프로젝트별로 다른 기준을 적용하려면 review-config.json을 생성:

  
{
  "severity_thresholds": {
    "block_merge": ["critical"],
    "request_changes": ["critical", "high"],
    "comment_only": ["medium", "low"]
  },
  "auto_approve": {
    "enabled": false,
    "conditions": {
      "max_critical": 0,
      "max_high": 0,
      "min_test_coverage": 80
    }
  },
  "notification": {
    "slack_channel": "#code-reviews",
    "mention_author": true
  }
}

제한사항 및 주의사항

Rate Limiting: GitHub API 속도 제한 준수
토큰 관리: PAT를 안전하게 저장
대용량 PR: 파일이 너무 많으면 분할 리뷰
False Positives: 자동 리뷰는 참고용, 최종 판단은 사람이 ```

3.3 성능 리뷰 Skill

위치: ~/.claude/skills/performance-review/SKILL.md

  
---
name: performance-review
description: 코드의 성능 병목을 탐지하고 최적화 방안을 제시합니다. N+1 쿼리, 메모리 누수, 비효율적 알고리즘을 찾을 때 사용하세요.
version: 1.5.0
---

# Performance Review Skill

## 목적
코드의 성능 이슈를 식별하고 구체적인 최적화 방안을 제시합니다.

## 검토 영역

### 1. 데이터베이스 성능

#### N+1 쿼리 탐지
```python
# ❌ N+1 문제
users = User.query.all()  # 1번 쿼리
for user in users:
    posts = Post.query.filter_by(user_id=user.id).all()  # N번 쿼리

# ✅ JOIN 사용
users = User.query.options(joinedload(User.posts)).all()

# ✅ 수동 최적화
users = User.query.all()
user_ids = [u.id for u in users]
posts = Post.query.filter(Post.user_id.in_(user_ids)).all()

인덱스 확인

  
# 스크립트: scripts/check-indexes.py
import sqlalchemy as sa
from sqlalchemy import inspect

def check_missing_indexes(model):
    """자주 쿼리되는 컬럼에 인덱스가 있는지 확인"""
    inspector = inspect(engine)
    indexes = inspector.get_indexes(model.__tablename__)
    
    # 외래키는 자동으로 인덱스 필요
    foreign_keys = [fk.parent for fk in model.__table__.foreign_keys]
    
    for fk in foreign_keys:
        if not any(fk.name in idx['column_names'] for idx in indexes):
            print(f"⚠️  Missing index on {model.__tablename__}.{fk.name}")

2. 메모리 최적화

제너레이터 사용

  
# ❌ 전체 리스트 생성
def get_all_users():
    users = db.query(User).all()  # 메모리에 전체 로드
    return [transform(u) for u in users]

# ✅ 제너레이터
def get_all_users():
    for user in db.query(User).yield_per(100):
        yield transform(user)

3. 알고리즘 복잡도

  
#!/usr/bin/env python3
# scripts/complexity-analysis.py

def analyze_complexity(code):
    """코드의 시간 복잡도 분석"""
    
    # 중첩 루프 탐지
    nested_loops = find_nested_loops(code)
    if nested_loops >= 2:
        print("⚠️  O(n²) 이상의 복잡도 감지")
    
    # 불필요한 재귀 탐지
    recursive_calls = find_recursive_calls(code)
    if recursive_calls and not has_memoization(code):
        print("💡 메모이제이션 고려")

프로파일링 도구

  
# scripts/profile.py
import cProfile
import pstats
from io import StringIO

def profile_function(func, *args, **kwargs):
    """함수 프로파일링"""
    profiler = cProfile.Profile()
    profiler.enable()
    
    result = func(*args, **kwargs)
    
    profiler.disable()
    s = StringIO()
    ps = pstats.Stats(profiler, stream=s).sort_stats('cumulative')
    ps.print_stats(20)
    
    print(s.getvalue())
    return result

출력 형식

  
## ⚡ 성능 리뷰 결과

### 병목 현황
- 🔴 Critical: X개 (즉시 최적화 필요)
- 🟡 High: X개 (우선 최적화)
- 🟢 Medium: X개 (개선 권장)

### 🔴 Critical Issues

#### 1. N+1 쿼리 문제
- **위치**: `api/posts.py:34-38`
- **영향**: 1000개 포스트 조회 시 1001번 쿼리
- **예상 개선**: 10초 → 0.1초 (100배)
- **해결방안**:
```python
posts = Post.query.options(joinedload(Post.author)).all()

최적화 제안

Redis 캐싱 도입
- 대상: 제품 정보, 사용자 권한
- 예상 효과: 응답 시간 50% 감소
DB 인덱스 추가
- users.email
- orders.created_at
- 예상 효과: 쿼리 10배 향상
  1

Phase 4: 통합 테스트

4.1 개별 컴포넌트 테스트

# MCP 테스트
"GitHub에서 최근 PR 3개 보여줘"
"Slack #code-review 채널에 테스트 메시지 보내줘"

# Skills 테스트
"이 코드를 security-review Skill로 검토해줘"
[코드 붙여넣기]

"이 코드를 performance-review Skill로 검토해줘"
[코드 붙여넣기]

4.2 통합 테스트

"PR #123을 가져와서 보안과 성능을 모두 검토한 뒤 
결과를 Slack #code-reviews 채널에 전송해줘"

Claude의 실행 과정:
1. ✓ GitHub MCP로 PR #123 데이터 가져오기
2. ✓ 변경된 파일 목록 확인
3. ✓ security-review Skill 적용
4. ✓ performance-review Skill 적용
5. ✓ 결과 정리
6. ✓ Slack MCP로 메시지 전송

실전 시나리오

시나리오 1: 주간 PR 리뷰 자동화

목표: 매주 월요일 오전, 지난 주 모든 PR을 리뷰하고 팀에 리포트

설정:

Skill 생성: weekly-pr-review

  
---
name: weekly-pr-review
description: 주간 PR을 자동으로 리뷰하고 리포트를 생성합니다.
version: 1.0.0
---

# Weekly PR Review Skill

## 워크플로우

1. GitHub MCP로 지난 7일간의 PR 가져오기
2. 각 PR에 대해:
   - 보안 리뷰 수행
   - 성능 리뷰 수행
   - 코드 품질 평가
3. 전체 통계 생성
4. Slack에 주간 리포트 전송
5. PostgreSQL에 리뷰 히스토리 저장

## 출력 형식

```markdown
# 📊 주간 코드 리뷰 리포트
**기간**: 2025-10-28 ~ 2025-11-03

## 전체 요약
- 총 PR 수: 15개
- 리뷰 완료: 15개
- Critical 이슈: 3개
- High 이슈: 8개
- Medium 이슈: 12개

## 주요 발견사항

### 🔴 Critical Issues (3)
1. SQL 인젝션 (PR #145)
2. 인증 우회 가능 (PR #148)
3. 민감정보 로깅 (PR #151)

### 📈 트렌드
- 보안 이슈: 지난 주 대비 20% 감소 ✅
- 성능 이슈: 지난 주 대비 10% 증가 ⚠️

### 🏆 이번 주 베스트 PR
PR #152 by @johndoe - 완벽한 테스트 커버리지, 이슈 없음

## 액션 아이템
- [ ] PR #145, #148, #151 즉시 수정 필요
- [ ] 팀 전체 보안 교육 스케줄
- [ ] 성능 최적화 가이드 업데이트

2. **사용 방법**:

매주 월요일: “weekly-pr-review Skill을 실행해서 지난 주 PR들을 리뷰하고 결과를 Slack #engineering 채널에 보내줘”

### 시나리오 2: 실시간 PR 알림 시스템

**목표**: 새로운 PR이 생성되면 즉시 자동 리뷰하고 알림

**구현**:

1. **GitHub Webhook 설정** (외부 서버 필요)

```python
# webhook-server.py
from flask import Flask, request
import requests

app = Flask(__name__)

def handle_pr_webhook():
    data = request.json
    
    if data['action'] == 'opened':
        pr_number = data['pull_request']['number']
        
        # Claude API 호출
        trigger_claude_review(pr_number)
        
    return '', 200

def trigger_claude_review(pr_number):
    """Claude에게 PR 리뷰 요청"""
    # Claude API 호출 로직
    pass

Claude 프롬프트:

"PR #{pr_number}를 리뷰해서:
Critical 이슈가 있으면 즉시 Slack으로 알림
리뷰 코멘트를 PR에 작성
결과를 PostgreSQL에 저장"

시나리오 3: 코드 품질 대시보드

목표: 팀 전체의 코드 품질 메트릭을 추적하고 시각화

구현:

데이터 수집 Skill: quality-metrics-collector

  
## 수집 항목
- PR당 평균 이슈 수
- Critical 이슈 발생 빈도
- 리뷰 소요 시간
- 개발자별 통계
- 파일별 이슈 빈도

## 저장
PostgreSQL MCP를 통해 메트릭 DB에 저장

시각화:

  
-- PostgreSQL에 저장된 데이터 쿼리
SELECT 
    DATE_TRUNC('week', created_at) as week,
    COUNT(*) as total_prs,
    AVG(critical_issues) as avg_critical,
    AVG(high_issues) as avg_high
FROM pr_reviews
GROUP BY week
ORDER BY week DESC
LIMIT 12;

자동 리포트:

"quality-metrics-collector로 지난 3개월 데이터를 수집하고
Excel 리포트를 생성해서 Google Drive에 저장해줘"

고급 패턴

패턴 1: Skills 체이닝

여러 Skills를 순차적으로 실행:

  
# Skill: code-review-pipeline

## 실행 순서
1. security-review (Critical 체크)
2. performance-review (병목 탐지)
3. code-quality-review (스타일, 구조)
4. test-coverage-review (테스트 적절성)
5. documentation-review (문서화)

## 조건부 실행
- Critical 이슈 발견 → 즉시 중단, 알림
- High 이슈 3개 이상 → 추가 리뷰 요청
- 모두 통과 → 자동 승인 권장

패턴 2: 컨텍스트 기반 Skill 선택

파일 타입이나 변경 범위에 따라 동적으로 Skill 선택:

  
# 의사 코드
def select_skills(changed_files):
    skills = []
    
    if any(f.endswith('.py') for f in changed_files):
        skills.append('python-review')
        skills.append('security-review')
    
    if any(f.endswith('.sql') for f in changed_files):
        skills.append('sql-review')
    
    if any('api/' in f for f in changed_files):
        skills.append('api-review')
    
    if len(changed_files) > 20:
        skills.append('architecture-review')
    
    return skills

패턴 3: 점진적 엄격도

PR 단계에 따라 리뷰 엄격도 조정:

  
# Draft PR
- 빠른 리뷰 (주요 이슈만)
- Critical만 체크
- 코멘트 간략

# Ready for Review
- 표준 리뷰
- Critical + High 체크
- 상세 코멘트

# Final Review (머지 전)
- 엄격한 리뷰
- 모든 레벨 체크
- 종합 리포트
- 테스트 커버리지 확인

패턴 4: 팀별 커스터마이징

팀마다 다른 리뷰 기준:

  
# Backend Team
- 보안: Critical + High 필수
- 성능: High 필수
- DB 인덱스: 필수 체크
- API 문서: 필수

# Frontend Team
- 접근성: High 필수
- 성능: Lighthouse 점수 90+
- Bundle 크기: 증가 시 경고
- 타입 안전성: TypeScript strict

# DevOps Team
- IaC 검증: Terraform plan 필수
- 보안 그룹: 최소 권한 원칙
- 로깅: 모든 리소스
- Cost 영향: 예상 비용 계산

보안 및 거버넌스

1. 접근 제어

MCP 서버 권한 관리

  
{
  "mcpServers": {
    "github": {
      "permissions": {
        "repositories": ["read", "write:pull-requests"],
        "organizations": ["read"]
      }
    },
    "slack": {
      "permissions": {
        "channels": ["#code-reviews", "#engineering"],
        "actions": ["post_message", "read_history"]
      }
    },
    "postgres": {
      "permissions": {
        "schemas": ["code_reviews"],
        "operations": ["SELECT", "INSERT"],
        "tables": ["pr_reviews", "metrics"]
      }
    }
  }
}

Skills 권한 범위

  
---
name: restricted-admin-skill
permissions:
  filesystem:
    read: ["/var/logs"]
    write: []
  network:
    allowed_domains: ["api.internal.company.com"]
  execution:
    allowed_commands: ["grep", "awk", "tail"]
---

2. 감사 로깅

  
# scripts/audit-logger.py

import logging
import json
from datetime import datetime

audit_logger = logging.getLogger('audit')

def log_skill_execution(skill_name, user, inputs, outputs):
    """Skill 실행 감사 로그"""
    audit_logger.info(json.dumps({
        'timestamp': datetime.utcnow().isoformat(),
        'event': 'skill_execution',
        'skill': skill_name,
        'user': user,
        'inputs_hash': hash(str(inputs)),  # 민감정보 방지
        'outputs_hash': hash(str(outputs)),
        'success': True
    }))

def log_mcp_access(server, operation, user):
    """MCP 서버 접근 감사 로그"""
    audit_logger.info(json.dumps({
        'timestamp': datetime.utcnow().isoformat(),
        'event': 'mcp_access',
        'server': server,
        'operation': operation,
        'user': user
    }))

3. 민감 정보 보호

  
# Skill: sensitive-data-redaction

## 자동 마스킹
- API 키: 마지막 4자리만 표시
- 패스워드: 완전 마스킹
- 이메일: 일부 마스킹
- IP 주소: 일부 마스킹

## 검출 패턴
```python
import re

PATTERNS = {
    'api_key': r'(api[_-]?key|apikey)["\s:=]+([a-zA-Z0-9]{20,})',
    'aws_key': r'AKIA[0-9A-Z]{16}',
    'password': r'(password|passwd|pwd)["\s:=]+([^\s"]+)',
    'email': r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
}

def redact_sensitive_data(text):
    for pattern_name, pattern in PATTERNS.items():
        text = re.sub(pattern, f'[REDACTED_{pattern_name.upper()}]', text)
    return text

### 4. Rate Limiting

```python
# scripts/rate-limiter.py

from datetime import datetime, timedelta
from collections import defaultdict

class RateLimiter:
    def __init__(self):
        self.requests = defaultdict(list)
    
    def check_limit(self, user, limit=100, window=3600):
        """시간당 요청 수 제한"""
        now = datetime.utcnow()
        cutoff = now - timedelta(seconds=window)
        
        # 오래된 요청 제거
        self.requests[user] = [
            ts for ts in self.requests[user] 
            if ts > cutoff
        ]
        
        # 제한 확인
        if len(self.requests[user]) >= limit:
            raise Exception(f"Rate limit exceeded for {user}")
        
        self.requests[user].append(now)
        return True

트러블슈팅

문제 1: MCP 서버가 연결되지 않음

증상:

Error: Failed to connect to MCP server 'github'

해결:

설정 파일 확인: ```bash
macOS
cat ~/Library/Application\ Support/Claude/claude_desktop_config.json

유효성 검사

jq empty claude_desktop_config.json

2. **환경 변수 확인**:
```bash
echo $GITHUB_PERSONAL_ACCESS_TOKEN

MCP 서버 수동 테스트:

npx @modelcontextprotocol/server-github

로그 확인:

  
# macOS
tail -f ~/Library/Logs/Claude/mcp*.log

문제 2: Skill이 로딩되지 않음

증상:

Claude가 Skill을 사용하지 않음

해결:

Skill 위치 확인:
1 ls -la ~/.claude/skills/

YAML 프론트매터 검증:

head -n 10 ~/.claude/skills/my-skill/SKILL.md

Description 개선: ```markdown —
❌ 너무 일반적
description: 코드 리뷰 도구

✅ 구체적

description: Python 코드의 보안 취약점을 검토합니다. SQL 인젝션, XSS, 인증 이슈를 찾을 때 사용하세요. —

4. **명시적 호출**:

“my-skill Skill을 사용해서 이 코드를 리뷰해줘”

### 문제 3: 성능 저하

**증상**:

Claude의 응답이 너무 느림 토큰 사용량이 과도함

**해결**:

1. **MCP 서버 수 줄이기**:
```json
{
  "mcpServers": {
    // 필요한 것만 활성화
    "github": { ... },
    // "slack": { ... },  // 비활성화
    // "postgres": { ... }  // 비활성화
  }
}

Skills 범위 축소: ```markdown
❌ 너무 포괄적인 Skill
전체 코드베이스 분석…

✅ 집중된 Skill

특정 파일/모듈만 분석

3. **점진적 로딩**:
```markdown
# Skill 메타데이터만 먼저 로드
# 필요할 때 전체 내용 로드

캐싱 활용:

  
# 동일한 파일을 반복 분석하지 않도록
def analyze_file(file_path, file_hash):
 ...

문제 4: 보안 경고

증상:

Skill execution blocked: Unsafe operation

해결:

허용된 경로 확인:

  
{
  "filesystem": {
 "allowed_paths": [
   "/path/to/project",
   "/tmp/claude-workspace"
 ]
  }
}

스크립트 권한 검토: ```bash
실행 권한만
chmod 755 scripts/analyze.py

읽기/쓰기는 제거

chmod 644 SKILL.md

3. **네트워크 접근 제한**:
```markdown
---
permissions:
  network:
    allowed_domains:
      - "api.github.com"
      - "api.internal.company.com"
---

문제 5: GitHub API Rate Limit

증상:

API rate limit exceeded

해결:

인증된 요청 사용:

  
# Personal Access Token 사용
export GITHUB_PERSONAL_ACCESS_TOKEN="ghp_..."

요청 배치 처리:

  
# 한 번에 여러 PR 가져오기
prs = github.get_pulls(state='open', per_page=100)

캐싱: ```python from functools import lru_cache from datetime import timedelta

def get_pr_info(pr_number): # 1시간 동안 캐시 return github.get_pull(pr_number)

4. **Rate Limit 모니터링**:
```python
rate_limit = github.get_rate_limit()
print(f"Remaining: {rate_limit.core.remaining}")
print(f"Reset at: {rate_limit.core.reset}")

부록

A. 유용한 MCP 서버 목록

공식 서버

@modelcontextprotocol/server-github: GitHub 통합
@modelcontextprotocol/server-slack: Slack 통합
@modelcontextprotocol/server-postgres: PostgreSQL 접근
@modelcontextprotocol/server-filesystem: 파일 시스템 접근
@modelcontextprotocol/server-puppeteer: 웹 스크래핑

커뮤니티 서버

Google Drive MCP: Google Drive 파일 접근
Jira MCP: Jira 이슈 관리
Notion MCP: Notion 데이터베이스
Stripe MCP: 결제 정보
AWS MCP: AWS 리소스 관리

B. Skills 템플릿 라이브러리

코드 리뷰

security-review: 보안 취약점
performance-review: 성능 병목
code-quality: 코드 품질
test-coverage: 테스트 적절성
api-review: API 설계

문서 생성

docx-creator: Word 문서
pptx-creator: PowerPoint
xlsx-creator: Excel
pdf-creator: PDF

개발 워크플로우

git-helper: Git 작업
ci-cd-helper: CI/CD 파이프라인
deployment-checker: 배포 검증

C. 예제 프로젝트 구조

my-code-review-project/
├── .claude/
│   └── skills/
│       ├── security-review/
│       │   ├── SKILL.md
│       │   └── scripts/
│       │       ├── bandit-scan.py
│       │       └── semgrep-scan.py
│       │
│       ├── performance-review/
│       │   ├── SKILL.md
│       │   └── scripts/
│       │       └── profile.py
│       │
│       └── github-pr-review/
│           └── SKILL.md
│
├── claude_desktop_config.json
├── .env
└── README.md

D. 추가 리소스

공식 문서

Claude Skills: https://docs.claude.com/en/docs/claude-code/skills
MCP 사양: https://github.com/modelcontextprotocol/modelcontextprotocol
Claude API: https://docs.claude.com/

커뮤니티

Claude MCP 커뮤니티: https://www.claudemcp.com/
MCP GitHub: https://github.com/modelcontextprotocol
Skills 마켓플레이스: https://github.com/anthropics/skills

학습 자료

Anthropic Academy: https://www.anthropic.com/learn
MCP 퀵스타트: https://modelcontextprotocol.io/quickstart
Skills 튜토리얼: https://docs.claude.com/en/docs/claude-code/skills

결론 및 다음 단계

핵심 요약

Claude.ai: 사용자 인터페이스, 자연어 상호작용
MCP: 외부 시스템 (GitHub, Slack 등) 연결
Skills: 재사용 가능한 전문 작업 패키지

통합의 이점

✅ 자동화: 수동 코드 리뷰 → 자동화된 초기 검토
✅ 일관성: 모든 PR에 동일한 기준 적용
✅ 효율성: 리뷰 시간 50-70% 단축
✅ 품질: Critical 이슈를 사전에 발견
✅ 확장성: 팀 전체가 공유 가능

구현 로드맵

Week 1: 기초 설정

Claude.ai 프로젝트 생성
Claude Desktop 앱 설치
첫 번째 MCP 서버 연결 (GitHub)
간단한 Skill 생성 (security-review)

Week 2: 통합 구축

추가 MCP 서버 (Slack, PostgreSQL)
전문 Skills 개발 (performance, quality)
GitHub PR 리뷰 통합 Skill
엔드투엔드 테스트

Week 3: 자동화

주간 리뷰 자동화
실시간 알림 시스템
메트릭 수집 및 대시보드
팀 교육

Week 4: 최적화

성능 튜닝
보안 강화
False Positive 줄이기
문서화 및 베스트 프랙티스 공유

성공 지표

리뷰 시간: 30분 → 10분 (70% 감소)
발견율: Critical 이슈 100% 사전 탐지
False Positive: 20% 이하 유지
팀 만족도: 4.5/5 이상
프로덕션 버그: 50% 감소

지속적 개선

1. 주간 회고
   - 놓친 이슈 분석
   - False Positive 패턴 식별
   - Skills 업데이트

2. 월간 리뷰
   - 메트릭 분석
   - 새로운 Skills 추가
   - 팀 피드백 반영

3. 분기별 평가
   - ROI 계산
   - 프로세스 개선
   - 새로운 도구 평가

이 가이드를 통해 Claude.ai + MCP + Skills의 강력한 통합 시스템을 구축하여 코드 품질을 획기적으로 향상시킬 수 있습니다! 🚀

문서 버전: 3.0
최종 업데이트: 2025년 11월 5일
작성자: Claude AI 통합 가이드 프로젝트 팀

AI, Claude

AI Claude.ai MCP agent-skills claude-skills Claude.write

📋 목차

개요: 세 가지 도구의 시너지

왜 통합이 필요한가?

실제 사례

기술 스택 이해하기

1. Claude.ai

2. Model Context Protocol (MCP)

3. Claude Skills

비교 표

통합 아키텍처

전체 흐름도

데이터 흐름

단계별 구축 가이드

Phase 1: Claude.ai 설정

1.1 프로젝트 생성

1.2 필요한 문서 업로드

Phase 2: MCP 서버 설정

2.1 Claude Desktop 앱 설치

2.2 MCP 서버 설정

2.3 MCP 서버 테스트

Phase 3: Skills 생성

3.1 보안 리뷰 Skill

2단계: 수동 검토

A. SQL 인젝션

B. 인증 및 인가

C. 민감 정보 노출

3단계: 보안 체크리스트

🔴 Critical (즉시 수정)

🟡 High (우선 수정)

🟢 Medium (권장)

출력 형식

✅ 통과 항목

💡 개선 제안

사용 방법

도구 요구사항

4단계: 리뷰 결과 정리

✅ 잘된 부분

💡 개선 제안

사용 예시

예시 1: 단일 PR 리뷰

예시 2: 일괄 PR 리뷰

환경 설정

GitHub Personal Access Token

MCP 설정 확인

커스터마이징

리뷰 기준 조정

제한사항 및 주의사항

3.3 성능 리뷰 Skill

인덱스 확인

2. 메모리 최적화

제너레이터 사용

3. 알고리즘 복잡도

프로파일링 도구

출력 형식

최적화 제안

Phase 4: 통합 테스트

4.1 개별 컴포넌트 테스트

4.2 통합 테스트

실전 시나리오

시나리오 1: 주간 PR 리뷰 자동화

시나리오 3: 코드 품질 대시보드

고급 패턴

패턴 1: Skills 체이닝

패턴 2: 컨텍스트 기반 Skill 선택

패턴 3: 점진적 엄격도

패턴 4: 팀별 커스터마이징

보안 및 거버넌스

1. 접근 제어

MCP 서버 권한 관리

Skills 권한 범위

2. 감사 로깅

3. 민감 정보 보호

트러블슈팅

문제 1: MCP 서버가 연결되지 않음

macOS

유효성 검사

문제 2: Skill이 로딩되지 않음

❌ 너무 일반적

✅ 구체적

❌ 너무 포괄적인 Skill