%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
timeline
    title IDE 진화의 역사
    
    1980년대 : 텍스트 에디터
             : 별도 컴파일러
             : 명령행 기반
    
    1990년대 : 통합 개발 환경
             : 문법 강조
             : 내장 디버거
             : 프로젝트 관리
    
    2000년대 : 인텔리센스
             : 자동 리팩토링
             : 코드 완성
             : 버전 제어 통합
    
    2010년대 : 플러그인 생태계
             : 클라우드 통합
             : 실시간 협업
             : 모바일 지원
    
    2020년대 : AI 코드 완성
             : 지능형 제안
             : 자동 테스트 생성
             : 자연어 인터페이스

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph LR
    subgraph matrix [" "]
        direction LR
        
        subgraph level1 ["기본 지원"]
            A1["자동완성<br/>GitHub Copilot"]
            A2["코드 생성<br/>Tabnine"]
        end
        
        subgraph level2 ["고급 지원"]
            B1["대화형 AI<br/>Claude Code"]
            B2["자율 에이전트<br/>Future Tech"]
        end
        
        A1 -.->|진화| A2
        A2 -.->|도약| B1
        B1 -.->|발전| B2
    end
    
    classDef current fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef future fill:#f8fafc,stroke:#94a3b8,stroke-width:2px,stroke-dasharray: 5 5,color:#64748b
    classDef basic fill:#f8fafc,stroke:#cbd5e1,stroke-width:1px,color:#64748b
    classDef highlight fill:#e2e8f0,stroke:#334155,stroke-width:3px,color:#0f172a
    
    class B1 highlight
    class B2 future
    class A1,A2 basic

# 다양한 접근 방식 모두 가능
claude "버그를 찾아서 수정해줘"
claude "TDD 방식으로 새 기능을 구현해줘"
claude "이 코드를 함수형 스타일로 리팩토링해줘"
claude "아키텍처를 분석하고 개선점을 제안해줘"

# Claude Code의 작업 과정을 실시간으로 확인
> 파일 탐색 중: src/components/
> 코드 분석 중: UserProfile.jsx
> 수정 사항 적용 중...
> 테스트 실행 중...

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#334155", "primaryBorderColor": "#e2e8f0"}, "mindmap": {"htmlLabels": false, "useMaxWidth": false}}}%%
mindmap
  root((맥락 이해))
    프로젝트 분석
      파일 구조 탐색
      의존성 매핑
      아키텍처 패턴 인식
    컨벤션 학습
      코딩 스타일 분석
      네이밍 규칙 파악
      포맷팅 패턴 인식
    로직 이해
      비즈니스 요구사항
      데이터 플로우
      에러 처리 패턴
    솔루션 제공
      최적화된 구현
      베스트 프랙티스 적용
      확장 가능한 설계

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph LR
    subgraph comparison [" "]
        direction TB
        
        subgraph copilot ["GitHub Copilot"]
            direction TB
            A1["인라인 자동완성<br/>간단한 제안"]
            A2["현재 파일 중심<br/>제한적 컨텍스트"]
            A3["코드 작성<br/>단일 기능"]
            A4["제한적 설정<br/>기본 옵션만"]
            A5["낮은 학습 곡선<br/>즉시 사용 가능"]
        end
        
        subgraph claude ["Claude Code"]
            direction TB
            B1["대화형 협업<br/>자연어 인터페이스"]
            B2["전체 프로젝트<br/>완전한 컨텍스트"]
            B3["전체 라이프사이클<br/>설계부터 배포까지"]
            B4["완전 커스터마이징<br/>CLAUDE.md 활용"]
            B5["적응형 학습<br/>점진적 마스터리"]
        end
        
        A1 -.->|vs| B1
        A2 -.->|vs| B2
        A3 -.->|vs| B3
        A4 -.->|vs| B4
        A5 -.->|vs| B5
    end
    
    classDef copilotStyle fill:#f1f5f9,stroke:#64748b,stroke-width:1px,color:#475569
    classDef claudeStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    
    class A1,A2,A3,A4,A5 copilotStyle
    class B1,B2,B3,B4,B5 claudeStyle

# 우리 프로젝트의 규칙
- 모든 컴포넌트는 함수형으로 작성
- 테스트 커버리지 80% 이상 유지
- 커밋 메시지는 conventional commits 따르기

# 프론트엔드부터 배포까지 한 번에
claude "사용자 인증 기능을 만들어줘. React 프론트엔드, Node.js 백엔드, PostgreSQL 데이터베이스, Docker 컨테이너화까지"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
flowchart LR
    subgraph before ["전통적 개발 방식"]
        direction TB
        A1["개발자가 모든 세부사항을<br/>직접 구현"]
        A2["반복적인 작업에<br/>시간 소모"]
        A3["새로운 기술 학습에<br/>높은 진입 장벽"]
        A4["느린 프로토타이핑<br/>사이클"]
    end
    
    subgraph transition ["전환점"]
        T["Claude Code<br/>도입"]
    end
    
    subgraph after ["혁신적 개발 문화"]
        direction TB
        B1["개발자는 '무엇을'<br/>만들지에 집중"]
        B2["AI가 '어떻게'<br/>구현할지를 도움"]
        B3["빠른 실험과<br/>검증 가능"]
        B4["지속적인 학습과<br/>성장"]
    end
    
    before --> transition
    transition --> after
    
    A1 -.->|변화| B1
    A2 -.->|자동화| B2
    A3 -.->|가속화| B3
    A4 -.->|최적화| B4
    
    classDef beforeStyle fill:#f8fafc,stroke:#64748b,stroke-width:1px,color:#64748b
    classDef afterStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef transitionStyle fill:#f1f5f9,stroke:#475569,stroke-width:3px,color:#0f172a
    
    class A1,A2,A3,A4 beforeStyle
    class B1,B2,B3,B4 afterStyle
    class T transitionStyle

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
flowchart TD
    A[법무팀 디지털 혁신] --> B[개인용 접근성 도구]
    A --> C[전화 트리 시뮬레이션]
    A --> D[G Suite 자동화]
    
    subgraph personal [개인용 도구]
        B --> E[법률 문서 작성 앱]
        E --> F[자동 완성 기능]
        E --> G[템플릿 제안]
        E --> H[판례 인용 포맷팅]
        E --> I[버전 관리]
    end
    
    subgraph routing [라우팅 시스템]
        C --> J[문의 유형 분류]
        C --> K[긴급도 평가]
        C --> L[전문분야 매칭]
        J --> M[계약/지적재산/노동/규정준수]
        K --> N[즉시/당일/주간]
        L --> O[변호사 자동 할당]
    end
    
    subgraph automation [워크플로우 자동화]
        D --> P[Google Sheets 연동]
        D --> Q[Google Drive 통합]
        D --> R[Gmail 자동화]
        
        P --> S[리뷰 요청 등록]
        P --> T[진행 상태 추적]
        Q --> U[문서 버전 관리]
        Q --> V[승인 워크플로우]
        R --> W[자동 알림]
        R --> X[리포트 발송]
    end
    
    classDef toolStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef processStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef featureStyle fill:#ecfdf5,stroke:#059669,stroke-width:2px,color:#064e3b
    
    class A,B,C,D toolStyle
    class E,J,K,L,P,Q,R processStyle
    class F,G,H,I,M,N,O,S,T,U,V,W,X featureStyle

# 1시간 만에 프로토타입 완성
claude "법률 문서 작성을 도와주는 예측 텍스트 앱을 만들어줘

기능
- 법률 용어 자동 완성
- 계약서 조항 템플릿 제안
- 판례 인용 자동 포맷팅
- 문서 버전 관리
- 협업 댓글 기능

기술 스택
- 간단한 웹 앱 (HTML, CSS, JavaScript)
- 로컬 저장소 활용
- 오프라인에서도 동작

1시간 내에 기본 동작하는 프로토타입으로 만들어줘"

# 담당 변호사 매칭 자동화
claude "법무 문의를 적절한 담당 변호사에게 라우팅하는 시스템을 만들어줘

라우팅 로직
- 문의 유형 분류 (계약, 지적재산, 노동, 규정준수)
- 긴급도 평가 (즉시, 당일, 주간)
- 변호사 전문분야 매칭
- 업무량 기반 할당

인터페이스
- 간단한 질문 트리
- 드래그 앤 드롭 문서 업로드
- 자동 이메일 알림
- 진행 상태 추적"

# 법무 리뷰 프로세스 자동화
claude "Google Workspace를 활용한 법무 리뷰 추적 시스템을 만들어줘

Google Sheets 연동
- 리뷰 요청 자동 등록
- 진행 상태 실시간 업데이트
- 담당자별 업무량 시각화
- 마감일 알림 자동화

Google Drive 통합
- 문서 버전 관리
- 댓글 기반 피드백 수집
- 최종 승인 워크플로우
- 아카이브 자동화

Gmail 자동화
- 리뷰 완료 시 자동 알림
- 지연 시 에스컬레이션
- 주간/월간 리포트 자동 발송"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
flowchart LR
    A[손그림 스케치] --> B[요구사항 분석]
    B --> C[레이아웃 구조 설계]
    C --> D[기능 동작 구현]
    D --> E[스타일링 적용]
    E --> F[최종 검토]
    
    subgraph feedback [피드백 루프]
        G[팀원 테스트] --> H[피드백 수집]
        H --> I[개선사항 식별]
        I --> J[반복적 개선]
        J --> G
    end
    
    F --> G
    J --> K[완성된 웹앱]
    
    subgraph requirements [핵심 요구사항]
        L[실제 동작하는 버튼]
        M[데이터 입력/저장]
        N[모바일 친화적 레이아웃]
        O[법무팀 브랜딩]
    end
    
    C --> requirements
    
    classDef processStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef feedbackStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef requirementStyle fill:#ecfdf5,stroke:#059669,stroke-width:2px,color:#064e3b
    
    class A,B,C,D,E,F,K processStyle
    class G,H,I,J feedbackStyle
    class L,M,N,O requirementStyle

# 스케치에서 앱으로
claude "이 손그림 와이어프레임을 보고 작동하는 웹앱을 만들어줘

[손그림 스케치 첨부]

요구사항
- 모든 버튼이 실제로 동작
- 데이터 입력과 저장 기능
- 모바일 친화적 레이아웃
- 법무팀 브랜딩 적용

단계별 확인
1. 레이아웃 구조 확인
2. 기능 동작 테스트
3. 스타일링 개선
4. 최종 검토"

# 사용자 피드백 기반 개선
claude "팀원들이 사용해보고 다음 피드백을 주었어
- 버튼이 너무 작아서 모바일에서 클릭하기 어려움
- 문서 업로드 후 진행상황을 알 수 없음
- 이메일 알림이 너무 자주 옴

이 피드백을 반영해서 개선해줘"

# AI 기반 계약서 분석 도구
claude "계약서 초안을 업로드하면 자동으로 검토하는 도구를 만들어줘

검토 항목
- 표준 조항 누락 여부
- 리스크 조항 식별
- 금액/날짜 정합성 확인
- 법적 요구사항 준수 체크

결과 출력
- 위험도별 이슈 분류
- 수정 제안사항
- 유사 계약서 참조
- 검토 우선순위 제시"

# 컴플라이언스 대시보드
claude "회사의 규정 준수 현황을 모니터링하는 대시보드를 만들어줘

추적 영역
- 데이터 보호 (GDPR, CCPA)
- 금융 규제 (SOX, PCI-DSS)
- 노동법 준수
- 환경 규제

자동화 기능
- 규제 변경사항 모니터링
- 준수 상태 실시간 체크
- 리스크 레벨 시각화
- 액션 아이템 자동 생성"

# Claude.ai에서 설계 후 Claude Code로 구현
# 1단계: Claude.ai에서 아이디어 구체화
"법무 업무에서 가장 반복적이고 시간이 많이 걸리는 작업이 뭔지 
분석해주고, 자동화 가능한 부분을 찾아줘"

# 2단계: Claude Code에서 구현
"앞서 논의한 계약서 검토 프로세스를 실제로 구현해줘"

# 단계별 피드백 루프
claude "이 기능이 제대로 동작하는지 스크린샷으로 확인해줄게.
다음에 추가할 기능은 뭐가 좋을까?"

# 완성도보다 공유 우선
claude "아직 완벽하지 않지만 팀원들과 공유할 수 있는 
데모 버전을 만들어줘. 피드백을 받아서 개선하고 싶어"

# ~/.bashrc 또는 ~/.zshrc에 추가
alias cc="claude"
alias ccc="claude --clear"
alias ccr="claude 'npm run'"

# Claude Code 템플릿 디렉토리 생성
mkdir -p ~/.claude-templates/{components,features,tests,docs}

# 컴포넌트 생성 템플릿
cat > ~/.claude-templates/components/react-component.txt << 'EOF'
새로운 React 컴포넌트를 만들어줘
- 컴포넌트 이름: [COMPONENT_NAME]
- 함수형 컴포넌트로 작성
- TypeScript 사용
- Props 인터페이스 정의
- 기본 스타일 포함
- 스토리북 스토리 파일도 생성
- 유닛 테스트 파일 포함
EOF

# 사용 예시
COMPONENT_NAME="UserProfile" envsubst < ~/.claude-templates/components/react-component.txt | claude

# API 라우트 생성 템플릿
cat > ~/.claude-templates/features/api-endpoint.txt << 'EOF'
새로운 REST API 엔드포인트를 만들어줘
- 리소스: [RESOURCE_NAME]
- CRUD 작업 모두 포함
- Express.js 라우터 사용
- 입력 검증 미들웨어
- 에러 핸들링
- Swagger 문서 주석
- 통합 테스트 포함
EOF

# 버그 수정 워크플로우 템플릿
cat > ~/.claude-templates/features/bugfix.txt << 'EOF'
다음 버그를 수정해줘
1. 먼저 관련된 코드를 찾아서 분석해줘
2. 버그의 근본 원인을 설명해줘
3. 수정 방안을 제시하고 구현해줘
4. 재발 방지를 위한 테스트를 추가해줘
5. 수정사항을 커밋 메시지와 함께 정리해줘

버그 설명: [BUG_DESCRIPTION]
EOF

# 대화형 모드로 시작
claude

> 이제부터 레거시 코드를 최신 아키텍처로 마이그레이션할 거야
< 알겠습니다. 먼저 현재 코드베이스를 분석하고 마이그레이션 계획을 수립하겠습니다.

> 1단계: 현재 아키텍처를 분석하고 문제점을 파악해줘
< 분석 결과
  - 모놀리식 구조로 모듈 간 결합도가 높음
  - 클래스 기반 컴포넌트 사용 (React 16.2)
  - 상태 관리가 prop drilling으로 복잡함
  - 테스트 커버리지 30%
  
  주요 개선 필요 영역을 식별했습니다. 계속 진행할까요?

> 2단계: 마이그레이션 로드맵을 만들어줘
< 단계별 마이그레이션 로드맵
  Phase 1: 인프라 현대화 (1-2주)
  - 빌드 도구를 Webpack에서 Vite로 마이그레이션
  - TypeScript 도입
  
  Phase 2: 컴포넌트 현대화 (3-4주)
  - 클래스 컴포넌트를 함수형으로 전환
  - Custom Hooks로 로직 추출
  
  Phase 3: 상태 관리 개선 (1주)
  - Context API 또는 Zustand 도입
  
  Phase 4: 테스트 강화 (1주)
  - 테스트 커버리지 80% 목표

> 좋아, Phase 1부터 시작하자. 먼저 Vite 마이그레이션을 진행해줘
< Phase 1 시작: Vite 마이그레이션을 단계별로 진행하겠습니다...

# Development Workflow

## 기능 개발 프로세스
1. 이슈 생성 및 브랜치 생성
2. 탐색: 관련 코드 분석 (30분)
3. 계획: 구현 전략 수립 (30분)
4. 구현: TDD로 개발 (2-4시간)
5. 리뷰: 자체 코드 리뷰 (30분)
6. PR 생성 및 리뷰 요청

## 일일 루틴
- 09:00: 이슈 확인 및 우선순위 정리
- 09:30: 집중 코딩 (포모도로 기법)
- 14:00: 코드 리뷰
- 16:00: 문서 업데이트
- 17:00: 다음 날 계획

## 품질 체크리스트
- [ ] 테스트 커버리지 80% 이상
- [ ] 모든 함수에 JSDoc
- [ ] 성능 프로파일링 완료
- [ ] 접근성 검사 통과
- [ ] 보안 스캔 통과

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
mindmap
  root((핵심 원칙))
    체계적 접근
      EPCC 사이클 적용
      예측 가능한 프로세스
      반복 가능한 개발
      리스크 최소화
    품질 우선
      TDD 실천
      지속적 리팩토링
      코드 리뷰 문화
      자동화된 테스트
    자동화 극대화
      반복 작업 제거
      도구 활용
      스크립트 개발
      효율성 향상
    지속적 개선
      메트릭 수집
      프로세스 분석
      피드백 반영
      메타 개선

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
flowchart TD
    A["CLAUDE.md의 역할과 중요성"] --> B["프로젝트 구조 및 아키텍처 문서화"]
    B --> C["코딩 스타일 가이드 정의"]
    C --> D["개발 환경 자동화 설정"]
    D --> E["팀 협업을 위한 규칙 수립"]
    E --> F["실전 프로젝트 예제와 최적화 전략"]
    
    classDef chapterStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C,D,E,F chapterStyle

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
mindmap
  root((CLAUDE.md 핵심 개념))
    프로젝트 컨텍스트
      고유한 특성 이해
      비즈니스 도메인 파악
      아키텍처 구조 인식
    지속적 규칙 적용
      세션 간 일관성 유지
      스타일 가이드 준수
      자동 규칙 검증
    팀 지식 저장소
      암묵적 지식 명시화
      개발 경험 축적
      베스트 프랙티스 공유

프로젝트 루트/
├── CLAUDE.md          # Claude Code 설정 파일
├── README.md          # 일반 프로젝트 문서
├── package.json
└── src/

# CLAUDE.md
## 코드 스타일

- 모든 함수는 화살표 함수로 작성
- 세미콜론 항상 사용
- 들여쓰기는 2칸

## Git 커밋 규칙
- feat: 새로운 기능 추가
- fix: 버그 수정
- docs: 문서 수정
- style: 코드 포매팅 (기능 변경 없음)
- refactor: 코드 리팩토링 (기능 변경 없음)
- test: 테스트 추가 또는 수정
- chore: 빌드 프로세스 또는 보조 도구 변경

## 커밋 메시지 형식
<type>(<scope>): <subject>

예시
feat(auth): 소셜 로그인 기능 추가
fix(api): 사용자 조회 시 null 참조 오류 수정

## 도메인 용어
- SKU (Stock Keeping Unit): 재고 관리 단위
  - 예: "SHOE-NIKE-AF1-WHT-42" (나이키 에어포스1 흰색 42사이즈)
- PDP (Product Detail Page): 상품 상세 페이지
  - 주요 컴포넌트: 이미지 갤러리, 가격 정보, 재고 상태, 리뷰
- CAC (Customer Acquisition Cost): 고객 획득 비용
  - 계산식: 총 마케팅 비용 / 신규 고객 수

## 비즈니스 규칙
- 재고가 5개 이하일 때 "품절 임박" 표시
- 신규 회원은 첫 구매 시 10% 할인 자동 적용
- 50,000원 이상 구매 시 무료 배송

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph LR
    subgraph readme ["README.md"]
        A1["대상: 사람<br/>개발자, 사용자"]
        A2["목적: 프로젝트 소개<br/>사용 가이드"]
        A3["내용: 설치 방법<br/>API 문서, 예제"]
        A4["형식: 사용자 친화적<br/>설명 중심"]
    end
    
    subgraph claude ["CLAUDE.md"]
        B1["대상: Claude Code<br/>AI 어시스턴트"]
        B2["목적: 작업 지침<br/>컨텍스트 제공"]
        B3["내용: 코딩 규칙<br/>아키텍처, 팀 컨벤션"]
        B4["형식: 구조화된<br/>AI 이해 최적화"]
    end
    
    A1 -.->|vs| B1
    A2 -.->|vs| B2
    A3 -.->|vs| B3
    A4 -.->|vs| B4
    
    classDef readmeStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef claudeStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    
    class A1,A2,A3,A4 readmeStyle
    class B1,B2,B3,B4 claudeStyle

# README.md (사람을 위한 문서)
## 프로젝트 소개
이 프로젝트는 전자상거래 플랫폼입니다.

## 설치 방법

1. 저장소를 클론합니다.
2. `npm install` 실행
3. `npm start`로 서버 시작

---

# CLAUDE.md (Claude Code를 위한 문서)
## 프로젝트 아키텍처
- 패턴: MVC + Repository Pattern
- 프론트엔드: React 18 + TypeScript
- 백엔드: Node.js + Express
- 데이터베이스: PostgreSQL + Redis

## 코드 생성 규칙
- 모든 API 응답은 ResponseDto로 래핑
- 에러는 CustomError 클래스 사용
- 비동기 함수는 반드시 try-catch 포함

# CLAUDE.md

## 프로젝트 구조

### 디렉토리 구조

### 주요 파일 위치
- 환경 설정: `.env`, `.env.example`
- API 엔드포인트: `src/services/api.ts`
- 라우팅 설정: `src/routes/index.tsx`
- 전역 스타일: `src/styles/global.css`

### 파일 명명 규칙
- 컴포넌트: PascalCase (예: UserProfile.tsx)
- 유틸리티: camelCase (예: formatDate.ts)
- 상수: UPPER_SNAKE_CASE (예: API_ENDPOINTS.ts)
- 스타일: kebab-case (예: user-profile.module.css)

## 아키텍처 패턴

### 상태 관리
- Redux Toolkit 사용
- 각 기능별로 slice 파일 생성
- RTK Query로 API 상태 관리

### 컴포넌트 구조
```typescript
// 모든 컴포넌트는 다음 구조를 따름
interface ComponentProps {
  // props 정의
}

export const ComponentName: React.FC<ComponentProps> = (props) => {
  // 훅은 최상단에
  // 로직
  // JSX 반환
}

## 코딩 스타일

### TypeScript/JavaScript
- 함수명: camelCase
- 컴포넌트명: PascalCase  
- 상수: UPPER_SNAKE_CASE
- 파일명: kebab-case.ts

### 명명 규칙 예시
```typescript
// 좋은 예
const getUserData = async (userId: string) => { }
const MAX_RETRY_COUNT = 3;
export const UserProfile: React.FC = () => { }

// 피해야 할 예
const get_user_data = async (userid) => { }
const maxretrycount = 3;
export const userprofile = () => { }
```

```mermaid
%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
flowchart TD
    A["Import 순서"] --> B["1. React 관련<br/>React, useState, useEffect"]
    B --> C["2. 외부 라이브러리<br/>axios, lodash, moment"]
    C --> D["3. 내부 모듈<br/>@/constants, @/services"]
    D --> E["4. 상대 경로 import<br/>../components, ./utils"]
    E --> F["5. 스타일 파일<br/>CSS, SCSS 파일"]
    
    classDef importStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef rootStyle fill:#e2e8f0,stroke:#334155,stroke-width:3px,color:#1e293b
    
    class A rootStyle
    class B,C,D,E,F importStyle
```

### Import 순서

```typescript
import React, { useState, useEffect } from 'react';
import { useSelector } from 'react-redux';
import axios from 'axios';

import { API_ENDPOINTS } from '@/constants';
import { UserService } from '@/services';

import { Button } from '../components';
import './styles.css';
```

## 코드 품질 기준

```mermaid
%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph TB
    subgraph rules ["함수 작성 규칙"]
        A["한 가지 일만 수행<br/>Single Responsibility"]
        B["함수 길이 50줄 이하<br/>가독성 향상"]
        C["매개변수 3개 이하<br/>복잡성 감소"]
        D["복잡도 10 이하<br/>Cyclomatic Complexity"]
    end
    
    classDef ruleStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    
    class A,B,C,D ruleStyle

// 모든 비동기 함수는 try-catch 사용
try {
  const data = await fetchData();
  return { success: true, data };
} catch (error) {
  console.error('Error fetching data:', error);
  return { success: false, error: error.message };
}

/**
 * 사용자 인증 토큰을 검증합니다.
 * @param token - JWT 토큰
 * @returns 토큰이 유효한지 여부
 */
const validateToken = (token: string): boolean => {
  // TODO(#123): 토큰 만료 시간 검증 로직 추가
  return jwt.verify(token, SECRET_KEY);
}

## 개발 환경

### 필수 도구
- Node.js 18.0 이상
- pnpm 8.0 이상 (npm 대신 사용)
- VS Code + 추천 확장 프로그램

### 초기 설정 스크립트
# 의존성 설치
pnpm install

# 환경 변수 설정
cp .env.example .env

# 데이터베이스 마이그레이션
pnpm db:migrate

# 개발 서버 시작
pnpm dev

## 코드 리뷰 가이드라인

### PR 작성 규칙
1. 제목: `[타입] 간단한 설명`
2. 본문 필수 포함 사항
   - 변경 사항 요약
   - 관련 이슈 번호
   - 테스트 방법
   - 스크린샷 (UI 변경 시)

### 리뷰 체크리스트
- [ ] 코드가 프로젝트 컨벤션을 따르는가?
- [ ] 테스트가 충분히 작성되었는가?
- [ ] 성능 영향은 고려되었는가?
- [ ] 보안 취약점은 없는가?
- [ ] 문서는 업데이트되었는가?

### 머지 기준
- 최소 1명의 승인 필요
- 모든 CI 체크 통과
- 충돌 해결 완료

### 브랜치 전략

체계적인 Git 브랜치 관리를 위한 전략과 규칙을 정의합니다. Git Flow를 기반으로 한 실용적인 브랜치 전략을 소개합니다.

## Git 브랜치 전략

### 브랜치 명명 규칙
- feature/기능명: 새 기능 개발
- fix/이슈번호: 버그 수정
- hotfix/설명: 긴급 수정
- refactor/대상: 리팩토링

### 브랜치 플로우
main
  ├── develop
  │     ├── feature/user-auth
  │     ├── feature/payment
  │     └── fix/123
  └── hotfix/critical-bug

### 머지 전략
- feature → develop: Squash merge
- develop → main: Merge commit
- hotfix → main: Cherry-pick

# E-Commerce Project Guidelines for Claude Code

## 프로젝트 개요
대규모 전자상거래 플랫폼 (일 100만 MAU)

## 핵심 기술 스택
- Frontend: Next.js 14, TypeScript, Tailwind CSS
- State: Zustand + React Query
- Backend: Node.js, Express, PostgreSQL
- Infrastructure: AWS, Docker, K8s

## 도메인 지식

### 비즈니스 용어
- SKU: Stock Keeping Unit (재고 관리 코드)
- GMV: Gross Merchandise Volume (총 거래액)
- AOV: Average Order Value (평균 주문 금액)
- Cart Abandonment: 장바구니 이탈

### 핵심 도메인 모델
```typescript
interface Product {
  id: string;
  sku: string;
  name: string;
  price: Money;
  inventory: Inventory;
  category: Category;
}

interface Order {
  id: string;
  userId: string;
  items: OrderItem[];
  status: OrderStatus;
  payment: Payment;
  shipping: Shipping;
}
```

## 성능 요구사항
- 페이지 로드: 3초 이내
- API 응답: 200ms 이내
- 99.9% 가용성

## 보안 규칙
- 모든 사용자 입력 검증
- SQL Injection 방지
- XSS 방지
- 민감 정보 암호화

## 테스트 전략
- 단위 테스트: 80% 커버리지
- 통합 테스트: 핵심 플로우
- E2E 테스트: 구매 플로우

## 배포 프로세스
1. feature 브랜치에서 개발
2. PR 생성 및 리뷰
3. develop 브랜치 머지
4. 스테이징 자동 배포
5. QA 검증
6. 프로덕션 배포 (승인 필요)

## Claude Code 특별 지침
- 성능을 항상 고려하여 코드 작성
- 확장 가능한 아키텍처 유지
- 마이크로서비스 경계 준수
- 비동기 처리 우선
- 에러 로깅 필수

# CLAUDE.md

## 🚨 중요 규칙 (항상 준수)
- 절대 main 브랜치에 직접 푸시 금지
- 모든 API 키는 환경 변수로
- 테스트 없는 코드 커밋 금지

## 📋 일반 가이드라인
- 가능하면 함수형 프로그래밍
- 주석은 최소화, 코드로 설명

## 💡 권장사항
- 새로운 라이브러리 도입 전 팀 논의
- 성능 최적화는 측정 후 진행 

# CLAUDE.md 업데이트 시 Claude Code에게 알리기
claude "CLAUDE.md 파일이 업데이트되었어. 
새로운 규칙들을 확인하고 요약해줘"

# 월간 CLAUDE.md 리뷰
claude "지난 한 달간 우리 팀의 개발 패턴을 분석해서
CLAUDE.md에서 개선이 필요한 부분을 찾아줘"

# 규칙 효과성 분석
claude "현재 CLAUDE.md 규칙들이 실제로 잘 지켜지고 있는지
코드베이스를 분석해서 준수율을 보고해줘"

# 새로운 규칙 제안
claude "최근 발생한 버그들을 분석해서
예방할 수 있는 새로운 규칙을 제안해줘"

# Node.js 버전 확인
node --version

# npm 버전 확인
npm --version

# Git 설치 확인 (선택사항이지만 권장)
git --version

# Claude Code 설치
npm install -g @anthropic-ai/claude-code

# 설치 확인
claude --version

# Homebrew tap 추가
brew tap anthropic-ai/claude-code

# Claude Code 설치
brew install claude-code

# 설치 확인
claude --version

# 터미널 권한 설정 (필요한 경우)
# 시스템 환경설정 > 보안 및 개인정보 > 개인정보 > 전체 디스크 접근 권한
# Terminal.app 또는 사용 중인 터미널 앱 추가

# Spotlight 검색 제외 (선택사항)
# .claude-code 디렉토리를 Spotlight 검색에서 제외하여 성능 향상

# WSL 설치 (Ubuntu 22.04 LTS 기본 포함)
wsl --install

# 설치 후 시스템 재부팅

# WSL 2로 업그레이드
wsl --set-version Ubuntu 2

# 설치 상태 확인
wsl --status
wsl --list --verbose

# NVM 설치
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

# 변경사항 적용
source ~/.bashrc

# Node.js 18 LTS 설치 및 사용
nvm install 18
nvm use 18

# 설치 확인
node --version
npm --version

# Claude Code 설치
npm install -g @anthropic-ai/claude-code

# 설치 확인
claude --version

# 시스템 패키지 업데이트
sudo apt update && sudo apt upgrade

# Node.js 설치 (아직 없는 경우)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install nodejs

# Claude Code 설치
sudo npm install -g @anthropic-ai/claude-code

# 설치 확인
claude --version

# 권한 설정 (필요한 경우)
sudo chmod +x /usr/local/bin/claude

# API 키 설정 명령어 실행
claude login

# 프롬프트가 나타나면 복사한 API 키를 붙여넣기
# (키를 입력할 때는 화면에 표시되지 않는 것이 정상입니다)

# 첫 인사 (Claude가 답변하면 성공!)
claude "안녕하세요, Claude! 처음 뵙겠습니다."

# 간단한 작업 요청해보기
claude "현재 시스템 정보를 알려주세요"

# 디렉토리 탐색해보기
claude "현재 폴더에 어떤 파일들이 있는지 보여주세요"

claude "package.json 파일을 읽고 요약해줘"

# 대화형 모드 시작
claude

# 이제 지속적으로 대화 가능
> 새로운 React 프로젝트를 시작하고 싶어
> TypeScript를 사용하고, 테스트 환경도 설정해줘
> Material-UI도 추가해줘

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph LR
    subgraph interactive ["대화형 모드의 장점"]
        A["컨텍스트 유지<br/>이전 대화 내용 기억"]
        B["단계적 개선<br/>점진적 요구사항 조정"]
        C["효율적 협업<br/>대화를 통한 구체화"]
        
        A --> B
        B --> C
        C --> A
    end
    
    classDef advantageStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    
    class A,B,C advantageStyle

{
  "api_key": "sk-ant-...",              // API 인증 키
  "default_model": "claude-3-opus-20240229", // 기본 사용 모델
  "theme": "dark",                       // 인터페이스 테마 (dark/light)
  "editor": "vscode",                    // 선호 에디터
  "auto_commit": false,                  // 자동 커밋 여부
  "language": "ko",                      // 기본 언어 설정
  "permissions": {
    "file_write": true,                  // 파일 쓰기 권한
    "file_read": true,                   // 파일 읽기 권한
    "command_execution": true            // 명령 실행 권한
  }
}

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph TB
    subgraph permissions ["권한 유형별 설명"]
        direction TB
        A["file_read<br/>프로젝트 파일 읽기<br/>코드 분석, 리뷰에 필수"]
        B["file_write<br/>파일 생성 및 수정<br/>개발 작업에 필수"]
        C["command_execution<br/>시스템 명령 실행<br/>빌드, 테스트 등에 필요"]
        
        A --> B
        B --> C
    end
    
    classDef permissionStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C permissionStyle

# 모든 권한 허용 (개발 환경, 주의 필요)
claude --dangerously-skip-permissions

# 특정 도구만 허용 (settings.json에서 설정)
# allowedTools / disallowedTools 필드 사용

# 권한 확인 모드 (기본값 — 위험 작업 시 사용자 확인)
claude

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph LR
    subgraph editors ["지원되는 에디터"]
        A["Visual Studio Code<br/>가장 완전한 통합 지원"]
        B["Vim/Neovim<br/>터미널 기반 워크플로우"]
        C["JetBrains IDEs<br/>IntelliJ, PyCharm 등"]
        D["Sublime Text<br/>경량 에디터"]
    end
    
    classDef editorStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    
    class A,B,C,D editorStyle

# VSCode 통합
claude config set editor vscode

# Vim 통합
claude config set editor vim

# 에디터에서 직접 Claude Code 호출
# VSCode: Cmd+Shift+P > "Claude: Ask"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
flowchart TD
    A["프록시 설정이 필요한 경우"]
    
    A --> B["회사 방화벽 뒤에서<br/>작업하는 경우"]
    A --> C["VPN을 통해 회사 네트워크에<br/>연결된 경우"]
    A --> D["특정 보안 정책이 적용된<br/>네트워크 환경"]
    
    classDef caseStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef rootStyle fill:#e2e8f0,stroke:#334155,stroke-width:3px,color:#1e293b
    
    class A rootStyle
    class B,C,D caseStyle

# HTTP 프록시 설정
export HTTP_PROXY=http://proxy.company.com:8080
export HTTPS_PROXY=http://proxy.company.com:8080

# Claude Code 전용 프록시 설정
claude config set proxy http://proxy.company.com:8080

# 1단계: npm 전역 경로 확인
npm config get prefix

# 2단계: PATH에 추가 (bash/zsh)
echo 'export PATH="$PATH:$(npm config get prefix)/bin"' >> ~/.bashrc
source ~/.bashrc

# 3단계: 설치 확인
claude --version

# 방법 1: 권한 수정 (권장)
sudo chown -R $(whoami) $(npm config get prefix)/{lib/node_modules,bin,share}

# 방법 2: npx를 통한 실행 (임시 해결)
npx @anthropic-ai/claude-code

# 방법 3: npm 전역 디렉토리 변경
mkdir ~/.npm-global
npm config set prefix '~/.npm-global'
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

# 1단계: 현재 상태 확인
claude status

# 2단계: 자동 재시도 간격 설정 (밀리초)
claude config set retry_delay 5000

# 3단계: 최대 재시도 횟수 설정
claude config set max_retries 3

# ⚠️ 임시 해결책 (보안 위험 있음)
export NODE_TLS_REJECT_UNAUTHORIZED=0

# ✅ 권장 해결책: 회사 인증서 설치
# 1단계: IT 부서에서 인증서 파일 받기
# 2단계: npm에 인증서 등록
npm config set cafile /path/to/company-cert.pem

# 3단계: Claude Code 전용 설정
claude config set tls_verify true
claude config set ca_bundle /path/to/company-cert.pem

# 응답 캐싱 활성화
claude config set cache_enabled true

# 캐시 유지 시간 설정 (초 단위, 기본: 3600초 = 1시간)
claude config set cache_ttl 3600

# 캐시 크기 제한 설정 (MB 단위)
claude config set cache_max_size 100

# 학습 가속화
claude "주니어 개발자의 빠른 성장을 위해 이 작업을 학습 기회로 활용해줘
- 단계별 구현 가이드
- 각 단계에서 배울 수 있는 핵심 개념
- 흔히 하는 실수와 예방법
- 시니어에게 질문할 타이밍과 방법
- 자신의 진전을 측정하는 방법

단순히 정답을 주기보다는 사고 과정을 기를 수 있도록 안내해줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
flowchart TD
    A[Explore<br/>코드베이스 이해] --> B[Plan<br/>접근 방법 설계]
    B --> C[Code<br/>구현 및 테스트]
    C --> D[Commit<br/>검증 및 커밋]
    D --> A
    
    E[체계적 분석<br/>아키텍처 파악<br/>기술 부채 식별] -.-> A
    F[구현 전략 수립<br/>작업 분해<br/>리스크 평가] -.-> B
    G[점진적 구현<br/>TDD 적용<br/>통합 테스트] -.-> C
    H[코드 검증<br/>커밋 메시지<br/>품질 확인] -.-> D
    
    classDef primaryStyle fill:#e2e8f0,stroke:#334155,stroke-width:3px,color:#1e293b
    classDef detailStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C,D primaryStyle
    class E,F,G,H detailStyle

# 고수준 아키텍처 이해
claude "이 프로젝트의 전체 아키텍처를 분석해줘.
- 마이크로서비스 vs 모놀리식 구조
- 주요 도메인과 경계
- 데이터 흐름과 의존성 방향
- 외부 시스템과의 통합 지점
- 보안 경계와 인증 방식"

# 기술 스택 심층 분석
claude "사용된 기술 스택을 종합적으로 분석해줘.
- 프론트엔드: 프레임워크, 상태 관리, 빌드 도구
- 백엔드: 언어, 프레임워크, ORM, 미들웨어
- 데이터베이스: 타입, 버전, 스키마 설계 패턴
- 인프라: 컨테이너화, 오케스트레이션, 모니터링
- 각 기술 선택의 이유와 장단점 분석"

# 코드 품질과 컨벤션 평가
claude "프로젝트의 코드 품질과 개발 관행을 평가해줘.
- 네이밍 규칙과 일관성 확인
- 파일/폴더 구조 패턴
- 테스트 커버리지와 전략
- 문서화 수준과 품질
- CI/CD 파이프라인 구성
- 코드 리뷰 프로세스 흔적"

# 비즈니스 크리티컬 기능 분석
claude "사용자 인증 및 권한 관리 시스템을 종합 분석해줘.
- 인증 플로우 (로그인, 토큰 관리, 세션)
- 권한 부여 메커니즘 (RBAC, ABAC)
- 보안 고려사항 (암호화, 검증)
- 프론트엔드-백엔드 연동 방식
- 에러 처리와 사용자 경험
- 확장 가능성과 개선점"

# 데이터 흐름과 상태 관리
claude "애플리케이션의 데이터 흐름을 추적하고 분석해줘.
- 사용자 입력부터 데이터 저장까지의 전체 경로
- 클라이언트 사이드 상태 관리 패턴
- 서버 사이드 데이터 처리 로직
- 캐싱 전략과 성능 최적화
- 데이터 일관성과 동시성 처리"

# 성능과 확장성 분석
claude "시스템의 성능 특성과 확장성을 분석해줘.
- 현재 성능 병목 지점 식별
- 트래픽 처리 능력과 한계
- 데이터베이스 쿼리 패턴과 최적화 기회
- 메모리 사용 패턴과 가비지 컬렉션
- 확장 전략 (수평적 vs 수직적)"

# 기술 부채 평가
claude "코드베이스의 기술 부채를 종합 평가해줘.
- 구식 라이브러리와 보안 취약점
- 중복 코드와 리팩토링 필요 영역
- 복잡도가 높은 모듈과 함수
- 테스트가 부족한 크리티컬 영역
- 문서화 부족으로 인한 유지보수 어려움
- 우선순위별 개선 로드맵 제안"

# 아키텍처 진화 가능성
claude "현재 아키텍처의 발전 방향을 제안해줘.
- 마이크로서비스 분해 가능성
- 새로운 기술 스택 도입 기회
- 성능 개선을 위한 아키텍처 변경
- 확장성 향상 방안
- 비용 최적화 기회"

### 2단계: Plan (계획)

**구현 전략 수립**

```bash
claude "장바구니 기능을 추가하려고 해. 
현재 아키텍처를 고려해서 구현 계획을 세워줘.
필요한 컴포넌트, API 엔드포인트, 데이터 모델을 포함해줘"

claude "이 기능을 구현하기 위한 작업을 단계별로 나눠줘.
각 단계는 독립적으로 테스트 가능해야 하고,
예상 소요 시간도 추정해줘"

claude "이 변경사항이 기존 코드에 미칠 영향을 분석해줘.
잠재적인 문제점과 해결 방안을 제시해줘"

# 스켈레톤 코드 생성
claude "계획에 따라 기본 구조를 먼저 만들어줘.
인터페이스와 빈 메서드로 시작해서 단계적으로 구현할 수 있도록"

# 핵심 로직 구현
claude "이제 핵심 비즈니스 로직을 구현해줘.
단위 테스트도 함께 작성해서 동작을 검증해줘"

# 통합 및 연결
claude "구현한 기능을 기존 시스템과 통합해줘.
필요한 어댑터나 미들웨어도 작성해줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
flowchart TD
    A["전체 구조 파악 전략"]
    
    A --> B["프로젝트 개요 파악<br/>• 구조 트리 시각화<br/>• 기술 스택 분석"]
    A --> C["핵심 디렉토리 탐색<br/>• src 폴더 상세 분석<br/>• 설정 파일 분류"]
    A --> D["파일 패턴 분석<br/>• 파일 타입별 그룹핑<br/>• 테스트 구조 파악"]
    A --> E["최근 활동 추적<br/>• 변경사항 분석<br/>• 핵심 로직 위치 파악"]
    
    classDef strategyStyle fill:#e2e8f0,stroke:#334155,stroke-width:3px,color:#1e293b
    classDef stepStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A strategyStyle
    class B,C,D,E stepStyle

# 단일 파일 읽기
claude "package.json 파일을 읽어줘"

# 여러 파일 동시에 읽기
claude "모든 설정 파일들(config로 시작하는)을 읽고 요약해줘"

# 특정 부분만 읽기
claude "app.js 파일에서 라우터 설정 부분만 보여줘"

# 파일 비교
claude "개발 환경과 프로덕션 환경 설정 파일을 비교해줘"

# 함수 분석
claude "calculateTotalPrice 함수가 어떻게 동작하는지 설명해줘"

# 의존성 분석
claude "이 프로젝트가 사용하는 주요 라이브러리들과 용도를 설명해줘"

# 아키텍처 분석
claude "이 프로젝트의 전체적인 아키텍처를 다이어그램으로 설명해줘"

# 보안 취약점 검사
claude "보안상 문제가 될 수 있는 코드가 있는지 검사해줘"

# 기본적인 파일 생성
claude "utils 폴더에 날짜 관련 유틸리티 함수들을 만들어줘"

# 템플릿 기반 생성
claude "Express 라우터 템플릿으로 user 라우터를 만들어줘"

# 테스트 파일 자동 생성
claude "UserService에 대한 Jest 테스트 파일을 만들어줘"

# 문서 생성
claude "API 엔드포인트 문서를 Swagger 형식으로 만들어줘"

# ES5를 ES6+ 문법으로 업그레이드
claude "모든 var를 const나 let으로 바꿔줘. 재할당되는 변수만 let을 사용해"

# 콜백을 async/await로 변환
claude "콜백 기반 코드를 async/await 패턴으로 변경해줘"

# 문자열 연결을 템플릿 리터럴로
claude "문자열 연결 연산자(+)를 템플릿 리터럴로 바꿔줘"

# 긴 함수 분리
claude "이 함수가 50줄이 넘는데, 논리적 단위로 분리해서 가독성을 높여줘"

# 중복 코드 제거
claude "중복되는 코드를 찾아서 재사용 가능한 함수로 추출해줘"

# 조건문 단순화
claude "복잡한 if-else 체인을 early return 패턴이나 switch문으로 개선해줘"

# 에러 처리 추가
claude "이 API 호출 함수에 적절한 에러 처리와 재시도 로직을 추가해줘"

# 로딩 상태 관리
claude "이 컴포넌트에 로딩, 성공, 에러 상태를 관리하는 로직을 추가해줘"

# 유효성 검사 추가
claude "사용자 입력 폼에 실시간 유효성 검사를 추가해줘"

# 잠재적 오류 찾기
claude "null/undefined 참조 오류가 발생할 수 있는 부분을 찾아서 옵셔널 체이닝으로 수정해줘"

# 메모리 누수 방지
claude "이벤트 리스너나 타이머가 제대로 정리되지 않는 부분을 찾아서 수정해줘"

# 경쟁 조건 해결
claude "비동기 작업에서 경쟁 조건이 발생할 수 있는 부분을 찾아서 수정해줘"

# 포매팅
claude "프로젝트 전체를 Prettier 규칙에 맞게 포매팅해줘"

# 네이밍 컨벤션
claude "camelCase를 snake_case로 변경해줘"

# 주석 추가
claude "복잡한 로직에 설명 주석을 추가해줘"

# 타입 추가
claude "JavaScript 파일에 TypeScript 타입을 추가해줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph LR
    subgraph structure ["Claude Code 명령어 구조"]
        A["claude<br/>기본 명령어"] --> B["[옵션]<br/>동작 방식 제어 플래그"]
        B --> C["[명령/질문]<br/>자연어로 작성하는 요청"]
    end
    
    classDef commandStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef optionStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A commandStyle
    class B,C optionStyle

# 도움말 보기 - 사용 가능한 모든 명령어와 옵션 확인
claude --help
claude -h

# 버전 확인 - 현재 설치된 Claude Code 버전 확인
claude --version
claude -v

# 대화 기록 지우기 - 새로운 컨텍스트로 시작하고 싶을 때
claude --clear
claude -c

# 복잡한 작업을 위한 고성능 모델 사용
claude --model claude-3-opus "복잡한 알고리즘 구현해줘"

# 빠른 응답이 필요한 간단한 작업
claude -m claude-3-haiku "간단한 설명만 해줘"

# 균형잡힌 성능과 속도
claude -m claude-3-sonnet "코드 리뷰해줘"

# JSON 형식으로 구조화된 데이터 받기
claude --json "프로젝트 구조를 JSON으로 출력해줘"

# 마크다운 형식으로 문서 생성
claude --markdown "README 파일 내용을 마크다운으로 보여줘"

# 일반 텍스트 출력 (기본값)
claude --plain "간단한 설명을 텍스트로 보여줘"

# 기술적인 요청
claude "UserService 클래스에 이메일 검증 메서드를 추가해줘"

# 탐색적인 질문
claude "이 프로젝트에서 인증은 어떻게 처리되고 있어?"

# 창의적인 요청
claude "이 함수를 더 효율적으로 만들 수 있는 방법이 있을까?"

# 복합적인 작업
claude "버그를 찾아서 수정하고, 테스트도 작성한 다음, 커밋 메시지까지 만들어줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
mindmap
  root((학습 목표))
    멀티 인스턴스 관리
      효과적인 역할 분담
      컨텍스트 최적화
      작업 동기화
    병렬 개발 환경
      Git Worktree 활용
      독립적 개발 공간
      브랜치별 특화 설정
    마이크로서비스 개발
      서비스별 전문화
      동시 개발 전략
      통합 관리
    정보 공유 최적화
      컨텍스트 관리
      인스턴스 간 협업
      지식 동기화

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph TD
    subgraph core [핵심 개발 영역]
        A[Frontend Studio<br/>인스턴스 #1<br/>UX/UI 전문가] 
        B[Backend Engine<br/>인스턴스 #2<br/>시스템 아키텍트]
    end
    
    subgraph ops [운영 및 품질 관리]
        C[DevOps Pipeline<br/>인스턴스 #3<br/>클라우드 네이티브 전문가]
        D[QA & Monitoring<br/>인스턴스 #4<br/>품질 보증 전문가]
    end
    
    subgraph integration [통합 관리]
        E[Integration Hub<br/>인스턴스 #5<br/>아키텍처 조정자]
    end
    
    A <--> B
    A --> C
    B --> C
    C <--> D
    A --> E
    B --> E
    C --> E
    D --> E
    
    F[크로스 도메인 이슈 해결] -.-> E
    G[아키텍처 일관성 검증] -.-> E
    H[팀 간 커뮤니케이션 조정] -.-> E
    
    classDef coreStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef opsStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef hubStyle fill:#cbd5e1,stroke:#475569,stroke-width:3px,color:#1e293b
    classDef activityStyle fill:#f8fafc,stroke:#94a3b8,stroke-width:1px,color:#64748b
    
    class A,B coreStyle
    class C,D opsStyle
    class E hubStyle
    class F,G,H activityStyle

# 건전한 AI 의존성 관리
claude "팀의 AI 의존성을 건전하게 관리하는 전략을 수립해줘.
현재 상황 분석
- 팀원별 Claude 활용 패턴과 의존도
- AI 없이 개발할 수 있는 역량 수준
- 창의적 문제 해결 능력의 변화
- 기본적인 코딩 스킬 유지 상태
- 비판적 사고와 설계 능력 발전도

균형 잡힌 개발 전략
- 주간 'AI-Free Development' 시간 운영
- 기본 원리 이해 중심의 학습 프로그램
- 알고리즘과 자료구조 정기 스터디
- 화이트보드 코딩과 페어 프로그래밍
- 설계 사고와 아키텍처 역량 강화"

# 개인별 맞춤형 역량 강화
claude "팀원별로 AI와의 건전한 협업 방식을 개발해줘.
신입 개발자: 기본기 우선, AI는 보조 도구로 활용
- 핵심 개념 이해 후 AI 활용 허용
- 단계별 도움 요청보다는 전체 맥락 학습
- 디버깅과 문제 해결 능력 우선 개발
- AI 제안에 대한 비판적 평가 능력 배양

시니어 개발자: AI를 창의성 증폭 도구로 활용
- 아키텍처 설계와 전략적 의사결정 주도
- AI를 통한 대안 탐색과 검증
- 복잡한 문제의 구조화와 분해
- 팀 전체의 AI 활용 가이드라인 제시"

# 고도화된 품질 보장 시스템
claude "AI 생성 코드의 품질 일관성을 보장하는 시스템을 구축해줘.
다층적 품질 검증
- AI 코드 생성 시 자동 품질 체크
- 피어 리뷰에서의 AI 특화 검증 항목
- 정적 분석과 동적 테스트 강화
- 코드 패턴 일관성 자동 검증
- 장기적 유지보수성 평가

진화하는 리뷰 문화
- AI 활용 과정의 투명성 확보
- 설계 결정과 트레이드오프 문서화
- 학습 중심의 건설적 피드백
- 코드 품질 표준의 지속적 개선
- 팀 전체의 집단 지혜 활용"

# 품질 메트릭 자동화
claude "AI 기반 개발의 품질을 자동으로 추적하는 시스템을 만들어줘.
실시간 품질 지표
- 코드 복잡도와 가독성 점수
- 테스트 커버리지와 테스트 품질
- 보안 취약점과 성능 이슈
- 문서화 완성도와 최신성
- 팀 코딩 스타일 일관성

품질 트렌드 분석
- 시간에 따른 품질 지표 변화
- AI 활용도와 품질의 상관관계
- 개인별/프로젝트별 품질 패턴
- 리팩토링 필요성 예측
- 기술 부채 누적 방지 알림"

# 팀 내 AI 활용 격차 해소
claude "팀원 간 Claude 활용 능력 차이를 줄이는 전략을 수립해줘.
현재 상태 진단
- 팀원별 AI 활용 숙련도 평가
- 생산성 격차와 영향 요인 분석
- 협업 패턴과 지식 공유 수준
- 학습 의욕과 변화 수용성 측정
- 멘토링 네트워크와 지원 체계

격차 해소 프로그램
- 단계별 AI 활용 교육 커리큘럼
- 버디 시스템과 1:1 멘토링
- 실전 프로젝트 기반 학습
- 정기적인 활용법 공유 세션
- 개인별 맞춤형 피드백과 지도"

# 협업 시너지 극대화
claude "AI를 활용한 팀 협업의 시너지를 극대화하는 방법을 제시해줘.
협업 패턴 최적화
- 역할별 AI 활용 전략 차별화
- 크로스 펑셔널 팀워크 강화
- 지식 공유와 집단 학습 촉진
- 의사결정 과정의 투명성 확보
- 창의성과 혁신 문화 조성

조직 차원의 변화 관리
- 리더십의 AI 전략과 비전 제시
- 성과 평가 시스템의 적응
- 인센티브와 동기부여 체계
- 지속적 학습 문화 구축
- 실패에 대한 관용과 실험 정신"

# AI 서비스 중단 시 대응 계획
claude "Claude Code 서비스 중단 상황에 대비한 팀 대응 매뉴얼을 작성해줘.
즉시 대응 (1-2시간)
- 핵심 업무 우선순위 재조정
- 대체 개발 방법론으로 전환
- 진행 중인 작업의 저장과 백업
- 팀 커뮤니케이션 방식 조정
- 고객과 이해관계자 상황 공유

단기 대응 (1-3일)
- 수동 개발 프로세스 활성화
- 기존 코드와 문서 최대 활용
- 팀원 간 지식 공유 강화
- 외부 도구와 리소스 활용
- 업무 일정과 마일스톤 조정

장기 대응 (1주 이상)
- 대체 AI 도구 평가와 도입
- 프로세스 개선과 자동화 강화
- 팀 스킬 다양화와 역량 강화
- 의존성 분산 전략 수립
- 복구 후 개선 방안 준비"

# 팀 탄력성 강화
claude "예상치 못한 변화에 대한 팀의 적응력을 강화하는 방법을 제시해줘.
탄력성 구축 요소
- 다양한 기술과 도구에 대한 경험
- 문제 해결 접근법의 다각화
- 팀원 간 스킬 중복과 백업
- 지속적 학습과 적응 문화
- 변화에 대한 긍정적 마인드셋

실무 적용 방안
- 정기적인 기술 스택 다양화 실험
- 로테이션과 크로스 트레이닝
- 위기 시뮬레이션과 대응 훈련
- 외부 네트워크와 커뮤니티 참여
- 혁신과 실험을 장려하는 문화"

# 상태 확인
claude "git 상태를 확인하고 변경사항을 요약해줘"

# 스테이징
claude "수정된 파일 중 테스트 관련 파일만 스테이징해줘"

# 커밋
claude "의미 있는 커밋 메시지를 작성해서 커밋해줘"

# 브랜치 관리
claude "새로운 기능을 위한 브랜치를 만들고 체크아웃해줘"

# 대화형 리베이스
claude "최근 3개 커밋을 정리해서 하나로 합쳐줘"

# 충돌 해결
claude "머지 충돌을 해결해줘. 두 변경사항을 모두 유지하는 방향으로"

# 히스토리 분석
claude "이 버그가 언제 도입됐는지 git bisect로 찾아줘"

# 체리픽
claude "hotfix 브랜치의 버그 수정 커밋만 main으로 체리픽해줘"

# PR 생성
claude "이 기능에 대한 Pull Request를 생성해줘. 
변경사항을 요약하고, 테스트 방법도 포함해줘"

# 코드 리뷰 대응
claude "리뷰어가 지적한 사항들을 수정하고 답변을 작성해줘"

# PR 템플릿 활용
claude "프로젝트의 PR 템플릿에 맞춰서 설명을 작성해줘"

# CLAUDE.md

## 🚨 중요 규칙 (항상 준수)
- 절대 main 브랜치에 직접 푸시 금지
- 모든 API 키는 환경 변수로
- 테스트 없는 코드 커밋 금지

## 📋 일반 가이드라인
- 가능하면 함수형 프로그래밍
- 주석은 최소화, 코드로 설명

## 💡 권장사항
- 새로운 라이브러리 도입 전 팀 논의
- 성능 최적화는 측정 후 진행

개인 학습/사이드 프로젝트
  → Pro 플랜 ($20/월)
  → 일반적인 개인 개발에 충분

본격적인 개인 프로젝트
  → Max 플랜 ($100/월)
  → Opus 모델 + 높은 사용량 한도

소규모 팀 (2~10명)
  → Team 플랜 ($30/인/월)
  → 팀 설정 공유, 일관된 코딩 컨벤션

기업/대규모 조직
  → Enterprise (커스텀 가격)
  → SSO, 감사 로그, 전용 지원

# 큰 프로젝트의 경우 컨텍스트 확대
claude config set max_context_length 100000

# 작은 프로젝트나 빠른 응답이 필요한 경우
claude config set max_context_length 50000

# 현재 설정 확인
claude config get max_context_length

개발자 = 코드 작성자
- 문법과 API 암기
- 반복적인 보일러플레이트 작성
- 스택오버플로우 검색
- 혼자서 모든 문제 해결

개발자 = 문제 해결자 + 아키텍트 + 멘토
- 비즈니스 문제 이해와 해결
- 시스템 설계와 아키텍처
- AI와의 협업을 통한 효율적 구현
- 팀과 AI를 이끄는 리더십

인간의 창의성 + AI의 효율성 = 무한한 가능성

# 변하지 않는 것들
- 알고리즘과 자료구조
- 시스템 설계 원칙
- 문제 해결 사고력
- 커뮤니케이션 능력

# 새롭게 필요한 것들
- AI와의 효과적인 소통 능력
- 프롬프트 엔지니어링 스킬
- 도메인 전문 지식
- 창의적 사고와 혁신 능력

# 실험해야 할 것들
- 새로운 AI 도구와 플랫폼
- 혁신적인 개발 워크플로우
- 팀 협업 방식의 변화
- 자동화 가능한 작업 영역

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
mindmap
  root((학습 목표))
    전략 수립
      프레임워크별 특성 이해
      최적화된 활용 전략
      개발 패턴 정립
    주요 프레임워크
      React/Next.js 마스터
      Node.js/Express 활용
      Django 개발 패턴
    코드 품질 관리
      CLAUDE.md 설정
      일관된 품질 유지
      팀 협업 규칙
    마이그레이션
      프레임워크 전환 지원
      효과적 활용 방법
      실전 적용 능력

# Vite를 사용한 React 프로젝트 생성
claude "Vite로 새로운 React TypeScript 프로젝트를 만들어줘. 
Tailwind CSS, React Router, React Query를 포함하고,
폴더 구조도 모범 사례에 따라 설정해줘"

src/
├── components/
│   ├── common/        # Button, Input 등 공통 컴포넌트
│   ├── features/      # 기능별 컴포넌트
│   └── layouts/       # Header, Footer 등
├── hooks/            # 커스텀 훅
├── pages/            # 라우트별 페이지 컴포넌트
├── services/         # API 통신
├── store/            # 전역 상태 관리
├── utils/            # 유틸리티 함수
└── types/            # TypeScript 타입 정의

# 기본 컴포넌트 생성
claude "UserProfile 컴포넌트를 만들어줘. 
프로필 이미지, 이름, 소개를 표시하고,
편집 모드를 지원해야 해. 
Storybook 스토리와 테스트 코드도 함께 작성해줘"

# 고급 데이터 테이블 컴포넌트
claude "DataTable 컴포넌트를 만들어줘.
- 정렬, 필터링, 페이지네이션 지원
- 선택 가능한 행과 대량 작업
- 가상 스크롤링으로 성능 최적화
- TypeScript 제네릭으로 타입 안전성 보장
- 접근성(a11y) 준수"

# 복잡한 폼 컴포넌트
claude "MultiStepForm 컴포넌트를 만들어줘.
- React Hook Form과 Zod 검증 통합
- 단계별 진행 표시와 네비게이션
- 자동 저장과 임시 저장 기능
- 오류 상태 처리와 사용자 피드백
- 각 단계별 조건부 필드 표시"

# 인증 상태 관리
claude "사용자 인증 상태를 전역으로 관리하는 
Context와 커스텀 훅을 만들어줘.
로그인, 로그아웃, 토큰 갱신 기능이 필요해"

# 복잡한 비즈니스 로직 상태 관리
claude "전자상거래 장바구니 상태 관리를 구현해줘.
- Zustand로 상태 저장소 구성
- 상품 추가/제거/수량 변경 로직
- 할인 쿠폰 적용과 가격 계산
- 로컬스토리지 동기화
- 비관적/낙관적 업데이트 처리"

# 서버 상태와 캐싱
claude "React Query를 활용한 서버 상태 관리를 설정해줘.
- API 응답 캐싱 전략
- 백그라운드 리페칭과 스테일 타임 설정
- 무한 스크롤 데이터 페칭
- 에러 재시도 로직과 오프라인 지원"

# 리렌더링 최적화
claude "이 컴포넌트의 불필요한 리렌더링을 방지하도록 
React.memo, useMemo, useCallback을 적용해줘"

# 코드 스플리팅과 지연 로딩
claude "이 애플리케이션에 코드 스플리팅을 적용해줘.
- 라우트 레벨 지연 로딩
- 무거운 컴포넌트의 동적 임포트
- 라이브러리 번들 분리
- 로딩 스피너와 에러 바운더리 추가"

# 대용량 리스트 최적화
claude "10,000개 아이템을 효율적으로 렌더링하는 
가상 스크롤 컴포넌트를 구현해줘.
- react-window 라이브러리 활용
- 동적 아이템 높이 지원
- 무한 스크롤과 페이지네이션 통합"

# 이미지 최적화
claude "이미지 갤러리의 성능을 최적화해줘.
- 지연 로딩과 프리로딩 전략
- WebP 포맷 지원과 폴백
- 이미지 압축과 리사이징
- Progressive loading 구현"

# 종합적인 블로그 시스템
claude "Next.js 14 App Router로 블로그를 만들어줘.
동적 라우팅, 메타데이터 최적화, 
그리고 ISR(Incremental Static Regeneration)을 활용해줘"

# 다국어 지원과 국제화
claude "Next.js에서 다국어 지원을 구현해줘.
- i18n 라우팅 설정
- 서버 컴포넌트에서 번역 처리
- 동적 번역 로딩과 폴백
- SEO 최적화를 위한 hreflang 태그"

# 복잡한 인증 시스템
claude "NextAuth.js로 다중 인증 제공자를 지원하는 시스템을 구현해줘.
- OAuth (Google, GitHub), 이메일, 자격증명 로그인
- 역할 기반 접근 제어 (RBAC)
- 세션 관리와 보안 강화
- API 라우트 보호 미들웨어"

claude "이 페이지를 Server Component로 리팩토링해줘.
데이터 페칭은 서버에서, 인터랙션은 Client Component로 분리해줘"

claude "RESTful API를 Next.js API routes로 구현해줘.
미들웨어로 인증을 처리하고, Zod로 요청 검증을 추가해줘"

# React/Next.js Project Guidelines

## 컴포넌트 규칙
- 함수형 컴포넌트만 사용
- Props는 인터페이스로 정의
- 컴포넌트당 하나의 파일

## 상태 관리
- 로컬 상태: useState
- 서버 상태: React Query (TanStack Query)
- 전역 상태: Zustand

## 폴더 구조

## 성능 최적화
- 이미지는 next/image 사용
- 동적 import로 코드 스플리팅
- Lighthouse 점수 90+ 유지

# 기본 REST API 서버
claude "Express.js로 확장 가능한 REST API 서버를 만들어줘.
계층화된 아키텍처(Controller-Service-Repository)를 사용하고,
TypeScript, JWT 인증, 에러 핸들링, 로깅을 포함해줘"

# 마이크로서비스 패턴
claude "Express로 마이크로서비스 아키텍처를 구현해줘.
- 서비스 간 통신 (HTTP/gRPC)
- API Gateway 패턴
- 서비스 디스커버리와 로드 밸런싱
- 분산 로깅과 트레이싱
- Circuit Breaker 패턴"

# 고성능 API 서버
claude "대용량 트래픽을 처리하는 Express API를 만들어줘.
- 클러스터링과 워커 프로세스 관리
- Redis를 활용한 세션과 캐싱
- 요청 제한과 DDoS 방어
- 데이터베이스 커넥션 풀링
- APM 모니터링 통합"

# GraphQL API 서버
claude "Express에 GraphQL을 통합한 API 서버를 만들어줘.
- Apollo Server 설정
- 스키마 stitching과 federation
- DataLoader를 활용한 N+1 쿼리 방지
- 인증과 권한 부여
- 쿼리 복잡도 제한"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph TD
    A[src/] --> B[controllers/]
    A --> C[services/]
    A --> D[repositories/]
    A --> E[models/]
    A --> F[middleware/]
    A --> G[routes/]
    A --> H[config/]
    A --> I[utils/]
    A --> J[types/]
    A --> K[tests/]
    A --> L[docs/]
    
    B -.-> |HTTP 요청/응답 처리| B1[Request Handler]
    C -.-> |비즈니스 로직| C1[Business Logic]
    D -.-> |데이터 액세스 계층| D1[Data Access]
    E -.-> |데이터 모델과 스키마| E1[Schema Definition]
    F -.-> |인증, 로깅, 검증| F1[Middleware Functions]
    G -.-> |API 라우트 정의| G1[Route Definitions]
    H -.-> |환경 설정| H1[Configuration]
    I -.-> |공통 유틸리티| I1[Utility Functions]
    J -.-> |TypeScript 타입 정의| J1[Type Definitions]
    K -.-> |테스트 파일| K1[Test Suites]
    L -.-> |API 문서| L1[Documentation]

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph LR
    A[Controllers] --> B[Services]
    B --> C[Repositories]
    C --> D[Models]
    
    A1[요청/응답 처리] -.-> A
    B1[비즈니스 로직] -.-> B
    C1[데이터 접근] -.-> C
    D1[데이터 모델] -.-> D
    
    E[Middlewares] -.-> A
    F[Utils] -.-> B
    G[Config] -.-> B
    H[Types] -.-> A
    H -.-> B
    H -.-> C

claude "사용자 관리를 위한 RESTful API를 설계해줘.
CRUD 작업, 페이지네이션, 필터링, 정렬을 지원하고,
OpenAPI(Swagger) 문서도 자동 생성되도록 해줘"

claude "Prisma ORM을 사용해서 User, Post, Comment 모델을 만들어줘.
관계 설정, 마이그레이션, 시드 데이터도 포함해줘"

claude "JWT 기반 인증 시스템을 구현해줘.
액세스 토큰과 리프레시 토큰을 사용하고,
역할 기반 접근 제어(RBAC)도 추가해줘"

claude "이 모놀리식 앱을 마이크로서비스로 분해해줘.
User Service, Product Service, Order Service로 나누고,
API Gateway와 서비스 간 통신 방법도 설계해줘"

# Node.js/Express API Guidelines

## API 설계 원칙
- RESTful 원칙 준수
- 일관된 응답 형식
- 적절한 HTTP 상태 코드 사용

## 응답 형식
```json
{
  "success": true,
  "data": {},
  "message": "Success",
  "timestamp": "2024-01-01T00:00:00Z"
}

## 5.3 Python/Django 애플리케이션

Django는 "battery included" 철학을 기반으로 하는 Python 웹 프레임워크로, 강력한 ORM, 관리자 인터페이스, 그리고 보안 기능을 내장하고 있습니다. Django REST Framework와 함께 사용하면 견고한 API 서버를 빠르게 구축할 수 있으며, Claude Code는 Django의 모범 사례를 준수하는 확장 가능한 애플리케이션 개발을 지원합니다.

### Django 프로젝트 설정

Django 프로젝트의 성공은 초기 설정과 아키텍처 설계에서 결정됩니다. Claude Code는 Django의 앱 기반 모듈화와 설정 관리 모범 사례를 따르는 프로젝트 구조를 생성할 수 있습니다.

```bash
claude "Django REST Framework로 블로그 API를 만들어줘.
사용자 인증, 포스트 CRUD, 댓글, 태그 기능을 포함하고,
테스트 코드와 API 문서화도 설정해줘"

claude "전자상거래를 위한 Django 모델을 설계해줘.
Product, Category, Order, User 모델과 관계를 정의하고,
Admin 인터페이스도 커스터마이징해줘"

claude "Product 모델에 대한 ViewSet과 Serializer를 만들어줘.
필터링, 검색, 정렬을 지원하고,
중첩된 관계도 효율적으로 처리해줘"

claude "Celery를 사용해서 이메일 발송과 
이미지 처리를 비동기로 처리하도록 설정해줘"

# Django Project Guidelines

## 앱 구조
- 기능별로 앱 분리
- 앱당 최대 10개 모델
- 순환 의존성 금지

## 모델 설계
- 모든 모델에 created_at, updated_at
- soft delete 사용 (is_deleted 필드)
- 관계는 명시적으로 정의

## API 설계
- ViewSet 사용 권장
- 커스텀 액션은 @action 데코레이터
- 페이지네이션 기본 20개

## 테스트
- 모델, 뷰, 시리얼라이저 각각 테스트
- Factory Boy로 테스트 데이터 생성
- 커버리지 80% 이상

claude "Expo로 크로스 플랫폼 모바일 앱을 만들어줘.
네비게이션, 상태 관리, 네이티브 기능 접근을 설정하고,
iOS와 Android 스타일 차이도 처리해줘"

claude "React Navigation으로 복잡한 네비게이션을 구현해줘.
Tab Navigator, Stack Navigator, Drawer를 조합하고,
딥링킹도 설정해줘"

claude "카메라와 위치 정보에 접근하는 기능을 구현해줘.
권한 요청 처리와 에러 핸들링도 포함해줘"

claude "Flutter로 Material Design 앱을 만들어줘.
다국어 지원, 다크 모드, 반응형 레이아웃을 포함하고,
Clean Architecture 패턴을 적용해줘"

# Mobile App Guidelines

## 아키텍처
- MVVM 패턴 사용
- 비즈니스 로직은 ViewModel에
- View는 상태만 표시

## 성능
- 리스트는 가상화 필수
- 이미지 최적화 및 캐싱
- 애니메이션 60fps 유지

## 플랫폼별 처리
```javascript
Platform.select({
  ios: { /* iOS 스타일 */ },
  android: { /* Android 스타일 */ }
})

## 5.5 데이터 과학 프로젝트 - MLOps 통합

데이터 과학과 머신러닝 분야는 탐색적 분석에서 프로덕션 배포까지 다양한 단계를 거치는 복잡한 워크플로우를 가지고 있습니다. Claude Code는 데이터 과학자들이 사용하는 주요 도구들과 현대적인 MLOps 파이프라인을 이해하여, 실험부터 배포까지 전체 프로세스를 지원할 수 있습니다.

### 현대적 데이터 과학 스택

데이터 과학 프로젝트의 성공을 위해서는 단순한 분석 도구를 넘어서 재현 가능하고 확장 가능한 MLOps 파이프라인이 필요합니다.

```mermaid
%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph TB
    subgraph "데이터 수집"
        A1[Raw Data] --> A2[Data Pipeline]
        A2 --> A3[Clean Data]
    end
    
    subgraph "실험 및 개발"
        B1[Jupyter Notebooks] --> B2[Feature Engineering]
        B2 --> B3[Model Training]
        B3 --> B4[Experiment Tracking]
    end
    
    subgraph "모델 운영"
        C1[Model Registry] --> C2[API Serving]
        C2 --> C3[Monitoring]
        C3 --> C4[Retraining]
        C4 --> C1
    end
    
    A3 --> B1
    B4 --> C1
    C3 --> A2

claude "머신러닝 프로젝트를 위한 Jupyter 환경을 설정해줘.
데이터 분석, 시각화, 모델 학습 파이프라인을 구축하고,
실험 추적도 설정해줘"

# 기본 데이터 전처리
claude "이 CSV 데이터를 분석하고 전처리해줘.
결측치 처리, 이상치 탐지, 특성 엔지니어링을 수행하고,
각 단계를 시각화해줘"

# 고급 특성 엔지니어링
claude "시계열 데이터의 특성 엔지니어링을 구현해줘.
- 시간 기반 특성 생성 (lag, rolling window)
- 계절성과 트렌드 분해
- Fourier 변환을 통한 주기 특성
- 스케일링과 정규화 파이프라인
- 범주형 변수 인코딩 전략"

# 대용량 데이터 처리
claude "Dask를 활용한 대용량 데이터 전처리 파이프라인을 만들어줘.
- 청크 단위 병렬 처리
- 메모리 효율적인 데이터 로딩
- 분산 컴퓨팅 환경 설정
- 진행 상황 모니터링"

# AutoML과 모델 비교
claude "여러 머신러닝 모델을 비교 평가해줘.
교차 검증, 하이퍼파라미터 튜닝을 수행하고,
결과를 표로 정리해줘"

# 딥러닝 모델 개발
claude "PyTorch로 이미지 분류 모델을 구현해줘.
- 전이학습 (Transfer Learning) 활용
- 데이터 증강과 정규화
- 학습률 스케줄링과 조기 종료
- 모델 체크포인트와 재개 기능
- TensorBoard 시각화"

# MLflow 실험 추적
claude "MLflow를 활용한 실험 추적 시스템을 구축해줘.
- 모델 메트릭과 파라미터 로깅
- 아티팩트 버전 관리
- 모델 레지스트리 설정
- A/B 테스트 프레임워크
- 실험 비교 대시보드"

# API 서빙
claude "학습된 모델을 FastAPI로 서빙하는 API를 만들어줘.
입력 검증, 예측, 모니터링 기능을 포함해줘"

# 실시간 예측 시스템
claude "Kafka와 Redis를 활용한 실시간 ML 파이프라인을 구축해줘.
- 스트리밍 데이터 전처리
- 실시간 특성 저장소
- 배치와 온라인 예측 통합
- 모델 성능 모니터링
- 자동 재학습 트리거"

# 컨테이너 배포
claude "Docker와 Kubernetes로 ML 모델을 배포해줘.
- 멀티 스테이지 Docker 빌드
- GPU 지원 컨테이너
- 오토스케일링 설정
- 헬스체크와 로그 수집
- CI/CD 파이프라인 통합"

# 모델 모니터링
claude "프로덕션 ML 모델 모니터링 시스템을 구축해줘.
- 데이터 드리프트 탐지
- 모델 성능 저하 알림
- 편향성 모니터링
- 설명 가능한 AI 대시보드
- 사고 대응 플레이북"

# Data Science Project Guidelines

## 프로젝트 구조

## 코딩 규칙
- 노트북은 실험용, 프로덕션 코드는 .py로
- 모든 실험은 추적 가능하게
- 재현 가능성 보장 (시드 고정)

## 데이터 처리
- 원본 데이터는 수정하지 않음
- 전처리 파이프라인 문서화
- 데이터 버전 관리

## 모델 관리
- MLflow로 실험 추적
- 모델 버전 관리
- A/B 테스트 지원

# 새 프로젝트 시작 시
claude "이 프로젝트의 구조와 사용된 기술 스택을 분석해줘.
주요 파일들의 역할과 데이터 흐름을 설명해줘"

# 기존 코드 개선
claude "이 코드를 리팩토링해줘. 
먼저 테스트를 작성해서 동작을 보장한 후,
단계별로 개선해줘"

# 문서 생성
claude "프로젝트의 README.md를 업데이트해줘.
설치 방법, 사용법, API 문서, 기여 가이드를 포함해줘"

# 성능 분석
claude "이 애플리케이션의 성능을 프로파일링하고,
병목 지점을 찾아서 최적화 방안을 제시해줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph TD
    A[현재 시스템 분석] --> B[마이그레이션 계획 수립]
    B --> C[파일럿 프로젝트]
    C --> D{성공 여부}
    D -->|성공| E[단계별 마이그레이션]
    D -->|실패| F[계획 수정]
    F --> C
    E --> G[성능 검증]
    G --> H{목표 달성}
    H -->|아니오| I[최적화]
    I --> G
    H -->|예| J[전체 시스템 전환]
    J --> K[모니터링 및 유지보수]
    
    style A fill:#e2e8f0
    style J fill:#dcfce7
    style K fill:#dcfce7

# 1. 의존성 및 아키텍처 분석
claude "이 Express 앱의 핵심 기능과 구조를 분석해줘.
- 의존성 트리와 순환 참조 확인
- 비즈니스 크리티컬 모듈 식별
- 테스트 커버리지 평가
- 성능 병목 지점 파악"

# 2. 상세한 마이그레이션 로드맵
claude "이 앱을 Fastify로 마이그레이션하는 계획을 세워줘.
- Strangler Fig 패턴 적용
- 단계별 롤백 계획
- 성능 벤치마크 설정
- 팀 교육 일정 포함
- 리스크 평가와 완화 전략"

# 3. 점진적 마이그레이션 실행
claude "인증 모듈부터 Fastify로 마이그레이션해줘.
- 트래픽 스플리팅 구현
- 모니터링과 알림 설정
- 데이터 일관성 보장
- 자동화된 테스트 스위트
- 성능 회귀 감지"

# 4. 복잡한 프론트엔드 마이그레이션
claude "React 클래스 컴포넌트를 함수형으로 마이그레이션해줘.
- 생명주기를 훅으로 변환
- 상태 관리 현대화
- 코드 분할과 지연 로딩 적용
- TypeScript 타입 안전성 강화
- 성능 최적화 기회 식별"

# 5. 데이터베이스 마이그레이션
claude "MySQL에서 PostgreSQL로 마이그레이션 계획을 세워줘.
- 스키마 변환과 데이터 타입 매핑
- 무중단 데이터 이전 전략
- 쿼리 최적화와 성능 튜닝
- 백업과 복구 절차
- 검증과 테스트 계획"

# 성능 지표 모니터링
claude "마이그레이션 전후 성능 비교 대시보드를 만들어줘.
- 응답 시간과 처리량 비교
- 메모리 사용량과 CPU 효율성
- 번들 크기와 로딩 시간
- 사용자 경험 메트릭 (LCP, FID, CLS)
- 개발자 생산성 지표"

# 품질 지표 추적
claude "코드 품질 개선 사항을 추적하는 시스템을 구축해줘.
- 테스트 커버리지 변화
- 코드 복잡도 감소
- 보안 취약점 해결
- 기술 부채 감소
- 팀 만족도 조사"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
mindmap
  root((프레임워크 성공 요소))
    생태계 이해
      철학과 원칙
        핵심 개념 숙지
        설계 원칙 준수
      관용구와 패턴
        커뮤니티 모범 사례
        검증된 관례 적용
      도구 체인
        전용 도구 활용
        라이브러리 생태계
    실전 적용
      점진적 도입
        단계적 접근
        리스크 최소화
      성능 중심
        최적화 전략
        벤치마킹
      팀 교육
        체계적 학습
        지식 공유
    지속적 개선
      모니터링
        정량적 측정
        성과 추적
      피드백 루프
        프로세스 개선
        팀 의견 수렴
      최신 동향
        업데이트 추적
        신기능 학습

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
mindmap
  root((학습 목표))
    전략 수립
      언어별 최적화 전략
      개발 환경 구성
      도구 체인 선택
    타입 시스템 활용
      타입 안전성 보장
      정적 분석 도구
      런타임 검증
    멀티 언어 프로젝트
      언어 간 상호 운용성
      API 인터페이스 설계
      타입 공유 전략
    언어 선택 가이드
      요구사항 분석
      성능 vs 생산성
      팀 역량 고려

# 기본 TypeScript 프로젝트 설정
claude "엄격한 타입 체크를 사용하는 TypeScript 프로젝트를 설정해줘.
tsconfig.json을 최적화하고, ESLint와 Prettier도 TypeScript에 맞게 구성해줘"

# 대규모 모노레포 설정
claude "대규모 TypeScript 모노레포를 설정해줘.
- Nx 워크스페이스 구성
- 프로젝트 간 의존성 관리
- 공유 라이브러리 빌드 시스템
- 컨시스턴트 코드 스타일 적용
- 사이클릭 의존성 감지"

# 마이크로프론트엔드 아키텍처
claude "TypeScript 마이크로프론트엔드 아키텍처를 구성해줘.
- Module Federation 설정
- 런타임 타입 안전성 보장
- 사이드카 로딩과 버전 관리
- 공유 상태 및 이벤트 처리
- 테스트 전략과 목 설정"

{
  "compilerOptions": {
    // 최신 자바스크립트 표준 지원
    "target": "ES2022",
    "module": "ESNext",
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    
    // 최대 타입 안전성
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedSideEffectImports": true,
    
    // 추가 엄격성 옵션
    "allowUnusedLabels": false,
    "allowUnreachableCode": false,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true,
    
    // 모든 타입 및 내보내기
    "moduleResolution": "bundler",
    "allowImportingTsExtensions": true,
    "noEmit": true,
    "isolatedModules": true,
    
    // 성능 최적화
    "incremental": true,
    "tsBuildInfoFile": ".tsbuildinfo",
    
    // 경로 매핑
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"],
      "@/components/*": ["./src/components/*"],
      "@/utils/*": ["./src/utils/*"],
      "@/types/*": ["./src/types/*"]
    }
  },
  "include": [
    "src/**/*",
    "types/**/*",
    "tests/**/*"
  ],
  "exclude": [
    "node_modules",
    "dist",
    "build",
    "coverage"
  ]
}

# Branded Types로 비즈니스 규칙 적용
claude "Branded Types를 사용해서 비즈니스 로직 안전성을 보장해줘.
- UserId, Email, PhoneNumber 등 도메인 타입 정의
- 런타임 검증 함수와 연동
- API 응답 타입 안전성 보장
- 데이터베이스 스키마와 동기화"

# Conditional Types로 API 타입 자동 생성
claude "Conditional Types를 활용해서 OpenAPI 스키마에서 
TypeScript 타입을 자동 생성하는 시스템을 만들어줘.
- Path Parameter와 Query Parameter 타입 추론
- Response 타입 자동 매핑
- HTTP Status Code별 타입 구분
- 에러 타입 유니온 생성"

# Template Literal Types로 DSL 구현
claude "Template Literal Types를 사용해서 타입 안전한 DSL을 만들어줘.
- CSS-in-JS 타입 체크
- SQL 쿼리 빌더 타입 안전성
- Event Name 자동 완성
- i18n 키 유효성 검사"

# 점진적 타입 로딩
claude "대규모 프로젝트의 TypeScript 컴파일 성능을 최적화해줘.
- Project References로 점진적 빌드
- Type-only imports 활용
- 사용하지 않는 타입 제거
- 동적 import로 타입 로딩 최적화
- Watch mode 성능 튜닝"

# 런타임 타입 검증 최적화
claude "런타임 타입 검증을 성능에 영향 없이 구현해줘.
- Zod로 런타임 스키마 검증
- Type Guards 최적화
- 비동기 검증 배칭
- 캐시 전략과 메모이제이션
- 에러 바운더리와 로깅"

### 타입 안전성 극대화

**1. 고급 타입 활용**

```bash
claude "이 JavaScript 코드를 TypeScript로 마이그레이션해줘.
유니온 타입, 제네릭, 조건부 타입을 활용해서
타입 안전성을 최대한 확보해줘"

claude "이 함수의 반환 타입이 너무 넓게 추론되고 있어.
타입 가드와 const assertion을 사용해서 더 정확한 타입을 추론하도록 해줘"

claude "API 응답을 Zod 스키마로 검증하는 시스템을 만들어줘.
타입스크립트 타입도 자동으로 생성되도록 해줘"

claude "이 명령형 코드를 함수형 스타일로 리팩토링해줘.
불변성을 유지하고, 순수 함수를 사용하며,
함수 조합으로 로직을 구성해줘"

claude "여러 API 호출을 효율적으로 처리하도록 최적화해줘.
Promise.all, Promise.allSettled를 적절히 사용하고,
에러 처리와 재시도 로직도 추가해줘"

# TypeScript/JavaScript Guidelines

## 타입 정의 규칙
- 인터페이스 > 타입 별칭 (확장 가능한 경우)
- any 사용 금지 (unknown 사용)
- 명시적 반환 타입 선호

## 비동기 처리
```typescript
// 좋은 예
const fetchData = async (): Promise<Result<Data, Error>> => {
  try {
    const data = await api.get('/data');
    return { ok: true, value: data };
  } catch (error) {
    return { ok: false, error };
  }
};

### TypeScript 실전 디버깅과 모니터링

```bash
# 고급 디버깅 설정
claude "TypeScript 프로젝트에 고급 디버깅 환경을 설정해줘.
- Source Map 최적화로 디버깅 성능 향상
- Chrome DevTools 연동
- TypeScript 컴파일러 에러 추적
- 런타임 성능 프로파일링
- 메모리 누수 탐지 도구"

# 프로덕션 모니터링
claude "TypeScript 애플리케이션의 프로덕션 모니터링을 설정해줘.
- 런타임 타입 에러 수집
- 성능 병목 지점 추적
- 번들 크기 모니터링
- TypeScript 컴파일 시간 추적
- 코드 커버리지 리포트"

# 기본 Python 프로젝트 설정
claude "Python 패키지 구조를 모범 사례에 따라 설정해줘.
pyproject.toml, 가상 환경, 타입 힌트, 
그리고 테스트 설정을 포함해줘"

# 대규모 FastAPI 애플리케이션
claude "FastAPI로 엔터프라이즈급 API 서버를 구축해줘.
- 비동기 데이터베이스 연동 (SQLAlchemy 2.0)
- Pydantic v2로 데이터 검증
- OAuth2/JWT 인증 시스템
- 마이크로서비스 아키텍처 대비
- 모니터링과 로깅 시스템"

# 데이터 엔지니어링 파이프라인
claude "Apache Airflow로 대용량 데이터 파이프라인을 구축해줘.
- ETL 워크플로우 자동화
- Pandas/Polars 성능 최적화
- 대용량 데이터 비동기 처리
- 에러 복구와 재시도 로직
- 모니터링과 알림 시스템"

# 머신러닝 프로덕션 시스템
claude "MLOps 파이프라인을 Python으로 구축해줘.
- MLflow로 실험 추적과 모델 버전 관리
- Celery로 비동기 매치 학습
- FastAPI로 모델 서빙 API
- 실시간 모델 모니터링
- A/B 테스트 프레임워크"

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

[tool.poetry]
name = "enterprise-python-app"
version = "0.1.0"
description = "Enterprise-grade Python application"
authors = ["Team <team@company.com>"]
readme = "README.md"
packages = [{include = "app", from = "src"}]

[tool.poetry.dependencies]
python = "^3.11"
fastapi = "^0.104.0"
uvicorn = {extras = ["standard"], version = "^0.24.0"}
sqlalchemy = "^2.0.0"
alembic = "^1.12.0"
pydantic = "^2.5.0"
celery = "^5.3.0"
redis = "^5.0.0"
structlog = "^23.2.0"
prometheus-client = "^0.19.0"

[tool.poetry.group.dev.dependencies]
pytest = "^7.4.0"
pytest-asyncio = "^0.21.0"
pytest-cov = "^4.1.0"
mypy = "^1.7.0"
black = "^23.11.0"
ruff = "^0.1.0"
pre-commit = "^3.5.0"

# 마이크로서비스 도구
locust = "^2.17.0"  # 로드 테스트
opentelemetry-api = "^1.21.0"  # 분산 추적
jinja2 = "^3.1.0"  # 템플릿 엔진

# 코드 품질 도구
[tool.mypy]
python_version = "3.11"
strict = true
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true
disallow_incomplete_defs = true
check_untyped_defs = true
disallow_untyped_decorators = true
no_implicit_optional = true
warn_redundant_casts = true
warn_unused_ignores = true
warn_no_return = true
warn_unreachable = true
strict_equality = true

[tool.black]
line-length = 88
target-version = ['py311']
include = '\.pyi?$'
extend-exclude = '''
^/(
  (
      \.eggs
    | \.git
    | \.mypy_cache
    | \.tox
    | \.venv
    | _build
    | buck-out
    | build
    | dist
  )/
)
'''

[tool.ruff]
select = [
    "E",   # pycodestyle errors
    "W",   # pycodestyle warnings  
    "F",   # pyflakes
    "I",   # isort
    "B",   # flake8-bugbear
    "C4",  # flake8-comprehensions
    "UP",  # pyupgrade
    "N",   # pep8-naming
    "S",   # bandit
]
ignore = [
    "E501",  # line too long
    "B008",  # do not perform function calls in argument defaults
    "S101",  # use of assert
]
line-length = 88
target-version = "py311"

[tool.pytest.ini_options]
minversion = "7.0"
addopts = "-ra -q --cov=src --cov-report=term-missing --cov-report=html"
testpaths = ["tests"]
python_files = ["test_*.py"]
python_classes = ["Test*"]
python_functions = ["test_*"]
asyncio_mode = "auto"

# 고급 타입 힌트 패턴
claude "이 Python 코드에 고급 타입 힌트를 추가해줘.
- 제네릭과 프로토콜을 활용한 추상화
- Union과 Literal을 이용한 정확한 타입 정의
- TypeGuard로 런타임 타입 체크
- NewType으로 도메인 타입 생성
- mypy strict 모드 통과 보장"

# Pydantic v2 고급 기능
claude "Pydantic v2로 고급 데이터 검증 시스템을 구축해줘.
- Field validators와 model validators
- 비동기 검증자와 커스텀 시리얼라이저
- Discriminated Unions로 복잡한 데이터 구조
- JSON Schema 자동 생성
- 성능 최적화된 설정"

# 정적 분석 도구 통합
claude "Python 코드 품질을 위한 정적 분석 도구를 설정해줘.
- mypy + Pylance로 최대 타입 체크
- ruff로 빠른 린팅과 포매팅
- bandit으로 보안 취약점 검사
- vulture로 사용하지 않는 코드 탐지
- 전체 CI/CD 파이프라인 통합"

from typing import (
    AsyncGenerator, Awaitable, Callable, 
    Generic, Literal, Protocol, TypeGuard, 
    TypeVar, Union, overload
)
from dataclasses import dataclass
from pydantic import BaseModel, Field, field_validator
from datetime import datetime
from decimal import Decimal

# Domain Types with NewType
from typing import NewType
UserId = NewType('UserId', int)
Email = NewType('Email', str)
ProductId = NewType('ProductId', str)

# Protocol for dependency injection
class DatabaseProtocol(Protocol):
    async def execute(self, query: str) -> list[dict[str, any]]: ...
    async def fetch_one(self, query: str) -> dict[str, any] | None: ...

# Generic Repository Pattern
T = TypeVar('T', bound=BaseModel)

class Repository(Generic[T]):
    def __init__(self, db: DatabaseProtocol, model_class: type[T]) -> None:
        self._db = db
        self._model_class = model_class
    
    async def find_by_id(self, id_: int) -> T | None:
        result = await self._db.fetch_one(
            f"SELECT * FROM {self._model_class.__tablename__} WHERE id = {id_}"
        )
        return self._model_class(**result) if result else None

# Advanced Pydantic Models
class UserCreateRequest(BaseModel):
    email: Email = Field(..., pattern=r'^[\w\.-]+@[\w\.-]+\.\w+$')
    name: str = Field(..., min_length=1, max_length=100)
    age: int = Field(..., ge=18, le=120)
    
    @field_validator('email')
    @classmethod
    def validate_email_domain(cls, v: str) -> str:
        allowed_domains = ['company.com', 'partner.com']
        domain = v.split('@')[1]
        if domain not in allowed_domains:
            raise ValueError(f'Email domain must be one of {allowed_domains}')
        return v

# Type Guards for runtime validation
def is_valid_user_id(value: any) -> TypeGuard[UserId]:
    return isinstance(value, int) and value > 0

# Discriminated Union for complex data structures
class SuccessResponse(BaseModel):
    status: Literal['success'] = 'success'
    data: dict[str, any]
    timestamp: datetime = Field(default_factory=datetime.now)

class ErrorResponse(BaseModel):
    status: Literal['error'] = 'error'
    message: str
    error_code: int
    timestamp: datetime = Field(default_factory=datetime.now)

APIResponse = Union[SuccessResponse, ErrorResponse]

# Async Context Manager with proper typing
class AsyncDatabaseTransaction:
    def __init__(self, db: DatabaseProtocol) -> None:
        self._db = db
        self._transaction: any = None
    
    async def __aenter__(self) -> DatabaseProtocol:
        self._transaction = await self._db.begin()
        return self._db
    
    async def __aexit__(self, exc_type: type[Exception] | None, 
                       exc_val: Exception | None, 
                       exc_tb: any) -> None:
        if exc_type is None:
            await self._transaction.commit()
        else:
            await self._transaction.rollback()

# 고성능 비동기 시스템
claude "대용량 비동기 처리 시스템을 구축해줘.
- asyncio + aiohttp로 대량 HTTP 요청 처리
- asyncpg로 비동기 데이터베이스 연동
- 비동기 컨텍스트 매니저와 세마포어
- 백프레셔와 서킷 관리
- 에러 전파와 로깅 전략"

# 메모리 최적화 전략
claude "Pandas/Polars로 대용량 데이터 처리를 최적화해줘.
- 청크 단위 스트리밍 처리
- 제너레이터와 이터레이터 최적화
- 메모리 매핑 파일과 파켓 형식
- 병렬 처리와 멀티프로세싱
- 가비지 컴렉션 최적화"

# Celery로 백그라운드 작업 처리
claude "Celery로 엔터프라이즈급 비동기 작업 시스템을 구축해줘.
- Redis Sentinel로 고가용성 브로커
- 동적 워커 스케일링
- 작업 우선순위와 라우팅
- 실패 처리와 재시도 전략
- 모니터링과 메트릭 수집"

# 성능 프로파일링과 병목 분석
claude "Python 애플리케이션의 성능 병목을 찾아서 최적화해줘.
- cProfile과 py-spy로 프로파일링
- 메모리 사용량 분석 (memory_profiler)
- 데이터베이스 쿼리 최적화
- 캐시 전략 및 메모이제이션
- JIT 컴파일러 (Numba) 활용"

import asyncio
import aiohttp
import asyncpg
from typing import AsyncIterator, AsyncContextManager
from contextlib import asynccontextmanager
import structlog
from dataclasses import dataclass
from datetime import datetime

# 비동기 데이터베이스 커넥션 풀
class AsyncDatabasePool:
    def __init__(self, dsn: str, min_size: int = 10, max_size: int = 100):
        self.dsn = dsn
        self.min_size = min_size
        self.max_size = max_size
        self.pool: asyncpg.Pool | None = None
        self.logger = structlog.get_logger()
    
    async def initialize(self) -> None:
        """비동기 커넥션 풀 초기화"""
        self.pool = await asyncpg.create_pool(
            self.dsn,
            min_size=self.min_size,
            max_size=self.max_size,
            command_timeout=60
        )
        self.logger.info("Database pool initialized", 
                        min_size=self.min_size, max_size=self.max_size)
    
    @asynccontextmanager
    async def acquire(self) -> AsyncIterator[asyncpg.Connection]:
        """커넥션 획득 및 자동 반납"""
        if not self.pool:
            raise RuntimeError("Pool not initialized")
        
        async with self.pool.acquire() as conn:
            try:
                yield conn
            except Exception as e:
                self.logger.error("Database operation failed", error=str(e))
                raise
    
    async def close(self) -> None:
        """커넥션 풀 종료"""
        if self.pool:
            await self.pool.close()
            self.logger.info("Database pool closed")

# 비동기 HTTP 클라이언트 래퍼
class AsyncHTTPClient:
    def __init__(self, timeout: int = 30, max_connections: int = 100):
        self.timeout = aiohttp.ClientTimeout(total=timeout)
        self.connector = aiohttp.TCPConnector(
            limit=max_connections,
            limit_per_host=20,
            keepalive_timeout=30
        )
        self.session: aiohttp.ClientSession | None = None
        self.logger = structlog.get_logger()
    
    async def __aenter__(self) -> 'AsyncHTTPClient':
        self.session = aiohttp.ClientSession(
            timeout=self.timeout,
            connector=self.connector
        )
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
        if self.session:
            await self.session.close()
    
    async def get_multiple(self, urls: list[str], 
                          concurrency: int = 10) -> AsyncIterator[dict]:
        """여러 URL을 동시에 요청하고 결과를 스트리밍"""
        semaphore = asyncio.Semaphore(concurrency)
        
        async def fetch_one(url: str) -> dict:
            async with semaphore:
                try:
                    async with self.session.get(url) as response:
                        data = await response.json()
                        return {"url": url, "status": response.status, "data": data}
                except Exception as e:
                    self.logger.error("HTTP request failed", url=url, error=str(e))
                    return {"url": url, "status": 500, "error": str(e)}
        
        # 비동기 제너레이터로 결과 스트리밍
        tasks = [fetch_one(url) for url in urls]
        for task in asyncio.as_completed(tasks):
            result = await task
            yield result

# 대용량 데이터 처리를 위한 제너레이터 패턴
async def process_large_dataset_chunks(
    query: str, 
    db_pool: AsyncDatabasePool,
    chunk_size: int = 10000
) -> AsyncIterator[list[dict]]:
    """대용량 데이터셋을 청크 단위로 처리"""
    offset = 0
    
    while True:
        chunked_query = f"{query} LIMIT {chunk_size} OFFSET {offset}"
        
        async with db_pool.acquire() as conn:
            rows = await conn.fetch(chunked_query)
            
        if not rows:
            break
            
        # dict로 변환하여 리턴
        chunk = [dict(row) for row in rows]
        yield chunk
        
        offset += chunk_size
        
        # 내부 처리를 위한 비동기 지연
        await asyncio.sleep(0.01)

# 무제한 재시도와 지수 백오프
async def retry_with_exponential_backoff(
    func: Callable[[], Awaitable[T]],
    max_retries: int = 3,
    base_delay: float = 1.0,
    max_delay: float = 60.0
) -> T:
    """지수 백오프와 함께 재시도"""
    logger = structlog.get_logger()
    
    for attempt in range(max_retries + 1):
        try:
            return await func()
        except Exception as e:
            if attempt == max_retries:
                logger.error("Max retries exceeded", error=str(e))
                raise
            
            delay = min(base_delay * (2 ** attempt), max_delay)
            logger.warning(
                "Operation failed, retrying",
                attempt=attempt + 1,
                max_retries=max_retries,
                delay=delay,
                error=str(e)
            )
            await asyncio.sleep(delay)
    
    # 이 지점에 도달할 수 없음
    raise RuntimeError("Unexpected execution path")

# Enterprise Python Guidelines

## 프로젝트 구조

## 코드 품질 기준
- **PEP 8 + ruff**: 모든 코드는 ruff 린터 통과 필수
- **타입 힌트**: mypy strict 모드 100% 커버리지
- **복잡도**: 함수당 맥동 복잡도 10 이하
- **돁스트링**: 고품질 돁스트링 필수 (Google Style)

## 타입 힌트 규칙
```python
from typing import TypeVar, Generic, Protocol, TypeGuard, NewType
from datetime import datetime
from decimal import Decimal

# Domain Types
UserId = NewType('UserId', int)
Email = NewType('Email', str)

# Repository Protocol
T = TypeVar('T')

class Repository(Protocol, Generic[T]):
    async def find_by_id(self, id_: int) -> T | None: ...
    async def save(self, entity: T) -> T: ...
    async def delete(self, id_: int) -> bool: ...

# Type Guards
def is_valid_email(value: str) -> TypeGuard[Email]:
    return '@' in value and '.' in value.split('@')[1]

# Pydantic Models
class UserCreate(BaseModel):
    email: Email = Field(..., description="사용자 이메일")
    name: str = Field(..., min_length=1, max_length=100)
    
    @field_validator('email')
    @classmethod
    def validate_email(cls, v: str) -> str:
        if not is_valid_email(v):
            raise ValueError('유효하지 않은 이메일 형식')
        return v

import structlog

logger = structlog.get_logger()

# 비즈니스 로직
logger.info(
    "User created successfully", 
    user_id=user.id,
    email=user.email,
    timestamp=datetime.now().isoformat()
)

# 에러 로깅
logger.error(
    "Database connection failed",
    error=str(e),
    retry_count=retry_count,
    max_retries=max_retries
)

### Python 실전 디버깅과 모니터링

```bash
# 프로덕션 디버깅 환경
claude "Python 애플리케이션의 프로덕션 디버깅 환경을 설정해줘.
- 원격 디버깅과 로그 수집
- APM 도구 (New Relic, DataDog) 연동
- 성능 병목 지점 실시간 추적
- 예외 및 오류 자동 수집
- 비동기 작업 모니터링"

# 대용량 시스템 모니터링
claude "Python 마이크로서비스의 종합 모니터링을 설정해줘.
- Prometheus + Grafana 메트릭 수집
- 분산 로깅 (ELK Stack)
- 비동기 작업 대시보드
- 자동 알림과 에스케일레이션
- 성능 회귀 감지"

# 기본 현대화 작업
claude "이 레거시 Java 8 코드를 Java 17+ 기능을 활용해서 현대화해줘.
- Records로 데이터 클래스 변환
- Pattern Matching으로 instanceof 간소화
- Text Blocks로 가독성 향상
- Optional로 null 안전성 강화
- Stream API로 컬렉션 처리 최적화"

# 대규모 시스템 마이그레이션
claude "모놀리식 Spring 애플리케이션을 마이크로서비스로 분해해줘.
- 도메인 경계 식별과 서비스 분리
- Spring Cloud Gateway로 API 게이트웨이 구성
- 분산 트랜잭션과 사가 패턴 적용
- 서비스 메시와 분산 추적 설정
- 데이터베이스 분리 전략"

# 성능 최적화
claude "Java 애플리케이션의 성능을 프로파일링하고 최적화해줘.
- JVM 튜닝과 GC 최적화
- 메모리 누수 탐지와 해결
- 스레드 풀 설정 최적화
- 데이터베이스 커넥션 풀링
- JIT 컴파일러 최적화"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph TD
    A[src/main/java/com/company/app/] --> B[config/<br/>Spring 설정 클래스]
    A --> C[domain/<br/>비즈니스 영역]
    A --> D[infrastructure/<br/>외부 시스템 연동]
    A --> E[presentation/<br/>컨트롤러와 DTO]
    A --> F[shared/<br/>공통 유틸리티]
    A --> G[security/<br/>보안 설정]
    
    C --> H[model/<br/>도메인 모델]
    C --> I[service/<br/>비즈니스 서비스]
    C --> J[repository/<br/>데이터 액세스]
    
    K[resources/] --> L[application.yml<br/>환경별 설정]
    K --> M[logback.xml<br/>로깅 설정]
    K --> N[schema.sql<br/>데이터베이스 스키마]
    
    classDef configStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef domainStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class B,D,E,F,G,H,I,J,L,M,N domainStyle
    class A,C,K configStyle

# 복잡한 의존성 그래프 최적화
claude "Spring Boot 애플리케이션의 의존성 주입을 최적화해줘.
- Constructor injection으로 불변성 보장
- 순환 의존성 탐지와 해결
- Configuration Properties로 타입 안전한 설정
- Profile별 Bean 조건부 생성
- 테스트용 Test Configuration 분리"

# 멀티 모듈 프로젝트 설정
claude "대규모 Spring Boot 멀티 모듈 프로젝트를 설정해줘.
- 공통 모듈과 도메인별 모듈 분리
- 모듈 간 의존성 관리
- 통합 테스트와 단위 테스트 전략
- 빌드 최적화와 병렬 컴파일
- 도커 이미지 계층화"

# WebFlux 마이그레이션
claude "기존 Spring MVC REST API를 Spring WebFlux로 마이그레이션해줘.
- Mono와 Flux를 활용한 논블로킹 처리
- R2DBC로 반응형 데이터베이스 연동
- WebClient로 외부 API 호출 최적화
- 백프레셔 처리와 에러 복구
- 성능 벤치마크와 비교 분석"

# 하이브리드 아키텍처
claude "Spring MVC와 WebFlux를 혼합한 하이브리드 시스템을 구축해줘.
- CPU 집약적 작업은 MVC로 처리
- I/O 집약적 작업은 WebFlux로 처리
- 공통 보안 설정과 인증 처리
- 모니터링과 메트릭 통합
- 로드 밸런싱 전략"

# Java 코드베이스 점진적 Kotlin 전환
claude "기존 Java Spring Boot 프로젝트를 점진적으로 Kotlin으로 전환해줘.
- 새 기능은 Kotlin으로 작성
- data class로 DTO 간소화
- sealed class로 상태 관리
- extension functions로 유틸리티 함수 정리
- coroutines로 비동기 처리 개선"

# Kotlin DSL 활용
claude "Kotlin DSL을 활용해서 설정과 빌드 스크립트를 개선해줘.
- build.gradle.kts로 빌드 스크립트 타입 안전성 확보
- Spring Security DSL로 보안 설정 간소화
- 테스트 DSL로 가독성 높은 테스트 작성
- 도메인 특화 언어 구현"

// 타입 안전한 설정 관리
@ConfigurationProperties(prefix = "app")
data class AppProperties(
    val database: DatabaseProperties,
    val security: SecurityProperties,
    val features: FeatureFlags
) {
    data class DatabaseProperties(
        val url: String,
        val maxPoolSize: Int = 20,
        val connectionTimeout: Duration = Duration.ofSeconds(30)
    )
    
    data class SecurityProperties(
        val jwtSecret: String,
        val jwtExpiration: Duration = Duration.ofHours(24),
        val corsAllowedOrigins: List<String> = emptyList()
    )
    
    data class FeatureFlags(
        val enableNewPaymentSystem: Boolean = false,
        val enableAdvancedAnalytics: Boolean = false
    )
}

// 결과 타입으로 에러 처리
sealed class Result<out T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Error(val exception: Throwable) : Result<Nothing>()
    
    inline fun <R> map(transform: (T) -> R): Result<R> = when (this) {
        is Success -> Success(transform(value))
        is Error -> this
    }
    
    inline fun <R> flatMap(transform: (T) -> Result<R>): Result<R> = when (this) {
        is Success -> transform(value)
        is Error -> this
    }
}

// 코루틴을 활용한 서비스 계층
@Service
class UserService(
    private val userRepository: UserRepository,
    private val emailService: EmailService,
    private val auditService: AuditService
) {
    suspend fun createUser(request: CreateUserRequest): Result<User> = runCatching {
        // 병렬 검증
        val (emailExists, usernameExists) = coroutineScope {
            val emailCheck = async { userRepository.existsByEmail(request.email) }
            val usernameCheck = async { userRepository.existsByUsername(request.username) }
            emailCheck.await() to usernameCheck.await()
        }
        
        when {
            emailExists -> throw UserAlreadyExistsException("Email already exists")
            usernameExists -> throw UserAlreadyExistsException("Username already exists")
        }
        
        val user = User(
            email = request.email,
            username = request.username,
            hashedPassword = hashPassword(request.password)
        )
        
        // 병렬 처리
        coroutineScope {
            val saveUser = async { userRepository.save(user) }
            val sendEmail = async { emailService.sendWelcomeEmail(user.email) }
            val audit = async { auditService.logUserCreation(user.id) }
            
            saveUser.await().also {
                sendEmail.await()
                audit.await()
            }
        }
    }.fold(
        onSuccess = { Result.Success(it) },
        onFailure = { Result.Error(it) }
    )
}

// Extension functions로 유틸리티 확장
fun String.isValidEmail(): Boolean = 
    matches("""^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$""".toRegex())

fun <T> List<T>.chunkedParallel(size: Int, block: suspend (List<T>) -> Unit) = runBlocking {
    chunked(size).map { chunk ->
        async { block(chunk) }
    }.awaitAll()
}

// 타입 안전한 쿼리 빌더
class UserQueryBuilder {
    private val criteria = mutableListOf<String>()
    private val parameters = mutableMapOf<String, Any>()
    
    fun byEmail(email: String) = apply {
        criteria.add("email = :email")
        parameters["email"] = email
    }
    
    fun byAgeRange(min: Int, max: Int) = apply {
        criteria.add("age BETWEEN :minAge AND :maxAge")
        parameters["minAge"] = min
        parameters["maxAge"] = max
    }
    
    fun activeOnly() = apply {
        criteria.add("active = true")
    }
    
    fun build(): Pair<String, Map<String, Any>> {
        val query = "SELECT * FROM users" + 
            if (criteria.isNotEmpty()) " WHERE " + criteria.joinToString(" AND ")
            else ""
        return query to parameters
    }
}

# JVM 성능 튜닝
claude "Java/Kotlin 애플리케이션의 JVM 성능을 최적화해줘.
- G1GC vs ZGC vs Parallel GC 비교 분석
- 힙 크기와 메타스페이스 튜닝
- JIT 컴파일러 최적화 옵션
- 스레드 로컬 할당 버퍼(TLAB) 설정
- Flight Recorder로 성능 프로파일링"

# 메모리 최적화
claude "메모리 사용량을 최적화하고 GC 압박을 줄여줘.
- 객체 풀링과 재사용 전략
- 오프힙 캐싱 구현
- WeakReference와 SoftReference 활용
- 메모리 누수 탐지와 해결
- 대용량 데이터 스트리밍 처리"

# 동시성 최적화
claude "Java/Kotlin의 동시성 기능을 최적화해줘.
- Virtual Threads (Project Loom) 활용
- CompletableFuture vs Kotlin Coroutines 비교
- 락프리 자료구조 구현
- Actor 모델과 CSP 패턴
- 백프레셔와 플로우 제어"

# Java/Kotlin Enterprise Guidelines

## 언어 선택 기준
- **신규 개발**: Kotlin 우선, 복잡한 비즈니스 로직 표현
- **레거시 통합**: Java 유지, 점진적 Kotlin 도입
- **성능 크리티컬**: 프로파일링 후 결정
- **팀 역량**: 학습 곡선 고려한 단계적 도입

## Java 개발 규칙
- **버전**: Java 17+ LTS 버전 사용
- **기능 활용**: Records, Pattern Matching, Sealed Classes
- **Null 처리**: Optional 적극 활용, null 리턴 금지
- **스트림**: 컬렉션 처리는 Stream API 사용
- **문자열**: Text Blocks로 가독성 향상

## Kotlin 개발 규칙
- **Null Safety**: nullable 타입 명시적 처리
- **불변성**: val 선호, 불변 컬렉션 사용
- **확장 함수**: 기존 클래스 확장, 유틸리티 대체
- **데이터 클래스**: DTO와 Value Object 표현
- **코루틴**: 비동기 처리의 기본 선택

## Spring Boot 패턴
```kotlin
// 컨트롤러 (RESTful API)
@RestController
@RequestMapping("/api/v1/users")
@Validated
class UserController(
    private val userService: UserService
) {
    @GetMapping("/{id}")
    suspend fun getUser(
        @PathVariable @Positive id: Long
    ): ResponseEntity<UserDto> = 
        userService.findById(id)
            .map { ResponseEntity.ok(it) }
            .getOrElse { 
                when (it) {
                    is UserNotFoundException -> ResponseEntity.notFound().build()
                    else -> ResponseEntity.internalServerError().build()
                }
            }
    
    @PostMapping
    suspend fun createUser(
        @Valid @RequestBody request: CreateUserRequest
    ): ResponseEntity<UserDto> = 
        userService.createUser(request)
            .map { ResponseEntity.status(201).body(it) }
            .getOrElse { ResponseEntity.badRequest().build() }
}

// 서비스 계층 (비즈니스 로직)
@Service
@Transactional
class UserService(
    private val userRepository: UserRepository,
    private val passwordEncoder: PasswordEncoder,
    private val eventPublisher: ApplicationEventPublisher
) {
    suspend fun createUser(request: CreateUserRequest): Result<UserDto> = 
        runCatching {
            validateUniqueConstraints(request)
            
            val user = User(
                email = request.email,
                username = request.username,
                password = passwordEncoder.encode(request.password)
            )
            
            userRepository.save(user).also {
                eventPublisher.publishEvent(UserCreatedEvent(it.id))
            }
        }.mapCatching { it.toDto() }
}

// 테스트 예시
@ExtendWith(MockKExtension::class)
class UserServiceTest {
    @MockK
    private lateinit var userRepository: UserRepository
    
    @MockK
    private lateinit var passwordEncoder: PasswordEncoder
    
    @InjectMockKs
    private lateinit var userService: UserService
    
    @Test
    fun `should create user successfully`() = runTest {
        // Given
        val request = CreateUserRequestBuilder()
            .withEmail("test@example.com")
            .withUsername("testuser")
            .build()
            
        every { passwordEncoder.encode(any()) } returns "encoded_password"
        coEvery { userRepository.save(any()) } returns UserBuilder().build()
        
        // When
        val result = userService.createUser(request)
        
        // Then
        result.isSuccess shouldBe true
        coVerify { userRepository.save(any()) }
    }
}

# 복잡한 동시성 문제 해결
claude "멀티스레드 환경에서 발생하는 데드락을 탐지하고 해결해줘.
- 스레드 덤프 분석과 해석
- 락 경합 지점 식별
- 락프리 알고리즘 적용
- Virtual Threads 마이그레이션
- 성능 벤치마크와 검증"

# 메모리 누수 진단
claude "Java 애플리케이션의 메모리 누수를 진단하고 해결해줘.
- 힙 덤프 분석과 MAT 도구 활용
- 강한 참조 체인 추적
- 리스너와 콜백 누수 탐지
- 오프힙 메모리 누수 확인
- 메모리 사용 패턴 최적화"

# 프로덕션 이슈 대응
claude "프로덕션 환경의 성능 저하를 실시간으로 진단해줘.
- APM 도구로 병목 지점 식별
- 데이터베이스 쿼리 성능 분석
- GC 로그 분석과 튜닝
- JIT 컴파일러 최적화 확인
- 자동 복구 메커니즘 구현"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph TD
    A[Go 프로젝트 구조] --> B[cmd/<br/>메인 애플리케이션<br/>진입점과 실행 파일]
    A --> C[internal/<br/>내부 패키지<br/>외부에서 import 불가]
    A --> D[pkg/<br/>공개 패키지<br/>외부에서 사용 가능]
    A --> E[api/<br/>API 정의<br/>OpenAPI, gRPC 스키마]
    A --> F[web/<br/>웹 애플리케이션<br/>정적 파일, 템플릿]
    A --> G[configs/<br/>설정 파일<br/>환경별 구성]
    
    C --> H[handler/<br/>HTTP 핸들러]
    C --> I[service/<br/>비즈니스 로직]
    C --> J[repository/<br/>데이터 저장소]
    C --> K[domain/<br/>도메인 모델]
    
    classDef publicStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef internalStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    
    class B,D,E,F,G publicStyle
    class C,H,I,J,K internalStyle

claude "Go 모듈을 사용하는 프로젝트 구조를 만들어줘.
Clean Architecture를 적용하고, 
의존성 주입과 인터페이스를 활용해서 테스트하기 쉽게 만들어줘"

claude "이 순차 처리 코드를 고루틴과 채널을 사용해서 병렬화해줘.
적절한 에러 처리와 컨텍스트 취소도 구현해줘"

claude "Worker Pool 패턴을 구현해줘.
작업 큐, 워커 고루틴, 결과 수집을 포함하고,
graceful shutdown도 지원해줘"

# Go Project Guidelines

## 프로젝트 구조

## 코딩 규칙
- 에러는 항상 처리
- 인터페이스는 사용하는 쪽에서 정의
- 고루틴 리크 방지

## 에러 처리
```go
if err != nil {
    return fmt.Errorf("failed to process: %w", err)
}

claude "이 C++ 코드를 Rust로 재작성해줘.
소유권, 생명주기, 트레이트를 활용해서
메모리 안전성을 보장하면서도 성능을 유지해줘"

claude "이 함수들의 에러 처리를 개선해줘.
Result 타입과 ? 연산자를 사용하고,
커스텀 에러 타입도 정의해줘"

claude "Tokio를 사용해서 비동기 웹 서버를 만들어줘.
동시 요청 처리, 타임아웃, 그리고 graceful shutdown을 구현해줘"

# Rust Project Guidelines

## 안전성 규칙
- unsafe 최소화
- unwrap() 사용 금지
- clippy 경고 모두 해결

## 에러 처리
```rust
use thiserror::Error;

#[derive(Error, Debug)]
pub enum AppError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    
    #[error("Parse error: {0}")]
    Parse(String),
}

## 언어 간 상호 운용성

현대 소프트웨어 개발에서는 여러 프로그래밍 언어를 조합하여 각 언어의 장점을 활용하는 멀티 언어 아키텍처가 일반적입니다. Claude Code는 언어 간 경계를 넘나드는 통합 솔루션을 설계하고, 타입 안전성을 유지하면서 다양한 언어로 구성된 시스템을 구축할 수 있습니다.

### 다국어 프로젝트

서로 다른 언어로 개발된 컴포넌트들을 통합할 때는 API 인터페이스의 일관성과 타입 안전성이 중요합니다. Claude Code는 이러한 통합 과정을 자동화하고 최적화할 수 있습니다.

```bash
claude "Python 백엔드와 TypeScript 프론트엔드를 연결하는
타입 안전한 API 클라이언트를 생성해줘.
OpenAPI 스펙을 기반으로 자동 생성되도록 해줘"

claude "Rust로 작성된 고성능 라이브러리를 
Python에서 사용할 수 있도록 바인딩을 만들어줘.
PyO3를 사용하고, 타입 변환도 안전하게 처리해줘"

# 벤치마크 기반 최적화
claude "이 함수의 성능을 프로파일링하고 최적화해줘.
벤치마크를 작성하고, 병목 지점을 찾아서 개선해줘"

# 개발 속도 최적화
claude "이 프로토타입을 빠르게 구현해줘.
일단 작동하게 만든 후, 필요한 부분만 최적화해줘"

# 타입 시스템 활용
claude "이 비즈니스 로직을 타입 시스템으로 보장해줘.
런타임 에러가 발생할 수 없도록 컴파일 타임에 검증해줘"

# 프로젝트 요구사항 분석
claude "이 프로젝트의 요구사항을 분석하고,
가장 적합한 프로그래밍 언어를 추천해줘.
성능, 개발 속도, 팀 역량, 생태계를 고려해줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph LR
    subgraph languages [언어별 전문 분야]
        A[Python<br/>데이터 과학, AI/ML<br/>스크립팅] 
        B[JavaScript/TS<br/>웹 개발<br/>풀스택]
        C[Go<br/>마이크로서비스<br/>DevOps]
        D[Rust<br/>시스템 프로그래밍<br/>WebAssembly]
        E[Java/Kotlin<br/>엔터프라이즈<br/>Android]
    end
    
    subgraph strengths [핵심 강점]
        F[풍부한 라이브러리<br/>빠른 프로토타이핑]
        G[유니버설 언어<br/>생태계 통합]
        H[단순함과 성능<br/>동시성 모델]
        I[안전성과 성능<br/>메모리 효율성]
        J[성숙한 생태계<br/>플랫폼 안정성]
    end
    
    A -.-> F
    B -.-> G
    C -.-> H
    D -.-> I
    E -.-> J
    
    classDef langStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef strengthStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C,D,E langStyle
    class F,G,H,I,J strengthStyle

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
mindmap
  root((핵심 원칙))
    언어 철학 존중
      가치와 설계 원칙 이해
      언어 고유 특성 반영
      파라다임 일관성 유지
    생태계 활용
      표준 도구 적극 활용
      검증된 라이브러리 사용
      프레임워크 모범 사례
      개발 효율성 극대화
    관용구 따르기
      커뮤니티 검증 패턴
      일관된 코딩 스타일
      팀 협업 향상
      유지보수성 확보
    강점 극대화
      고유 장점 식별
      적합한 아키텍처 적용
      성능 특성 활용
      문제 영역 최적화

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
flowchart LR
    A[Red<br/>실패하는 테스트 작성] --> B[Green<br/>최소 구현으로 통과]
    B --> C[Refactor<br/>코드 품질 개선]
    C --> A
    
    subgraph activities [TDD 활동]
        D[테스트 케이스 정의<br/>엣지 케이스 고려<br/>실패 확인]
        E[최소한의 코드<br/>테스트 통과 집중<br/>성능은 나중에]
        F[중복 제거<br/>가독성 향상<br/>설계 개선]
    end
    
    A -.-> D
    B -.-> E
    C -.-> F
    
    classDef cycleStyle fill:#e2e8f0,stroke:#334155,stroke-width:3px,color:#1e293b
    classDef activityStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C cycleStyle
    class D,E,F activityStyle

claude "calculateDiscount 함수를 위한 테스트를 먼저 작성해줘.
다음 시나리오를 포함해야 해
- 일반 할인 (10%)
- VIP 할인 (20%)
- 최대 할인 한도
- 엣지 케이스 (음수, 0, null)"

claude "작성한 테스트를 통과하는 최소한의 코드를 구현해줘.
아직 최적화는 하지 말고, 테스트 통과에만 집중해줘"

claude "이제 테스트는 유지하면서 코드를 개선해줘.
중복 제거, 가독성 향상, 성능 최적화를 진행해줘"

# 사용자 스토리
claude "사용자 스토리: '사용자는 비밀번호를 변경할 수 있다'
이를 위한 TDD 사이클을 시작해줘"

# Claude의 응답 과정
# 1. 테스트 케이스 정의
# 2. API 엔드포인트 테스트 작성
# 3. 서비스 레이어 테스트 작성
# 4. 실제 구현
# 5. 리팩토링

### Day 2: 구현

```bash
# 오전: 백엔드 구현
claude "결제 API 엔드포인트를 TDD로 구현해줘"

# 오후: 프론트엔드 구현
claude "결제 UI를 구현해줘. 
카드 정보 입력, 검증, 로딩 상태를 포함해줘"

# 오전: 통합 테스트
claude "결제 플로우 전체를 테스트하는 E2E 테스트를 작성해줘"

# 오후: 문서화와 배포
claude "결제 기능 사용 가이드를 작성하고,
배포 체크리스트를 만들어줘"

# 긴 작업 시 컨텍스트 저장
claude "지금까지의 작업을 요약하고,
다음에 해야 할 일을 정리해줘"

# 컨텍스트 복원
claude "이전에 작업하던 결제 기능 구현을 계속해줘.
마지막으로 작업한 부분부터 시작해줘"

# 독립적인 작업 식별
claude "이 기능들 중 동시에 진행할 수 있는 작업을 찾아줘"

# 멀티 인스턴스 활용
# Terminal 1: 백엔드 개발
# Terminal 2: 프론트엔드 개발
# Terminal 3: 테스트 작성

claude "반복적인 작업을 자동화하는 스크립트를 만들어줘
- 새 컴포넌트 생성
- 테스트 파일 생성
- 배포 전 체크
- 성능 측정"

# Development Workflow

## 기능 개발 프로세스
1. 이슈 생성 및 브랜치 생성
2. 탐색: 관련 코드 분석 (30분)
3. 계획: 구현 전략 수립 (30분)
4. 구현: TDD로 개발 (2-4시간)
5. 리뷰: 자체 코드 리뷰 (30분)
6. PR 생성 및 리뷰 요청

## 일일 루틴
- 09:00: 이슈 확인 및 우선순위 정리
- 09:30: 집중 코딩 (포모도로 기법)
- 14:00: 코드 리뷰
- 16:00: 문서 업데이트
- 17:00: 다음 날 계획

## 품질 체크리스트
- [ ] 테스트 커버리지 80% 이상
- [ ] 모든 함수에 JSDoc
- [ ] 성능 프로파일링 완료
- [ ] 접근성 검사 통과
- [ ] 보안 스캔 통과

# Terminal 1에서 작업 중단 시
claude "현재 작업 상황을 요약해줘.
다음에 다시 시작할 때 필요한 정보를 포함해줘"

# 다시 작업 시작 시
claude "이전에 작업하던 사용자 인증 기능을 계속해줘.
마지막 상태부터 이어서 진행해줘"

# 브랜치 전환 시 컨텍스트 자동 로드
claude "현재 브랜치(feature/user-auth)의 컨텍스트를 로드해줘.
관련 파일들과 작업 기록을 확인해줘"

# shared/context.md
## 현재 진행 상황
- Frontend: 로그인 컴포넌트 50% 완료
- Backend: 인증 API 80% 완료  
- Database: 스키마 완료, 마이그레이션 필요
- Testing: 단위 테스트 작성 중

## 공통 결정사항
- JWT 토큰 만료 시간: 1시간
- API 응답 형식: { success, data, message }
- 에러 코드 체계: HTTP 상태 코드 + 커스텀 코드

ecommerce/
├── frontend/          # React 앱
├── backend/           # Node.js API  
├── admin-panel/       # 관리자 페이지
├── mobile-app/        # React Native
└── infrastructure/    # Docker, K8s

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph LR
    subgraph devA [개발자 A: 프론트엔드]
        A1[Terminal A1<br/>Frontend 개발<br/>React + TypeScript]
        A2[Terminal A2<br/>Mobile App 개발<br/>React Native]
    end
    
    subgraph devB [개발자 B: 백엔드]
        B1[Terminal B1<br/>Backend API 개발<br/>Node.js + Express]
        B2[Terminal B2<br/>Infrastructure 관리<br/>Docker + K8s]
    end
    
    subgraph devC [개발자 C: 관리 및 품질]
        C1[Terminal C1<br/>Admin Panel 개발<br/>Next.js + Dashboard]
        C2[Terminal C2<br/>전체 테스트 및 QA<br/>Jest + Cypress]
    end
    
    subgraph shared [공유 리소스]
        S1[공통 API 스펙<br/>OpenAPI]
        S2[공유 컴포넌트<br/>Design System]
        S3[통합 문서<br/>Architecture Docs]
    end
    
    A1 --> S1
    A1 --> S2
    A2 --> S1
    A2 --> S2
    B1 --> S1
    B2 --> S3
    C1 --> S2
    C1 --> S3
    C2 --> S3
    
    classDef devStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef sharedStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A1,A2,B1,B2,C1,C2 devStyle
    class S1,S2,S3 sharedStyle

# Terminal A1 (Frontend)
claude "React + TypeScript + Vite 프로젝트를 설정해줘.
상태 관리, 라우팅, UI 라이브러리를 포함해줘"

# Terminal B1 (Backend)
claude "Express + TypeScript + Prisma 프로젝트를 설정해줘.
인증, 로깅, 에러 핸들링을 포함해줘"

# Terminal B2 (Infrastructure)
claude "Docker Compose로 개발 환경을 구성해줘.
PostgreSQL, Redis, Nginx를 포함해줘"

# 병렬 개발 시작
# Terminal A1: 제품 목록 컴포넌트
# Terminal A2: 모바일 네비게이션
# Terminal B1: 제품 API
# Terminal B2: 인증 시스템
# Terminal C1: 관리자 대시보드

# Terminal A1: 프론트엔드 통합 테스트
claude "React Testing Library로 핵심 플로우를 테스트해줘"

# Terminal B1: API 통합 테스트  
claude "Jest + Supertest로 API 엔드포인트를 테스트해줘"

# Terminal C2: E2E 테스트
claude "Playwright로 전체 사용자 플로우를 테스트해줘"

# Terminal 1 (Frontend Studio)
cd frontend/
claude "당신은 프론트엔드 UX 전문가입니다. 
다음 역할에 집중해주세요
- React/Vue/Angular 컴포넌트 아키텍처 설계
- 반응형 디자인과 접근성 최적화
- 성능 중심의 상태 관리 구현
- 브라우저 호환성과 Progressive Web App 기능
- 사용자 인터랙션 패턴과 애니메이션 최적화

현재 프로젝트: [프로젝트명]
기술 스택: React 18 + TypeScript + Vite
품질 기준: Lighthouse 95+ 점수 유지"

# 컴포넌트 아키텍처 설계
claude "엔터프라이즈급 디자인 시스템을 구축해줘
- Atomic Design 방법론 적용
- 타입 안전한 테마 시스템
- 자동화된 스토리북 문서화
- 컴포넌트 성능 벤치마킹
- 시각적 회귀 테스트 통합"

# 상태 관리 최적화
claude "복잡한 애플리케이션 상태를 효율적으로 관리해줘
- 서버 상태와 클라이언트 상태 분리
- 옵티미스틱 업데이트 패턴
- 백그라운드 동기화 전략
- 오프라인 모드 지원
- 실시간 데이터 바인딩"

# Terminal 2 (Backend Engine)
cd backend/
claude "당신은 백엔드 시스템 아키텍트입니다.
다음 영역에 전문성을 발휘해주세요
- 마이크로서비스 아키텍처와 도메인 주도 설계
- RESTful/GraphQL API 설계와 버전 관리
- 데이터베이스 최적화와 캐싱 전략
- 보안, 인증, 권한 관리 시스템
- 비동기 처리와 메시지 큐 아키텍처
- 모니터링, 로깅, 알림 시스템

현재 환경: Node.js/Python + PostgreSQL + Redis
성능 목표: 99.9% 가용성, 200ms 이하 응답시간
보안 기준: OWASP Top 10 완전 준수"

# 마이크로서비스 설계
claude "확장 가능한 마이크로서비스 아키텍처를 설계해줘
- 서비스 경계와 데이터 소유권 정의
- API Gateway와 서비스 메시 구성
- 분산 트랜잭션과 사가 패턴
- 서킷 브레이커와 벌크헤드 패턴
- 이벤트 소싱과 CQRS 적용"

# 고성능 데이터 처리
claude "대용량 데이터 처리 파이프라인을 구축해줘
- 스트리밍 데이터 처리 (Kafka/RabbitMQ)
- 배치 처리 최적화와 병렬화
- 데이터베이스 샤딩과 레플리케이션
- 캐시 계층화 전략 (L1/L2/L3)
- 실시간 분석과 메트릭 수집"

# Terminal 3 (DevOps Pipeline)
cd infrastructure/
claude "당신은 DevOps와 클라우드 아키텍처 전문가입니다.
다음 영역을 담당해주세요
- Infrastructure as Code (Terraform/Pulumi)
- 컨테이너 오케스트레이션 (Kubernetes/Docker Swarm)
- CI/CD 파이프라인 자동화 (GitLab CI/GitHub Actions)
- 클라우드 플랫폼 최적화 (AWS/GCP/Azure)
- 보안 강화와 컴플라이언스 관리
- 성능 모니터링과 자동 스케일링
- 재해 복구와 백업 전략

목표 환경: Production-Ready Kubernetes Cluster
가용성 목표: 99.99% uptime
보안 기준: SOC 2 Type II 준수"

# GitOps 파이프라인 구축
claude "완전 자동화된 GitOps 파이프라인을 구현해줘
- 멀티 환경 배포 전략 (dev/staging/prod)
- 블루-그린 배포와 카나리 릴리스
- 자동 롤백과 헬스체크 시스템
- 시크릿 관리와 암호화 (Vault/Sealed Secrets)
- 코드 품질 게이트와 보안 스캔
- 성능 테스트 자동화"

# 관찰 가능성 플랫폼
claude "종합적인 관찰 가능성 플랫폼을 구축해줘
- 메트릭 수집과 시각화 (Prometheus/Grafana)
- 분산 추적 (Jaeger/Zipkin)
- 구조화된 로깅 (ELK/Fluentd)
- 알림과 인시던트 관리 (PagerDuty/Slack)
- SLI/SLO 정의와 에러 버짓 관리"

# Terminal 4 (QA & Monitoring)
claude "당신은 품질 보증과 테스트 자동화 전문가입니다.
다음 품질 영역을 담당해주세요
- 테스트 피라미드 전략 (Unit/Integration/E2E)
- 성능 테스트와 부하 테스트 (JMeter/k6)
- 보안 테스트와 취약점 스캔 (OWASP ZAP)
- 접근성 테스트와 사용성 평가
- 브라우저 호환성과 크로스 플랫폼 테스트
- 테스트 데이터 관리와 환경 구성
- 품질 메트릭 수집과 리포팅

품질 목표: 테스트 커버리지 90%+
성능 기준: 응답시간 200ms 이하
보안 수준: Zero known vulnerabilities"

# 지능형 테스트 자동화
claude "AI 기반 테스트 자동화 시스템을 구축해줘
- 시각적 회귀 테스트 (Applitools/Percy)
- 자동 테스트 케이스 생성과 유지보수
- 플레이키 테스트 탐지와 해결
- 테스트 실행 최적화와 병렬화
- 실패 분석과 자동 버그 리포팅"

# 프로덕션 모니터링
claude "실시간 품질 모니터링 시스템을 구현해줘
- 실사용자 모니터링 (RUM)
- 합성 트랜잭션 모니터링
- 에러 추적과 크래시 리포팅
- A/B 테스트 플랫폼
- 사용자 피드백 수집과 분석"

# Frontend Development Context

## 주요 기술 스택
- React 18 + TypeScript
- Tailwind CSS
- React Query + Zustand

## 컴포넌트 규칙
- 함수형 컴포넌트만 사용
- Props는 인터페이스로 정의
- Storybook 스토리 필수

## 성능 최적화
- React.memo 적극 활용
- 번들 크기 최적화
- 이미지 최적화

# Backend Development Context

## 주요 기술 스택
- Node.js + Express + TypeScript
- PostgreSQL + Prisma
- Redis for caching

## API 설계 원칙
- RESTful 설계
- 일관된 에러 응답
- Rate limiting 적용

## 보안 요구사항
- JWT 토큰 인증
- 입력 검증 필수
- SQL Injection 방지

# Terminal 5 (Integration Hub)
claude "당신은 시스템 통합과 아키텍처 조정 전문가입니다.
다음 통합 영역을 담당해주세요
- 크로스 도메인 이슈 해결과 의사결정
- 아키텍처 일관성 검증과 가이드라인 적용
- 팀 간 커뮤니케이션과 지식 공유
- 기술 부채 관리와 리팩토링 계획
- 성능 병목 지점 분석과 최적화 방향
- 프로젝트 로드맵과 우선순위 조정

책임 범위: 전체 시스템 아키텍처
목표: 일관된 사용자 경험과 개발자 경험
원칙: 단순성, 확장성, 유지보수성"

# Sequential Thinking MCP 서버 통합
- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    mcp_config: |
      {
        "mcpServers": {
          "sequential-thinking": {
            "command": "npx",
            "args": [
              "-y",
              "@modelcontextprotocol/server-sequential-thinking"
            ]
          }
        }
      }
    allowed_tools: "mcp__sequential-thinking__sequentialthinking"

# 조직 특화 MCP 서버 설계
claude "우리 조직을 위한 커스텀 MCP 서버들을 설계해줘.
다음 시스템과의 통합이 필요해

내부 시스템 연동
- JIRA API: 이슈 트래킹과 프로젝트 관리
- Confluence: 문서와 지식 베이스 접근
- Slack API: 팀 커뮤니케이션과 알림
- Jenkins: CI/CD 파이프라인 상태
- DataDog: 모니터링과 성능 메트릭

외부 서비스 통합
- AWS API: 인프라 상태와 리소스 관리
- Kubernetes API: 컨테이너 오케스트레이션
- Database connections: 스키마 정보와 쿼리 실행
- Security scanners: 취약점 검사 결과

각 MCP 서버의 구현 방법과 보안 설정을 포함해줘."

# 종합적인 MCP 서버 설정
- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    mcp_config: |
      {
        "mcpServers": {
          "jira-integration": {
            "command": "node",
            "args": ["./scripts/mcp-jira-server.js"],
            "env": {
              "JIRA_URL": "${{ secrets.JIRA_URL }}",
              "JIRA_TOKEN": "${{ secrets.JIRA_TOKEN }}",
              "JIRA_PROJECT_KEY": "${{ vars.JIRA_PROJECT_KEY }}"
            }
          },
          "database-inspector": {
            "command": "python",
            "args": ["./scripts/mcp-db-server.py"],
            "env": {
              "DB_CONNECTION_STRING": "${{ secrets.DB_READ_ONLY_CONNECTION }}",
              "DB_TYPE": "postgresql"
            }
          },
          "security-scanner": {
            "command": "npx",
            "args": ["-y", "@company/security-mcp-server"],
            "env": {
              "SCANNER_API_KEY": "${{ secrets.SECURITY_SCANNER_API_KEY }}",
              "SCAN_LEVEL": "comprehensive"
            }
          },
          "monitoring-integration": {
            "command": "node",
            "args": ["./scripts/mcp-monitoring-server.js"],
            "env": {
              "DATADOG_API_KEY": "${{ secrets.DATADOG_API_KEY }}",
              "GRAFANA_URL": "${{ secrets.GRAFANA_URL }}",
              "GRAFANA_TOKEN": "${{ secrets.GRAFANA_TOKEN }}"
            }
          }
        }
      }
    allowed_tools: |
      mcp__jira-integration__create-issue,
      mcp__jira-integration__update-issue,
      mcp__jira-integration__search-issues,
      mcp__database-inspector__query-schema,
      mcp__database-inspector__explain-query,
      mcp__security-scanner__scan-code,
      mcp__security-scanner__check-vulnerabilities,
      mcp__monitoring-integration__get-metrics,
      mcp__monitoring-integration__create-alert

# 조직 특화 코드 품질 도구
claude "우리 팀의 코딩 표준을 자동으로 검사하는 커스텀 도구를 만들어줘.
다음 검사 항목을 포함해줘

코딩 표준 검사
- 함수 네이밍 규칙 (camelCase, 동사로 시작)
- 파일 구조 규칙 (feature/component 기반)
- 코멘트 작성 규칙 (JSDoc, docstring)
- 에러 처리 패턴 일관성
- 로깅 형식 표준화

성능 검사
- 메모리 누수 패턴 감지
- 비효율적인 루프와 쿼리
- 불필요한 렌더링 감지
- 번들 크기 최적화 기회

보안 검사
- 하드코딩된 시크릿 탐지
- SQL 인젝션 취약점
- XSS 공격 벡터
- 권한 부여 누락"

# 커스텀 문서화 자동화
- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    custom_instructions: |
      당신은 우리 조직의 문서화 전문가입니다.
      다음 문서화 표준을 준수해주세요
      
      API 문서화
      - OpenAPI 3.0 스펙 준수
      - 요청/응답 예시 포함
      - 에러 코드와 메시지 설명
      - 버전 관리 정보
      
      코드 문서화
      - 함수별 JSDoc/docstring
      - 복잡한 로직 인라인 주석
      - README 업데이트
      - 아키텍처 다이어그램
      
      사용자 문서화
      - 설치와 설정 가이드
      - 사용 예시와 튜토리얼
      - 문제 해결 가이드
      - FAQ 섹션
    allowed_tools: |
      Edit,Replace,GitLog,GitDiff,
      mcp__docs-generator__create-api-docs,
      mcp__docs-generator__update-readme,
      mcp__docs-generator__generate-diagrams

# 컨텍스트 기반 워크플로우 자동화
claude "PR 내용을 분석해서 자동으로 적절한 워크플로우를 선택하는 시스템을 만들어줘.
다음 분류 기준을 사용해줘

변경 유형 분석
- 기능 추가 (feature): 새로운 기능 구현
- 버그 수정 (bugfix): 기존 기능 오류 수정
- 리팩토링 (refactor): 코드 구조 개선
- 문서화 (docs): 문서 업데이트
- 설정 (config): 설정 파일 변경
- 테스트 (test): 테스트 코드 관련

영향도 분석
- Critical: 핵심 비즈니스 로직 변경
- High: 사용자 경험에 직접 영향
- Medium: 내부 로직 개선
- Low: 문서나 주석 업데이트

각 분류에 따른 자동화 워크플로우
- 필요한 리뷰어 자동 할당
- 적절한 테스트 전략 선택
- 배포 승인 프로세스 결정
- 모니터링 수준 설정"

# 지능형 품질 게이트 시스템
name: Adaptive Quality Gates
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  analyze-changes:
    runs-on: ubuntu-latest
    outputs:
      risk_level: ${{ steps.analysis.outputs.risk_level }}
      test_strategy: ${{ steps.analysis.outputs.test_strategy }}
      review_requirements: ${{ steps.analysis.outputs.review_requirements }}
      
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          
      - uses: anthropics/claude-code-action@beta
        id: analysis
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          direct_prompt: |
            이 PR의 변경사항을 분석하고 다음을 결정해주세요
            
            1. 위험도 평가 (low/medium/high/critical)
            2. 필요한 테스트 전략 (unit/integration/e2e/performance)
            3. 리뷰 요구사항 (standard/senior/architect/security)
            
            분석 기준
            - 변경된 파일의 수와 중요도
            - 비즈니스 로직 변경 여부
            - 보안 관련 코드 수정
            - 데이터베이스 스키마 변경
            - API 인터페이스 변경
            - 성능에 영향을 줄 수 있는 변경
            
            결과를 다음 형식으로 GitHub Actions output에 설정해주세요
            echo "risk_level=medium" >> $GITHUB_OUTPUT
            echo "test_strategy=integration,e2e" >> $GITHUB_OUTPUT  
            echo "review_requirements=senior,security" >> $GITHUB_OUTPUT

  quality-gate-low:
    needs: analyze-changes
    if: needs.analyze-changes.outputs.risk_level == 'low'
    runs-on: ubuntu-latest
    steps:
      - name: Fast Track Review
        run: echo "Low risk changes - fast track approved"

  quality-gate-high:
    needs: analyze-changes
    if: contains(fromJson('["high", "critical"]'), needs.analyze-changes.outputs.risk_level)
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@beta
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          direct_prompt: |
            이는 높은 위험도의 변경사항입니다.
            다음 강화된 검토를 수행해주세요
            
            1. 세부적인 코드 리뷰
            2. 보안 취약점 전체 검사
            3. 성능 영향 분석
            4. 롤백 계획 수립
            5. 모니터링 계획 제안
            
            추가로 다음 팀들을 리뷰에 포함시켜주세요
            @security-team @architecture-team @senior-engineers

claude "보안을 강화해줘.
CSRF 방지, Rate limiting, 
입력 검증, SQL Injection 방지,
XSS 방지를 구현해줘"

claude "Socket.io 보안을 강화해줘.
네임스페이스별 권한 검사, 메시지 검증,
스팸 방지, 악성 사용자 차단을 구현해줘"

# 엔터프라이즈 시크릿 관리 전략
claude "Claude Code Action을 위한 포괄적인 시크릿 관리 전략을 설계해줘.
다음 요소를 포함해줘

시크릿 계층 구조
- Organization level secrets (전사 공통)
- Repository level secrets (프로젝트별)  
- Environment level secrets (환경별)

보안 모범 사례
- 시크릿 로테이션 정책 (30-90일)
- 접근 권한 최소화 원칙
- 암호화와 전송 보안
- 감사 로그와 모니터링
- 사고 대응 절차

규정 준수
- SOC 2 Type II 요구사항
- GDPR 개인정보 보호
- HIPAA 보건의료 규정
- 업계별 특수 요구사항"

# 고급 시크릿 보안 설정
name: Secure Claude Action
on:
  issue_comment:
    types: [created]

jobs:
  security-validation:
    runs-on: ubuntu-latest
    environment: production
    steps:
      - name: API Key Validation
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # API 키 형식 검증
          if [[ ! "$ANTHROPIC_API_KEY" =~ ^sk-ant-api03- ]]; then
            echo "Invalid API key format"
            exit 1
          fi
          
          # API 키 활성화 상태 확인
          response=$(curl -s -H "x-api-key: $ANTHROPIC_API_KEY" \
                     https://api.anthropic.com/v1/models)
          if [[ $? -ne 0 ]]; then
            echo "API key validation failed"
            exit 1
          fi
          
      - name: Rate Limiting Check
        run: |
          # API 사용량 모니터링
          echo "Checking current API usage..."
          # 사용량이 임계값을 초과하면 중단
          
      - name: Security Context Validation
        run: |
          # 요청자 권한 확인
          if [[ "${{ github.actor }}" == "dependabot[bot]" ]]; then
            echo "Bot users not allowed"
            exit 1
          fi
          
          # 민감한 파일 변경 감지
          if git diff --name-only | grep -E "(secrets|keys|config)" > /dev/null; then
            echo "Sensitive files detected - additional approval required"
            # 추가 승인 프로세스 트리거
          fi

      - uses: anthropics/claude-code-action@beta
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          timeout_minutes: 30  # 실행 시간 제한
          disallowed_tools: "WebFetch,FileDelete,Bash(rm),Bash(curl)"

# 역할 기반 접근 제어 (RBAC) 설계
claude "Claude Code Action을 위한 RBAC 시스템을 설계해줘.
다음 역할과 권한을 정의해줘

역할 정의
- Admin: 전체 설정과 시크릿 관리
- Senior Developer: 모든 코드 변경 권한
- Developer: 제한된 코드 변경 권한  
- Reviewer: 읽기 전용 리뷰 권한
- External Contributor: 최소한의 상호작용

권한 매트릭스
- 파일 읽기/쓰기 권한
- 브랜치별 접근 제어
- 민감한 디렉토리 보호
- 시스템 명령어 실행 권한
- 외부 API 호출 권한

구현 방법
- GitHub Team 기반 권한 매핑
- 동적 권한 검증 로직
- 감사 로그 자동 생성
- 권한 에스컬레이션 프로세스"

# 민감한 데이터 보호 설정
- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    
    # 접근 금지 파일 패턴
    disallowed_paths: |
      - "**/.env*"
      - "**/secrets/**"
      - "**/keys/**"
      - "**/*password*"
      - "**/*secret*"
      - "**/config/production.yaml"
      
    # 허용된 도구만 사용
    allowed_tools: "Edit,Replace,GitLog,GitDiff"
    disallowed_tools: "Bash,WebFetch,FileDelete,NetworkAccess"
    
    # 커스텀 보안 지침
    custom_instructions: |
      보안 지침
      1. 절대로 시크릿이나 패스워드를 코드에 하드코딩하지 마세요
      2. 모든 외부 입력은 검증해야 합니다.
      3. 민감한 정보는 로그에 남기지 마세요
      4. 보안 관련 변경사항은 별도 승인이 필요합니다.
      5. 데이터베이스 연결 정보는 환경 변수로만 관리하세요

# 감사 로그 시스템 설계
claude "Claude Code Action의 모든 활동을 추적하는 감사 시스템을 설계해줘.
다음 요소를 포함해줘

로그 수집 대상
- 모든 API 호출과 응답
- 파일 변경과 커밋 내역
- 권한 요청과 승인/거부
- 에러와 예외 상황
- 성능과 리소스 사용량

로그 형식과 구조
- 구조화된 JSON 로그
- 타임스탬프와 상관관계 ID
- 사용자와 액션 컨텍스트
- 비즈니스 영향도 분류
- 보안 이벤트 마킹

저장과 분석
- 중앙화된 로그 수집 (ELK Stack)
- 실시간 알림과 대시보드
- 이상 패턴 자동 감지
- 규정 준수 리포팅
- 장기 보존 정책"

# 보안 모니터링 워크플로우
name: Security Monitoring
on:
  workflow_run:
    workflows: ["Claude AI Assistant"]
    types: [completed]

jobs:
  security-audit:
    runs-on: ubuntu-latest
    steps:
      - name: Audit Log Collection
        run: |
          # Claude Action 실행 로그 수집
          echo "Collecting audit logs..."
          
          # 보안 이벤트 감지
          if grep -i "security\|password\|secret" $GITHUB_EVENT_PATH; then
            echo "Security-related activity detected"
            # 알림 발송
          fi
          
      - name: Anomaly Detection
        run: |
          # 비정상적인 패턴 감지
          # - 비정상적으로 많은 파일 변경
          # - 민감한 파일에 대한 접근 시도
          # - 평소와 다른 시간대의 활동
          
      - name: Compliance Reporting
        run: |
          # 규정 준수 리포트 생성
          echo "Generating compliance report..."

### 4단계: Commit (커밋)

**코드 검증**

```bash
# 자동 검증
claude "커밋하기 전에 다음을 확인해줘
- 모든 테스트 통과
- 린팅 규칙 준수
- 타입 체크 통과
- 코드 커버리지 확인"

# 커밋 메시지 작성
claude "변경사항을 분석해서 의미 있는 커밋 메시지를 작성해줘.
conventional commits 형식을 따르고,
변경 이유와 영향을 명확히 설명해줘"

# 단위 테스트
claude "calculateDiscount 함수에 대한 단위 테스트를 작성해줘"

# 통합 테스트
claude "사용자 등록 API에 대한 통합 테스트를 작성해줘"

# 엣지 케이스
claude "이 함수의 엣지 케이스를 찾아서 테스트를 추가해줘"

# 테스트 커버리지
claude "테스트 커버리지를 확인하고 누락된 부분에 테스트를 추가해줘"

claude "이 오류 메시지가 무엇을 의미하는지 설명하고 해결 방법을 제시해줘
TypeError: Cannot read property 'name' of undefined"

claude "문제가 발생하는 것 같은 부분에 디버그 로그를 추가해줘"

claude "이 함수의 실행 흐름을 단계별로 추적할 수 있도록 코드를 수정해줘"

claude "이 코드의 성능 병목 지점을 찾아서 최적화해줘"

# 대화형 디버깅 시작
claude

> 서버가 시작되지 않아. 포트 3000에서 이미 사용 중이라는 오류가 나와.
< 포트 3000을 사용하는 프로세스를 확인해보겠습니다. 다음 명령을 실행해드릴게요
  lsof -i :3000

> 확인했더니 이전에 실행한 node 프로세스가 PID 12345로 실행 중이야.
< 해당 프로세스를 안전하게 종료하고, 향후 이런 문제를 방지하는 스크립트를 만들어드리겠습니다.
  1. 프로세스 종료 스크립트 생성
  2. package.json에 재시작 스크립트 추가
  3. graceful shutdown 코드 구현

> 좋아, 진행해줘. 그리고 왜 서버가 제대로 종료되지 않았는지도 알고 싶어.
< 서버 코드를 분석해보니 다음과 같은 문제들을 발견했습니다.
  1. SIGTERM 시그널 핸들러가 없어서 프로세스가 강제 종료됨
  2. 활성 연결이 정리되지 않고 있음
  3. 데이터베이스 연결 풀이 닫히지 않음
  
  이제 이 문제들을 하나씩 해결해드리겠습니다...

claude

> 서버가 며칠 동안 실행되면 메모리 사용량이 계속 증가해. 메모리 누수가 있는 것 같아.
< 메모리 누수를 추적하기 위해 다음 단계로 진행하겠습니다.
  1. 현재 코드에서 메모리 누수 가능성이 있는 패턴 검색
  2. 메모리 프로파일링 도구 설정
  3. 의심되는 코드 영역에 모니터링 추가

> 어떤 패턴들이 위험한가?
< 다음과 같은 패턴들을 발견했습니다.
  - 이벤트 리스너가 제거되지 않는 곳 3개
  - 전역 변수에 계속 데이터가 추가되는 캐시
  - 순환 참조가 있는 객체 구조
  각각 수정 방법을 보여드릴까요?

claude "이 코드베이스에서 리팩토링이 필요한 부분을 찾아줘.
다음을 중점적으로 확인해줘
- 중복 코드
- 긴 함수
- 복잡한 조건문
- 부적절한 이름"

# 1단계: 테스트 확보
claude "리팩토링 전에 현재 동작을 보장하는 테스트를 작성해줘"

# 2단계: 작은 단위로 개선
claude "한 번에 하나씩 리팩토링을 진행해줘.
각 단계마다 테스트가 통과하는지 확인해줘"

# 3단계: 성능 검증
claude "리팩토링 전후의 성능을 비교해줘.
벤치마크를 실행하고 결과를 분석해줘"

claude "코드 품질을 측정하고 개선 방안을 제시해줘
- 순환 복잡도
- 코드 커버리지
- 기술 부채
- 의존성 복잡도"

# 엔터프라이즈 모니터링 전략
claude "Claude Code Action을 위한 종합적인 모니터링 시스템을 설계해줘.
다음 계층별 모니터링을 포함해줘

인프라 계층
- GitHub Actions 러너 리소스 사용량
- API 응답 시간과 처리량
- 네트워크 지연 시간과 패킷 손실
- 저장소 I/O 성능
- 메모리와 CPU 사용 패턴

애플리케이션 계층
- Claude API 호출 성공률과 지연 시간
- 워크플로우 실행 시간과 성공률
- 오류 발생 빈도와 패턴
- 사용자 요청 처리 상태
- 캐시 히트율과 효율성

비즈니스 계층
- 사용자 만족도와 피드백
- 코드 품질 개선 지표
- 개발 생산성 향상 측정
- 비용 효율성과 ROI
- 팀 협업 효과성

모니터링 도구 통합
- Prometheus + Grafana 대시보드
- DataDog APM과 로그 분석
- AWS CloudWatch (Bedrock 사용 시)
- Google Cloud Monitoring (Vertex 사용 시)
- 커스텀 메트릭 수집과 알림"

# 모니터링 워크플로우
name: Claude Action Monitoring
on:
  schedule:
    - cron: '*/5 * * * *'  # 5분마다 실행
  workflow_run:
    workflows: ["Claude AI Assistant"]
    types: [completed, requested, in_progress]

jobs:
  health-check:
    runs-on: ubuntu-latest
    steps:
      - name: API Health Check
        id: health
        run: |
          # Anthropic API 상태 확인
          ANTHROPIC_STATUS=$(curl -s -w "%{http_code}" -H "x-api-key: ${{ secrets.ANTHROPIC_API_KEY }}" \
                            https://api.anthropic.com/v1/models -o /dev/null)
          
          # API 응답 시간 측정
          RESPONSE_TIME=$(curl -w "%{time_total}" -s -o /dev/null \
                         -H "x-api-key: ${{ secrets.ANTHROPIC_API_KEY }}" \
                         https://api.anthropic.com/v1/models)
          
          echo "api_status=$ANTHROPIC_STATUS" >> $GITHUB_OUTPUT
          echo "response_time=$RESPONSE_TIME" >> $GITHUB_OUTPUT
          
      - name: Usage Metrics Collection
        run: |
          # API 사용량 수집
          echo "Collecting usage metrics..."
          
          # GitHub Actions 사용량 확인
          gh api /repos/${{ github.repository }}/actions/workflows \
            --jq '.workflows[] | select(.name == "Claude AI Assistant") | .id' > workflow_id.txt
          
          # 최근 실행 통계 수집
          WORKFLOW_ID=$(cat workflow_id.txt)
          gh api "/repos/${{ github.repository }}/actions/workflows/$WORKFLOW_ID/runs?per_page=100" \
            --jq '.workflow_runs | group_by(.conclusion) | map({conclusion: .[0].conclusion, count: length})'
            
      - name: Performance Analysis
        run: |
          # 성능 지표 분석
          echo "Analyzing performance metrics..."
          
          # 평균 실행 시간 계산
          # 성공률 계산
          # 에러 패턴 분석
          
      - name: Alert on Issues
        if: steps.health.outputs.api_status != '200' || steps.health.outputs.response_time > '2.0'
        run: |
          # Slack 알림 발송
          curl -X POST -H 'Content-type: application/json' \
            --data '{"text":"🚨 Claude Code Action Alert: API issues detected"}' \
            ${{ secrets.SLACK_WEBHOOK_URL }}

# 성능 최적화 방안
claude "Claude Code Action의 성능을 최적화하는 전략을 수립해줘.
다음 영역별 최적화를 포함해줘

API 호출 최적화
- 요청 배칭과 병렬 처리
- 결과 캐싱 전략 (Redis, Memcached)
- 지능형 재시도 로직
- 부분 응답과 스트리밍
- 컨텍스트 압축과 최적화

워크플로우 최적화
- 조건부 실행과 스킵 로직
- 의존성 최적화와 병렬화
- 아티팩트 캐싱과 재사용
- 환경 준비 시간 단축
- 리소스 효율적 할당

코드 분석 최적화
- 증분 분석 (변경된 부분만)
- 지능형 필터링 (관련 파일만)
- 사전 컴파일된 분석 결과 활용
- 백그라운드 전처리
- 예측적 프리페칭

모델 활용 최적화
- 적절한 모델 선택 (작업별)
- 프롬프트 최적화와 압축
- 컨텍스트 윈도우 관리
- 토큰 사용량 최적화
- 응답 품질 vs 속도 균형"

# 적응적 리소스 관리
name: Adaptive Resource Management
on:
  schedule:
    - cron: '0 */6 * * *'  # 6시간마다.

jobs:
  resource-optimization:
    runs-on: ubuntu-latest
    steps:
      - name: Analyze Usage Patterns
        id: analysis
        run: |
          # 사용 패턴 분석
          PEAK_HOURS=$(gh api "/repos/${{ github.repository }}/actions/workflows" \
                      --jq '.workflows[] | select(.name == "Claude AI Assistant") | .id' | \
                      xargs -I {} gh api "/repos/${{ github.repository }}/actions/workflows/{}/runs" \
                      --jq '.workflow_runs[0:50] | group_by(.created_at[11:13]) | 
                            map({hour: .[0].created_at[11:13], count: length}) | 
                            sort_by(.count) | reverse | .[0:3] | map(.hour) | join(",")')
          
          echo "peak_hours=$PEAK_HOURS" >> $GITHUB_OUTPUT
          
      - name: Optimize Configuration
        run: |
          # 사용 패턴에 따른 설정 최적화
          echo "Peak hours: ${{ steps.analysis.outputs.peak_hours }}"
          
          # 러너 타입 조정
          # 타임아웃 설정 최적화
          # 모델 선택 전략 업데이트
          
      - name: Update Scaling Policy
        run: |
          # 자동 스케일링 정책 업데이트
          echo "Updating scaling policies based on usage patterns..."

# 비용 최적화 전략
claude "Claude Code Action의 운영 비용을 모니터링하고 최적화하는 시스템을 만들어줘.
다음 요소를 포함해줘

비용 추적
- API 호출 비용 (토큰 사용량 기반)
- GitHub Actions 런타임 비용
- 클라우드 인프라 비용 (Bedrock/Vertex)
- 스토리지와 네트워크 비용
- 모니터링 도구 비용

비용 최적화
- 토큰 효율적인 프롬프트 설계
- 캐싱을 통한 중복 호출 방지
- 스마트 모델 선택 (비용 vs 성능)
- 예약 인스턴스와 할인 활용
- 자동 스케일링과 리소스 해제

예산 관리
- 팀별/프로젝트별 비용 할당
- 예산 임계값과 알림 설정
- 월별 비용 예측과 계획
- 비용 대비 효과 측정
- 예산 초과 방지 메커니즘

리포팅과 분석
- 실시간 비용 대시보드
- 사용 패턴별 비용 분석
- ROI 계산과 비즈니스 가치
- 비용 트렌드와 예측
- 최적화 기회 식별"

# 엔터프라이즈급 워크트리 아키텍처 구성
# 1. 기능별 격리된 개발 환경
git worktree add ../project-auth-service feature/auth-microservice
git worktree add ../project-payment-gateway feature/payment-integration
git worktree add ../project-user-dashboard feature/dashboard-redesign
git worktree add ../project-mobile-api feature/mobile-optimization
git worktree add ../project-security-audit hotfix/security-vulnerabilities

# 2. 각 워크트리에 특화된 Claude 설정
cd ../project-auth-service
echo "# Authentication Service Context" > CLAUDE.md
echo "Focus: OAuth2/JWT implementation, security best practices" >> CLAUDE.md
echo "Tech Stack: Node.js + Express + Passport" >> CLAUDE.md
echo "Security Level: CRITICAL - all inputs must be validated" >> CLAUDE.md
claude "당신은 보안 인증 시스템 전문가입니다. 
OAuth2와 JWT를 활용한 엔터프라이즈급 인증 시스템을 구축해주세요.
보안 모범 사례와 OWASP 가이드라인을 엄격히 준수해주세요."

cd ../project-payment-gateway
echo "# Payment Gateway Context" > CLAUDE.md
echo "Focus: PCI DSS compliance, payment processing" >> CLAUDE.md
echo "Tech Stack: Python + FastAPI + Stripe/PayPal" >> CLAUDE.md
echo "Compliance: PCI DSS Level 1, SOX compliance required" >> CLAUDE.md
claude "당신은 결제 시스템 전문가입니다.
PCI DSS 준수와 금융 보안 요구사항을 충족하는
안전하고 확장 가능한 결제 게이트웨이를 구현해주세요."

cd ../project-user-dashboard
echo "# User Dashboard Context" > CLAUDE.md
echo "Focus: React performance, user experience" >> CLAUDE.md
echo "Tech Stack: React 18 + TypeScript + Tailwind" >> CLAUDE.md
echo "Performance: Lighthouse 95+, Core Web Vitals optimized" >> CLAUDE.md
claude "당신은 프론트엔드 UX 전문가입니다.
사용자 중심의 대시보드를 설계하고 구현해주세요.
성능 최적화와 접근성을 최우선으로 고려해주세요."

# 고급 워크트리 관리 자동화
claude "엔터프라이즈급 Git Worktree 관리 시스템을 구축해줘

주요 기능
1. 기능별 템플릿 기반 워크트리 생성
2. 환경별 CLAUDE.md 자동 설정
3. 의존성 충돌 탐지와 해결
4. 작업 진행률 추적과 리포팅
5. 자동 정리와 아카이빙
6. 팀 협업을 위한 워크트리 공유

기술 요구사항
- Shell scripting with error handling
- JSON/YAML 설정 파일 지원
- 크로스 플랫폼 호환성 (Linux/macOS/Windows)
- 로깅과 감사 추적
- 백업과 복구 메커니즘"

#!/bin/bash
# new-feature.sh

FEATURE_NAME=$1
WORKTREE_PATH="../project-$FEATURE_NAME"

# 브랜치 생성
git checkout -b "feature/$FEATURE_NAME"

# Worktree 추가
git worktree add "$WORKTREE_PATH" "feature/$FEATURE_NAME"

# 새 터미널에서 Claude 시작
cd "$WORKTREE_PATH"
osascript -e "tell app \"Terminal\" to do script \"cd $WORKTREE_PATH && claude\""

echo "Feature branch 'feature/$FEATURE_NAME' created in $WORKTREE_PATH"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph TB
    subgraph project [마이크로서비스 프로젝트 구조]
        A[user-service<br/>Terminal 1<br/>사용자 관리]
        B[product-service<br/>Terminal 2<br/>상품 관리]
        C[order-service<br/>Terminal 3<br/>주문 처리]
        D[payment-service<br/>Terminal 4<br/>결제 처리]
        E[api-gateway<br/>Terminal 5<br/>통합 관리]
    end
    
    subgraph terminals [병렬 개발 환경]
        T1[Claude Instance 1<br/>사용자 인증 및 프로필]
        T2[Claude Instance 2<br/>상품 카탈로그 및 검색]
        T3[Claude Instance 3<br/>주문 워크플로우]
        T4[Claude Instance 4<br/>결제 통합]
        T5[Claude Instance 5<br/>API 라우팅 및 보안]
    end
    
    A -.-> T1
    B -.-> T2
    C -.-> T3
    D -.-> T4
    E -.-> T5
    
    T1 --> T5
    T2 --> T5
    T3 --> T5
    T4 --> T5
    
    classDef serviceStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef terminalStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C,D,E serviceStyle
    class T1,T2,T3,T4,T5 terminalStyle

# Terminal 1 (API Gateway)
claude "API Gateway를 구현해줘.
라우팅, 인증, 로드 밸런싱, 모니터링을 포함해줘"

# Terminal 2 (User Service)
claude "사용자 관리 마이크로서비스를 개발해줘.
회원가입, 로그인, 프로필 관리 기능을 포함해줘"

# Terminal 3 (Product Service)  
claude "상품 관리 마이크로서비스를 개발해줘.
상품 CRUD, 재고 관리, 검색 기능을 포함해줘"

# OpenAPI 스펙 동기화
claude "각 서비스의 OpenAPI 스펙을 생성하고,
API Gateway에서 통합 문서를 만들어줘"

# 공통 작업
claude "사용자 관리 API의 OpenAPI 스펙을 정의해줘.
엔드포인트, 요청/응답 스키마, 에러 코드를 포함해줘"

# Terminal 1 (Backend)
claude "정의된 API 스펙에 따라 백엔드를 구현해줘.
Mock 데이터로 먼저 동작하게 만들어줘"

# Terminal 2 (Frontend)  
claude "API 스펙을 기반으로 프론트엔드를 구현해줘.
MSW를 사용해서 API를 모킹해줘"

# 공통 타입 정의
claude "백엔드와 프론트엔드에서 공유할 타입 정의를 만들어줘.
Zod 스키마에서 TypeScript 타입을 자동 생성하도록 해줘"

# API 변경 시 자동 업데이트
claude "백엔드 API가 변경되면 프론트엔드 타입도 
자동으로 업데이트하는 시스템을 구축해줘"

# 패턴 1: 역할별 세션 분리
Terminal 1: claude --session "architect"     # 설계/구조 전담
Terminal 2: claude --session "implementer"   # 구현 전담
Terminal 3: claude --session "reviewer"      # 리뷰/검증 전담

# 패턴 2: 레이어별 세션 분리
Terminal 1: claude --session "frontend"      # UI/UX 작업
Terminal 2: claude --session "backend"       # API/DB 작업
Terminal 3: claude --session "infra"         # DevOps/배포 작업

# CLAUDE.md에 세션 간 공유 정보 기록
## 현재 작업 상태
- Frontend: 로그인 UI 완료, 대시보드 진행 중
- Backend: Auth API 완료, Payment API 진행 중
- 공유 규칙: API 응답은 { success, data, error } 형식

# 세션 A에서 결과를 파일로 저장
claude "API 스펙을 api-spec.md로 정리해줘"

# 세션 B에서 파일 참조
claude "api-spec.md를 읽고 프론트엔드 API 클라이언트를 구현해줘"

# 세션 A: 작업 완료 후 커밋
git commit -m "feat: auth API 완료"

# 세션 B: 최신 코드 기반으로 작업
git pull && claude "최근 커밋된 auth API를 확인하고 프론트엔드 연동해줘"

프로젝트: 10,000+ 파일 SaaS 애플리케이션

세션 구성:
├── 세션 1 (설계): 아키텍처 결정, 의존성 관리
│   └── CLAUDE.md + 아키텍처 문서 참조
├── 세션 2 (프론트): React 컴포넌트 개발
│   └── 컴포넌트 디렉토리만 스코프
├── 세션 3 (백엔드): API + DB 마이그레이션
│   └── api/ + database/ 디렉토리 스코프
├── 세션 4 (테스트): E2E + 단위 테스트
│   └── tests/ 디렉토리 + 테스트 설정
└── 세션 5 (리뷰): 코드 리뷰 + 품질 검증
    └── git diff 기반 변경 사항만 검토

동기화 포인트:
- 매 기능 완료 시 git commit
- API 스펙 변경 시 api-spec.md 업데이트
- 아키텍처 변경 시 CLAUDE.md 업데이트

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph TD
    A[Headless 모드] --> B[환경 감지]
    A --> C[컨텍스트 분석]
    A --> D[전략 수립]
    
    B --> E[Production<br/>최고 품질 모델]
    B --> F[Staging<br/>표준 검증]
    B --> G[Development<br/>빠른 피드백]
    
    C --> H[프로젝트 규모]
    C --> I[기술 스택]
    C --> J[팀 구조]
    
    D --> K[분석 깊이]
    D --> L[우선순위 영역]
    D --> M[리소스 할당]
    
    E --> N[종합 품질 분석]
    F --> O[표준 검증 프로세스]
    G --> P[빠른 피드백 루프]
    
    classDef envStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef analysisStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C,D envStyle
    class E,F,G,H,I,J,K,L,M,N,O,P analysisStyle

# 환경별 적응형 분석
claude --headless --context production \
  "프로덕션 배포를 위한 종합 위험도 평가를 수행해주세요.
   보안, 성능, 안정성, 비즈니스 임팩트를 종합 분석하고
   배포 승인 여부를 JSON 형태로 제공해주세요."

# 실시간 스트리밍 분석
claude --headless --stream --output-format json \
  "대용량 코드 변경사항을 실시간으로 분석하며
   중요한 이슈 발견 시 즉시 알림을 제공해주세요."

# 지능형 조건부 실행
#!/bin/bash
# advanced-quality-gate.sh

set -euo pipefail

# 환경 감지 및 설정
DETECT_ENV=$(claude --headless --quiet \
  "현재 Git 브랜치와 변경사항을 분석하여
   적절한 품질 검증 수준을 결정해주세요 (minimal/standard/strict)")

case $DETECT_ENV in
  "strict")
    QUALITY_THRESHOLD=95
    SECURITY_SCAN=true
    PERFORMANCE_TEST=true
    ;;
  "standard")
    QUALITY_THRESHOLD=85
    SECURITY_SCAN=true
    PERFORMANCE_TEST=false
    ;;
  "minimal")
    QUALITY_THRESHOLD=75
    SECURITY_SCAN=false
    PERFORMANCE_TEST=false
    ;;
esac

# 적응형 품질 분석
QUALITY_RESULT=$(claude --headless --output quality-report.json \
  "코드 품질을 $QUALITY_THRESHOLD% 기준으로 분석해주세요.
   기준: 복잡도, 중복도, 테스트 커버리지, 문서화 수준
   결과: pass/fail과 상세 개선 방안")

# 조건부 보안 스캔
if [ "$SECURITY_SCAN" = true ]; then
  SECURITY_RESULT=$(claude --headless --output security-report.json \
    "OWASP Top 10과 SANS Top 25 기준으로
     보안 취약점을 종합 분석해주세요.
     심각도별 분류와 수정 우선순위 포함")
fi

# 지능형 의사결정
DECISION=$(claude --headless \
  "품질 리포트와 보안 리포트를 종합하여
   배포 승인 여부를 결정해주세요.
   결정 근거와 함께 명확한 approve/reject 답변")

if [[ $DECISION == *"approve"* ]]; then
  echo "✅ 품질 게이트 통과 - 배포 승인"
  exit 0
else
  echo "❌ 품질 게이트 실패 - 개선 필요"
  claude --headless "개선 방안과 예상 소요 시간을 제시해주세요"
  exit 1
fi

# 기본 환경 변수 (모든 환경 공통)
export CLAUDE_API_KEY="sk-ant-..."
export CLAUDE_MODEL="claude-3-sonnet-20240229"  # 비용 효율적 기본 모델
export CLAUDE_HEADLESS=true
export CLAUDE_TIMEOUT=300  # 5분 타임아웃
export CLAUDE_RETRY_COUNT=3
export CLAUDE_LOG_LEVEL="info"

# 환경별 세부 구성
case "$ENVIRONMENT" in
  "production")
    export CLAUDE_MODEL="claude-3-opus-20240229"  # 최고 품질
    export CLAUDE_OUTPUT_FORMAT="structured-json"
    export CLAUDE_VALIDATION_STRICT=true
    export CLAUDE_AUDIT_ENABLED=true
    ;;
  "staging")
    export CLAUDE_MODEL="claude-3-sonnet-20240229"
    export CLAUDE_OUTPUT_FORMAT="json"
    export CLAUDE_VALIDATION_STANDARD=true
    ;;
  "development")
    export CLAUDE_MODEL="claude-3-haiku-20240307"  # 빠른 반응
    export CLAUDE_OUTPUT_FORMAT="markdown"
    export CLAUDE_VALIDATION_MINIMAL=true
    ;;
esac

# 프로젝트별 컨텍스트 구성
export CLAUDE_PROJECT_TYPE="web-application"
export CLAUDE_TECH_STACK="react,node,typescript,postgresql"
export CLAUDE_TEAM_SIZE="12"
export CLAUDE_COMPLIANCE_LEVEL="SOC2"  # SOC2, HIPAA, PCI-DSS 등
export CLAUDE_QUALITY_GATES="security,performance,accessibility"

# 고급 기능 설정
export CLAUDE_CACHE_ENABLED=true
export CLAUDE_CACHE_TTL=3600  # 1시간
export CLAUDE_PARALLEL_ANALYSIS=true
export CLAUDE_MAX_CONCURRENT=4
export CLAUDE_MEMORY_LIMIT="2GB"

# 보안 및 규정 준수
export CLAUDE_DATA_RESIDENCY="us-east-1"
export CLAUDE_PII_DETECTION=true
export CLAUDE_SENSITIVE_DATA_MASKING=true
export CLAUDE_AUDIT_LOG_RETENTION="90d"

#!/bin/bash
# claude-config-loader.sh

# 프로젝트별 동적 구성 로드
load_claude_config() {
    local project_root="$(git rev-parse --show-toplevel)"
    local config_file="$project_root/.claude/ci-config.json"
    
    if [[ -f "$config_file" ]]; then
        # JSON 구성 파일에서 환경 변수 로드
        eval "$(jq -r 'to_entries[] | "export CLAUDE_\(.key | ascii_upcase)=\(.value)"' "$config_file")"
    fi
    
    # Git 메타데이터 기반 자동 설정
    export CLAUDE_GIT_BRANCH="$(git rev-parse --abbrev-ref HEAD)"
    export CLAUDE_GIT_COMMIT="$(git rev-parse HEAD)"
    export CLAUDE_GIT_AUTHOR="$(git log -1 --pretty=format:'%an')"
    
    # 프로젝트 규모 자동 탐지
    local file_count=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" | wc -l)
    if (( file_count > 1000 )); then
        export CLAUDE_PROJECT_SCALE="large"
        export CLAUDE_ANALYSIS_DEPTH="comprehensive"
    elif (( file_count > 100 )); then
        export CLAUDE_PROJECT_SCALE="medium"
        export CLAUDE_ANALYSIS_DEPTH="standard"
    else
        export CLAUDE_PROJECT_SCALE="small"
        export CLAUDE_ANALYSIS_DEPTH="focused"
    fi
}

# 사용법
load_claude_config

# 디자인 파일 제공
claude "이 Figma 디자인 스크린샷을 보고 
React 컴포넌트로 구현해줘. 
반응형 디자인과 다크 모드도 지원해야 해"

# 초기 구현
claude "기본 레이아웃과 스타일을 먼저 구현해줘"

# 세부 조정
claude "패딩을 조금 늘리고, 폰트 크기를 조정해줘.
호버 효과와 트랜지션도 추가해줘"

# 인터랙션 추가
claude "클릭 시 애니메이션과 로딩 상태를 추가해줘"

claude "디자인 시스템을 기반으로 컴포넌트 라이브러리를 만들어줘.
Button, Card, Modal 등 기본 컴포넌트를 포함하고,
Storybook으로 문서화해줘"

claude "이 코드베이스에서 리팩토링이 필요한 부분을 찾아줘.
다음을 중점적으로 확인해줘
- 중복 코드
- 긴 함수
- 복잡한 조건문
- 부적절한 이름"

# 1단계: 테스트 확보
claude "리팩토링 전에 현재 동작을 보장하는 테스트를 작성해줘"

# 2단계: 작은 단위로 개선
claude "한 번에 하나씩 리팩토링을 진행해줘.
각 단계마다 테스트가 통과하는지 확인해줘"

# 3단계: 성능 검증
claude "리팩토링 전후의 성능을 비교해줘.
벤치마크를 실행하고 결과를 분석해줘"

claude "코드 품질을 측정하고 개선 방안을 제시해줘
- 순환 복잡도
- 코드 커버리지
- 기술 부채
- 의존성 복잡도"

claude "코드를 분석해서 API 문서를 자동으로 생성해줘.
OpenAPI(Swagger) 스펙으로 만들고,
예제 요청/응답도 포함해줘"

claude "JSDoc/TSDoc 주석을 파싱해서 
개발자 문서를 생성해줘.
함수 설명, 파라미터, 반환값, 예제를 포함해줘"

claude "시스템 아키텍처를 Mermaid 다이어그램으로 그려줘.
컴포넌트 간 관계와 데이터 흐름을 표시해줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
gantt
    title 3일간 결제 기능 추가 워크플로우
    dateFormat  X
    axisFormat %d
    
    section Day 1: 탐색과 계획
    기존 시스템 분석     :active, d1-morning, 0, 1
    결제 기능 설계      :d1-afternoon, after d1-morning, 1
    아키텍처 문서화     :d1-doc, after d1-afternoon, 1
    
    section Day 2: 구현
    백엔드 API 개발     :d2-backend, 1, 1
    프론트엔드 UI      :d2-frontend, after d2-backend, 1
    단위 테스트 작성    :d2-test, after d2-frontend, 1
    
    section Day 3: 통합과 배포
    통합 테스트        :d3-integration, 2, 1
    E2E 테스트        :d3-e2e, after d3-integration, 1
    문서화 및 배포 준비  :d3-deploy, after d3-e2e, 1

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}, "flowchart": {"htmlLabels": false, "useMaxWidth": false}}}%%
graph TB
    subgraph project [마이크로서비스 프로젝트 구조]
        A[user-service<br/>Terminal 1<br/>사용자 관리]
        B[product-service<br/>Terminal 2<br/>상품 관리]
        C[order-service<br/>Terminal 3<br/>주문 처리]
        D[payment-service<br/>Terminal 4<br/>결제 처리]
        E[api-gateway<br/>Terminal 5<br/>통합 관리]
    end
    
    subgraph terminals [병렬 개발 환경]
        T1[Claude Instance 1<br/>사용자 인증 및 프로필]
        T2[Claude Instance 2<br/>상품 카탈로그 및 검색]
        T3[Claude Instance 3<br/>주문 워크플로우]
        T4[Claude Instance 4<br/>결제 통합]
        T5[Claude Instance 5<br/>API 라우팅 및 보안]
    end
    
    A -.-> T1
    B -.-> T2
    C -.-> T3
    D -.-> T4
    E -.-> T5
    
    T1 --> T5
    T2 --> T5
    T3 --> T5
    T4 --> T5
    
    classDef serviceStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef terminalStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C,D,E serviceStyle
    class T1,T2,T3,T4,T5 terminalStyle

# Terminal 1 (API Gateway)
claude "API Gateway를 구현해줘.
라우팅, 인증, 로드 밸런싱, 모니터링을 포함해줘"

# Terminal 2 (User Service)
claude "사용자 관리 마이크로서비스를 개발해줘.
회원가입, 로그인, 프로필 관리 기능을 포함해줘"

# Terminal 3 (Product Service)  
claude "상품 관리 마이크로서비스를 개발해줘.
상품 CRUD, 재고 관리, 검색 기능을 포함해줘"

# OpenAPI 스펙 동기화
claude "각 서비스의 OpenAPI 스펙을 생성하고,
API Gateway에서 통합 문서를 만들어줘"

# 공통 작업
claude "사용자 관리 API의 OpenAPI 스펙을 정의해줘.
엔드포인트, 요청/응답 스키마, 에러 코드를 포함해줘"

# Terminal 1 (Backend)
claude "정의된 API 스펙에 따라 백엔드를 구현해줘.
Mock 데이터로 먼저 동작하게 만들어줘"

# Terminal 2 (Frontend)  
claude "API 스펙을 기반으로 프론트엔드를 구현해줘.
MSW를 사용해서 API를 모킹해줘"

# 공통 타입 정의
claude "백엔드와 프론트엔드에서 공유할 타입 정의를 만들어줘.
Zod 스키마에서 TypeScript 타입을 자동 생성하도록 해줘"

# API 변경 시 자동 업데이트
claude "백엔드 API가 변경되면 프론트엔드 타입도 
자동으로 업데이트하는 시스템을 구축해줘"

# AWS Bedrock을 통한 Claude Code Action
name: Claude via AWS Bedrock
on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]

permissions:
  id-token: write  # OIDC 토큰 생성을 위해 필요
  contents: write
  pull-requests: write
  issues: write

jobs:
  claude-bedrock:
    runs-on: ubuntu-latest
    environment: production
    
    steps:
      - name: Configure AWS Credentials (OIDC)
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}
          role-session-name: claude-code-action
          aws-region: us-west-2
          
      - name: Validate AWS Permissions
        run: |
          # Bedrock 접근 권한 확인
          aws bedrock list-foundation-models --region us-west-2
          
          # Cross-region inference 권한 확인
          aws bedrock list-inference-profiles --region us-west-2
          
      - name: Generate GitHub App Token
        id: app-token
        uses: actions/create-github-app-token@v2
        with:
          app-id: ${{ secrets.APP_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}
          
      - uses: anthropics/claude-code-action@beta
        with:
          github_token: ${{ steps.app-token.outputs.token }}
          model: "anthropic.claude-3-7-sonnet-20250219-beta:0"  # Cross-region inference
          use_bedrock: "true"
          timeout_minutes: 45
          
          custom_instructions: |
            AWS Bedrock 환경에서 실행 중입니다.
            다음 AWS 특화 고려사항을 적용해주세요
            - AWS 보안 모범 사례 준수
            - CloudTrail 로깅 고려
            - VPC 네트워크 정책 인식
            - AWS 리소스 태깅 표준 적용

# AWS IAM 설정 최적화
claude "Claude Code Action을 위한 AWS IAM 설정을 최적화해줘.
다음을 포함해줘

IAM 역할 정의
- GitHub Actions용 OIDC 신뢰 관계
- Bedrock 모델 접근 권한
- CloudWatch 로깅 권한
- 최소 권한 원칙 적용

보안 강화 설정
- 조건부 접근 제어
- 리소스 기반 정책
- 시간 기반 접근 제한
- IP 주소 화이트리스트

Cross-region inference 설정
- 다중 리전 모델 접근
- 지연 시간 최적화
- 가용성 향상 전략
- 비용 최적화 고려사항"

# Google Vertex AI를 통한 Claude Code Action
name: Claude via Google Vertex AI  
on:
  issue_comment:
    types: [created]
  pull_request_review_comment:
    types: [created]

permissions:
  id-token: write  # OIDC 토큰 생성을 위해 필요
  contents: write
  pull-requests: write
  issues: write

jobs:
  claude-vertex:
    runs-on: ubuntu-latest
    environment: production
    
    steps:
      - name: Authenticate to Google Cloud
        uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: ${{ secrets.GCP_WORKLOAD_IDENTITY_PROVIDER }}
          service_account: ${{ secrets.GCP_SERVICE_ACCOUNT }}
          
      - name: Set up Cloud SDK
        uses: google-github-actions/setup-gcloud@v2
        
      - name: Validate GCP Permissions
        run: |
          # Vertex AI 접근 권한 확인
          gcloud ai models list --region=us-central1
          
          # 프로젝트 설정 확인
          gcloud config list project
          
      - name: Generate GitHub App Token
        id: app-token
        uses: actions/create-github-app-token@v2
        with:
          app-id: ${{ secrets.APP_ID }}
          private-key: ${{ secrets.APP_PRIVATE_KEY }}
          
      - uses: anthropics/claude-code-action@beta
        with:
          github_token: ${{ steps.app-token.outputs.token }}
          model: "claude-3-7-sonnet@20250219"
          use_vertex: "true"
          timeout_minutes: 45
          
          custom_instructions: |
            Google Vertex AI 환경에서 실행 중입니다.
            다음 GCP 특화 고려사항을 적용해주세요
            - Google Cloud 보안 모범 사례 준수
            - Cloud Audit Logs 인식
            - VPC 및 방화벽 정책 고려
            - Google Cloud 리소스 라벨링 표준 적용

# 멀티 클라우드 아키텍처 설계
claude "Claude Code Action을 위한 멀티 클라우드 전략을 설계해줘.
다음 요소를 포함해줘

클라우드 선택 기준
- 지역별 가용성과 지연 시간
- 비용 효율성과 예산 관리
- 규정 준수 요구사항
- 성능과 처리량 특성
- 장애 복구 능력

페일오버 시나리오
- Primary: Direct Anthropic API
- Secondary: AWS Bedrock (if primary fails)
- Tertiary: Google Vertex AI (if both fail)

자동 전환 로직
- 상태 모니터링과 헬스체크
- 지능형 라우팅 알고리즘
- 성능 기반 동적 선택
- 비용 최적화 고려
- 사용자 경험 우선순위"

# 지능형 클라우드 선택 시스템
name: Smart Cloud Selection
on:
  issue_comment:
    types: [created]

jobs:
  cloud-selection:
    runs-on: ubuntu-latest
    outputs:
      selected_cloud: ${{ steps.selector.outputs.cloud }}
      
    steps:
      - name: Cloud Status Check
        id: selector
        run: |
          # 각 클라우드 서비스 상태 확인
          ANTHROPIC_STATUS=$(curl -s https://status.anthropic.com/api/v2/status.json | jq -r '.status.indicator')
          AWS_STATUS=$(curl -s https://status.aws.amazon.com/rss/bedrock-us-west-2.rss | grep -c "operational" || echo 0)
          GCP_STATUS=$(curl -s https://status.cloud.google.com/incidents.json | jq -r '.incidents | length')
          
          # 지역별 지연 시간 측정
          ANTHROPIC_LATENCY=$(curl -w "%{time_total}" -s -o /dev/null https://api.anthropic.com/v1/models || echo 999)
          
          # 비용 고려사항 (시간대별 요금 차이)
          HOUR=$(date +%H)
          if [[ $HOUR -ge 9 && $HOUR -le 17 ]]; then
            COST_FACTOR="peak"
          else
            COST_FACTOR="off-peak"
          fi
          
          # 지능형 선택 로직
          if [[ "$ANTHROPIC_STATUS" == "none" && $ANTHROPIC_LATENCY -lt 2 ]]; then
            echo "cloud=anthropic" >> $GITHUB_OUTPUT
          elif [[ $AWS_STATUS -gt 0 ]]; then
            echo "cloud=bedrock" >> $GITHUB_OUTPUT
          elif [[ $GCP_STATUS -eq 0 ]]; then
            echo "cloud=vertex" >> $GITHUB_OUTPUT
          else
            echo "cloud=anthropic" >> $GITHUB_OUTPUT  # fallback
          fi

  claude-anthropic:
    needs: cloud-selection
    if: needs.cloud-selection.outputs.selected_cloud == 'anthropic'
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@beta
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

  claude-bedrock:
    needs: cloud-selection
    if: needs.cloud-selection.outputs.selected_cloud == 'bedrock'
    runs-on: ubuntu-latest
    steps:
      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}
          aws-region: us-west-2
          
      - uses: anthropics/claude-code-action@beta
        with:
          model: "anthropic.claude-3-7-sonnet-20250219-beta:0"
          use_bedrock: "true"

  claude-vertex:
    needs: cloud-selection
    if: needs.cloud-selection.outputs.selected_cloud == 'vertex'
    runs-on: ubuntu-latest
    steps:
      - name: Authenticate to Google Cloud
        uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: ${{ secrets.GCP_WORKLOAD_IDENTITY_PROVIDER }}
          service_account: ${{ secrets.GCP_SERVICE_ACCOUNT }}
          
      - uses: anthropics/claude-code-action@beta
        with:
          model: "claude-3-7-sonnet@20250219"
          use_vertex: "true"

# Sequential Thinking MCP 서버 통합
- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    mcp_config: |
      {
        "mcpServers": {
          "sequential-thinking": {
            "command": "npx",
            "args": [
              "-y",
              "@modelcontextprotocol/server-sequential-thinking"
            ]
          }
        }
      }
    allowed_tools: "mcp__sequential-thinking__sequentialthinking"

# 조직 특화 MCP 서버 설계
claude "우리 조직을 위한 커스텀 MCP 서버들을 설계해줘.
다음 시스템과의 통합이 필요해

내부 시스템 연동
- JIRA API: 이슈 트래킹과 프로젝트 관리
- Confluence: 문서와 지식 베이스 접근
- Slack API: 팀 커뮤니케이션과 알림
- Jenkins: CI/CD 파이프라인 상태
- DataDog: 모니터링과 성능 메트릭

외부 서비스 통합
- AWS API: 인프라 상태와 리소스 관리
- Kubernetes API: 컨테이너 오케스트레이션
- Database connections: 스키마 정보와 쿼리 실행
- Security scanners: 취약점 검사 결과

각 MCP 서버의 구현 방법과 보안 설정을 포함해줘."

# 종합적인 MCP 서버 설정
- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    mcp_config: |
      {
        "mcpServers": {
          "jira-integration": {
            "command": "node",
            "args": ["./scripts/mcp-jira-server.js"],
            "env": {
              "JIRA_URL": "${{ secrets.JIRA_URL }}",
              "JIRA_TOKEN": "${{ secrets.JIRA_TOKEN }}",
              "JIRA_PROJECT_KEY": "${{ vars.JIRA_PROJECT_KEY }}"
            }
          },
          "database-inspector": {
            "command": "python",
            "args": ["./scripts/mcp-db-server.py"],
            "env": {
              "DB_CONNECTION_STRING": "${{ secrets.DB_READ_ONLY_CONNECTION }}",
              "DB_TYPE": "postgresql"
            }
          },
          "security-scanner": {
            "command": "npx",
            "args": ["-y", "@company/security-mcp-server"],
            "env": {
              "SCANNER_API_KEY": "${{ secrets.SECURITY_SCANNER_API_KEY }}",
              "SCAN_LEVEL": "comprehensive"
            }
          },
          "monitoring-integration": {
            "command": "node",
            "args": ["./scripts/mcp-monitoring-server.js"],
            "env": {
              "DATADOG_API_KEY": "${{ secrets.DATADOG_API_KEY }}",
              "GRAFANA_URL": "${{ secrets.GRAFANA_URL }}",
              "GRAFANA_TOKEN": "${{ secrets.GRAFANA_TOKEN }}"
            }
          }
        }
      }
    allowed_tools: |
      mcp__jira-integration__create-issue,
      mcp__jira-integration__update-issue,
      mcp__jira-integration__search-issues,
      mcp__database-inspector__query-schema,
      mcp__database-inspector__explain-query,
      mcp__security-scanner__scan-code,
      mcp__security-scanner__check-vulnerabilities,
      mcp__monitoring-integration__get-metrics,
      mcp__monitoring-integration__create-alert

# 조직 특화 코드 품질 도구
claude "우리 팀의 코딩 표준을 자동으로 검사하는 커스텀 도구를 만들어줘.
다음 검사 항목을 포함해줘

코딩 표준 검사
- 함수 네이밍 규칙 (camelCase, 동사로 시작)
- 파일 구조 규칙 (feature/component 기반)
- 코멘트 작성 규칙 (JSDoc, docstring)
- 에러 처리 패턴 일관성
- 로깅 형식 표준화

성능 검사
- 메모리 누수 패턴 감지
- 비효율적인 루프와 쿼리
- 불필요한 렌더링 감지
- 번들 크기 최적화 기회

보안 검사
- 하드코딩된 시크릿 탐지
- SQL 인젝션 취약점
- XSS 공격 벡터
- 권한 부여 누락"

# 커스텀 문서화 자동화
- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    custom_instructions: |
      당신은 우리 조직의 문서화 전문가입니다.
      다음 문서화 표준을 준수해주세요
      
      API 문서화
      - OpenAPI 3.0 스펙 준수
      - 요청/응답 예시 포함
      - 에러 코드와 메시지 설명
      - 버전 관리 정보
      
      코드 문서화
      - 함수별 JSDoc/docstring
      - 복잡한 로직 인라인 주석
      - README 업데이트
      - 아키텍처 다이어그램
      
      사용자 문서화
      - 설치와 설정 가이드
      - 사용 예시와 튜토리얼
      - 문제 해결 가이드
      - FAQ 섹션
    allowed_tools: |
      Edit,Replace,GitLog,GitDiff,
      mcp__docs-generator__create-api-docs,
      mcp__docs-generator__update-readme,
      mcp__docs-generator__generate-diagrams

# 컨텍스트 기반 워크플로우 자동화
claude "PR 내용을 분석해서 자동으로 적절한 워크플로우를 선택하는 시스템을 만들어줘.
다음 분류 기준을 사용해줘

변경 유형 분석
- 기능 추가 (feature): 새로운 기능 구현
- 버그 수정 (bugfix): 기존 기능 오류 수정
- 리팩토링 (refactor): 코드 구조 개선
- 문서화 (docs): 문서 업데이트
- 설정 (config): 설정 파일 변경
- 테스트 (test): 테스트 코드 관련

영향도 분석
- Critical: 핵심 비즈니스 로직 변경
- High: 사용자 경험에 직접 영향
- Medium: 내부 로직 개선
- Low: 문서나 주석 업데이트

각 분류에 따른 자동화 워크플로우
- 필요한 리뷰어 자동 할당
- 적절한 테스트 전략 선택
- 배포 승인 프로세스 결정
- 모니터링 수준 설정"

# 지능형 품질 게이트 시스템
name: Adaptive Quality Gates
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  analyze-changes:
    runs-on: ubuntu-latest
    outputs:
      risk_level: ${{ steps.analysis.outputs.risk_level }}
      test_strategy: ${{ steps.analysis.outputs.test_strategy }}
      review_requirements: ${{ steps.analysis.outputs.review_requirements }}
      
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
          
      - uses: anthropics/claude-code-action@beta
        id: analysis
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          direct_prompt: |
            이 PR의 변경사항을 분석하고 다음을 결정해주세요
            
            1. 위험도 평가 (low/medium/high/critical)
            2. 필요한 테스트 전략 (unit/integration/e2e/performance)
            3. 리뷰 요구사항 (standard/senior/architect/security)
            
            분석 기준
            - 변경된 파일의 수와 중요도
            - 비즈니스 로직 변경 여부
            - 보안 관련 코드 수정
            - 데이터베이스 스키마 변경
            - API 인터페이스 변경
            - 성능에 영향을 줄 수 있는 변경
            
            결과를 다음 형식으로 GitHub Actions output에 설정해주세요
            echo "risk_level=medium" >> $GITHUB_OUTPUT
            echo "test_strategy=integration,e2e" >> $GITHUB_OUTPUT  
            echo "review_requirements=senior,security" >> $GITHUB_OUTPUT

  quality-gate-low:
    needs: analyze-changes
    if: needs.analyze-changes.outputs.risk_level == 'low'
    runs-on: ubuntu-latest
    steps:
      - name: Fast Track Review
        run: echo "Low risk changes - fast track approved"

  quality-gate-high:
    needs: analyze-changes
    if: contains(fromJson('["high", "critical"]'), needs.analyze-changes.outputs.risk_level)
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@beta
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          direct_prompt: |
            이는 높은 위험도의 변경사항입니다.
            다음 강화된 검토를 수행해주세요
            
            1. 세부적인 코드 리뷰
            2. 보안 취약점 전체 검사
            3. 성능 영향 분석
            4. 롤백 계획 수립
            5. 모니터링 계획 제안
            
            추가로 다음 팀들을 리뷰에 포함시켜주세요
            @security-team @architecture-team @senior-engineers

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
flowchart TD
    A[코드 작성 완료] --> B[AI 사전 리뷰]
    B --> C{품질 기준 충족}
    C -->|기준 미달| D[자동 개선 제안]
    C -->|기준 충족| E[PR 생성]
    D --> F[개발자 수정]
    F --> B
    
    E --> G[맥락 인식 AI 리뷰]
    G --> H[역할별 전문 리뷰]
    
    subgraph specialists [전문가 리뷰 체계]
        I[보안 전문가<br/>Security Champion]
        J[성능 전문가<br/>Performance Specialist]
        K[아키텍처 전문가<br/>Architecture Guardian]
        L[UX 전문가<br/>User Experience Advocate]
    end
    
    H --> I
    H --> J
    H --> K
    H --> L
    
    subgraph analysis [전문 분석 영역]
        I --> M[보안 위협 모델링<br/>취약점 패턴 분석<br/>컴플라이언스 검증]
        J --> N[성능 병목 분석<br/>알고리즘 최적화<br/>리소스 효율성]
        K --> O[설계 원칙 준수<br/>의존성 관리<br/>확장성 평가]
        L --> P[사용성 평가<br/>접근성 검증<br/>인터렉션 품질]
    end
    
    M --> Q[종합 리뷰 리포트]
    N --> Q
    O --> Q
    P --> Q
    
    Q --> R{리뷰 결과}
    R -->|승인| S[병합 승인]
    R -->|수정 요청| T[개발자 피드백]
    T --> F
    S --> U[자동 배포]
    
    subgraph feedback [피드백 루프]
        U --> V[운영 메트릭 수집]
        V --> W[리뷰 효과성 분석]
        W --> X[리뷰 프로세스 개선]
        X --> B
    end
    
    classDef processStyle fill:#e2e8f0,stroke:#334155,stroke-width:2px,color:#1e293b
    classDef specialistStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    classDef analysisStyle fill:#ecfdf5,stroke:#059669,stroke-width:2px,color:#064e3b
    classDef decisionStyle fill:#fef3c7,stroke:#d97706,stroke-width:2px,color:#92400e
    classDef feedbackStyle fill:#ddd6fe,stroke:#7c3aed,stroke-width:2px,color:#5b21b6
    
    class A,B,E,G,H,Q processStyle
    class I,J,K,L specialistStyle
    class M,N,O,P analysisStyle
    class C,R decisionStyle
    class V,W,X feedbackStyle

# 종합적 사전 품질 검증
claude "이 코드 변경사항을 다음 관점에서 종합 분석해줘

🔍 정적 분석 관점
- 코딩 표준과 컨벤션 준수
- 복잡도와 가독성 평가
- 잠재적 버그와 취약점
- 성능 병목 가능성
- 메모리 누수와 리소스 관리

🏗️ 아키텍처 관점
- 기존 설계 원칙과의 일관성
- 의존성과 결합도 분석
- 확장성과 유지보수성
- 테스트 가능성과 모킹 용이성
- API 설계와 인터페이스 품질

🧠 비즈니스 로직 관점
- 요구사항 충족도 검증
- 엣지 케이스와 예외 상황 처리
- 데이터 흐름과 상태 관리
- 보안과 권한 처리
- 사용자 경험 영향도

📊 품질 메트릭 관점
- 테스트 커버리지와 테스트 품질
- 문서화 완성도
- 로깅과 모니터링 준비도
- 국제화와 접근성 고려
- 성능 벤치마크 영향

각 관점별로 1-10점 평가와 구체적인 개선 방안을 제시해줘"

# 맥락 기반 지능형 리뷰
claude "이 PR을 리뷰하되, 다음 맥락을 고려해서 분석해줘

📈 프로젝트 맥락
- 최근 3개월간 버그 패턴 분석
- 성능 이슈 히스토리
- 보안 인시던트 경험
- 팀의 기술 부채 현황
- 다가오는 마일스톤과 압박

👥 팀 맥락
- 작성자의 기술 수준과 경험
- 코드 리뷰어의 전문 분야
- 팀 내 코딩 스타일 진화
- 과거 리뷰 피드백 패턴
- 학습 목표와 성장 방향

🎯 비즈니스 맥락
- 기능의 비즈니스 중요도
- 고객 영향도와 위험성
- 운영 복잡도 증가 여부
- 기술적 의존성 변화
- 향후 확장 계획

이 맥락을 바탕으로 우선순위를 정해서 리뷰 코멘트를 작성해줘.
단순한 문제 지적보다는 교육적이고 건설적인 피드백을 중심으로 해줘"

%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#f8fafc", "primaryTextColor": "#1e293b", "primaryBorderColor": "#e2e8f0", "lineColor": "#94a3b8", "secondaryColor": "#f1f5f9", "tertiaryColor": "#e2e8f0"}}}%%
graph LR
    subgraph security [보안 전문 리뷰]
        A[보안 위협 모델링]
        B[OWASP Top 10 체크]
        C[인증 및 권한 부여]
        D[데이터 보호 및 암호화]
    end
    
    subgraph performance [성능 전문 리뷰]
        E[알고리즘 복잡도 분석]
        F[데이터베이스 쿼리 최적화]
        G[네트워크 I/O 효율성]
        H[프론트엔드 렌더링 성능]
    end
    
    subgraph architecture [아키텍처 전문 리뷰]
        I[설계 원칙 준수]
        J[의존성 및 결합도]
        K[확장성 및 유지보수성]
        L[테스트 가능성]
    end
    
    subgraph ux [사용자 경험 리뷰]
        M[사용성 평가]
        N[접근성 검증]
        O[인터렉션 품질]
        P[성능 인식 영향]
    end
    
    subgraph outcomes [리뷰 결과]
        Q[심각도 평가<br/>Critical/High/Medium/Low]
        R[개선 방안 제시]
        S[우선순위 및 로드맵]
        T[학습 리소스 추천]
    end
    
    A --> Q
    B --> R
    C --> S
    D --> T
    
    E --> Q
    F --> R
    G --> S
    H --> T
    
    I --> Q
    J --> R
    K --> S
    L --> T
    
    M --> Q
    N --> R
    O --> S
    P --> T
    
    classDef securityStyle fill:#fee2e2,stroke:#dc2626,stroke-width:2px,color:#7f1d1d
    classDef performanceStyle fill:#fef3c7,stroke:#d97706,stroke-width:2px,color:#92400e
    classDef architectureStyle fill:#ecfdf5,stroke:#059669,stroke-width:2px,color:#064e3b
    classDef uxStyle fill:#ddd6fe,stroke:#7c3aed,stroke-width:2px,color:#5b21b6
    classDef outcomeStyle fill:#f1f5f9,stroke:#475569,stroke-width:2px,color:#1e293b
    
    class A,B,C,D securityStyle
    class E,F,G,H performanceStyle
    class I,J,K,L architectureStyle
    class M,N,O,P uxStyle
    class Q,R,S,T outcomeStyle

# 보안 중심 심층 분석
claude "보안 전문가 관점에서 이 코드를 리뷰해줘

🛡️ 보안 위협 모델링
- OWASP Top 10 체크리스트
- 입력 검증과 출력 인코딩
- 인증과 권한 부여 로직
- 세션 관리와 토큰 처리
- 암호화와 키 관리

🔐 프라이버시 보호
- 개인정보 처리 방식
- 데이터 마스킹과 익명화
- 로깅 시 민감정보 노출
- GDPR/CCPA 컴플라이언스
- 데이터 보존과 삭제 정책

⚠️ 취약점 패턴 분석
- SQL Injection 가능성
- XSS 공격 벡터
- CSRF 보호 메커니즘
- 파일 업로드 보안
- API 보안 고려사항

각 위험요소별로 심각도(Critical/High/Medium/Low)를 평가하고
구체적인 완화 방법을 제시해줘"

# 성능 중심 전문 리뷰
claude "성능 전문가 관점에서 이 코드를 분석해줘

⚡ 계산 복잡도 분석
- 알고리즘 시간/공간 복잡도
- 중첩 루프와 재귀 최적화
- 데이터 구조 선택의 적절성
- 캐싱 기회와 메모이제이션
- 병렬 처리 가능성

🗄️ 데이터 액세스 패턴
- N+1 쿼리 문제
- 인덱스 활용도
- 배치 처리 최적화
- 커넥션 풀 효율성
- 트랜잭션 경계 설정

🌐 네트워크와 I/O
- API 호출 최적화
- 페이로드 크기 최소화
- 압축과 캐싱 전략
- 비동기 처리 기회
- 타임아웃과 재시도 로직

📱 프론트엔드 성능
- 번들 크기 영향
- 렌더링 성능
- 메모리 사용량
- 이벤트 리스너 최적화
- 이미지와 리소스 로딩

성능 영향도를 정량적으로 예측하고 벤치마크 방법을 제안해줘"

# 사용자 경험 중심 코드 리뷰
claude "UX 관점에서 이 코드 변경이 사용자 경험에 미치는 영향을 분석해줘

🎨 인터페이스 일관성
- 디자인 시스템 준수
- 상호작용 패턴 일관성
- 접근성(a11y) 표준 준수
- 다크모드와 테마 지원
- 반응형 디자인 고려

⚡ 성능과 반응성
- 로딩 상태와 피드백
- 인터랙션 지연 시간
- 애니메이션 성능
- 오프라인 경험
- 점진적 향상(Progressive Enhancement)

🌍 글로벌 사용자 고려
- 국제화(i18n) 준비도
- 다양한 디바이스 지원
- 네트워크 환경 대응
- 문화적 적응성
- 시간대와 지역화

🧠 인지 부하
- 정보 구조와 네비게이션
- 에러 메시지 명확성
- 도움말과 가이드
- 학습 곡선 최소화
- 인지적 마찰 요소

사용자 여정의 각 단계에서 발생할 수 있는 문제점과 개선 방안을 제시해줘"

# 리뷰 프로세스 효과성 분석
claude "우리 팀의 코드 리뷰 프로세스를 분석하고 개선 방안을 제시해줘

📊 정량적 지표 분석
- 리뷰 완료 시간 (목표: 24시간 이내)
- 리뷰 라운드 수 (목표: 평균 2라운드 이하)
- 발견된 결함 수와 심각도
- 프로덕션 버그 예방률
- 리뷰어 참여도와 품질

🎯 품질 지표 추적
- 리뷰 코멘트의 건설성
- 학습 효과와 지식 전수
- 팀 표준 개선 기여도
- 베스트 프랙티스 발굴
- 기술 부채 예방 효과

🚀 프로세스 최적화
- 리뷰 병목 지점 식별
- 자동화 기회 발굴
- 리뷰어 워크로드 밸런싱
- 전문 영역별 라우팅
- 교육과 멘토링 통합

월별 트렌드와 개선 로드맵을 포함한 리포트를 생성해줘"

# 🔄 Dynamic Code Review Standards v3.0

## 📈 적응형 품질 기준

### 프로젝트 단계별 리뷰 강도
```bash
# 현재 프로젝트 단계 평가
if [ 프로젝트_단계 == "MVP" ]; then
    리뷰_기준="기능 동작 + 보안 기본"
    승인_임계값=70
elif [ 프로젝트_단계 == "성장" ]; then
    리뷰_기준="확장성 + 성능 + 테스트"
    승인_임계값=85
elif [ 프로젝트_단계 == "성숙" ]; then
    리뷰_기준="모든 품질 기준 + 혁신성"
    승인_임계값=95
fi

# 학습 효과 측정
claude "이번 달 코드 리뷰를 통한 팀 학습 효과를 분석해줘
- 주니어 개발자들이 가장 많이 배운 개념
- 반복되는 실수 패턴과 교육 필요 영역
- 시니어가 전수한 지식의 정착도
- 팀 전체 기술 수준 향상 지표
- 다음 달 집중 교육 주제 추천

개인별 성장 계획과 멘토링 매칭을 제안해줘"

# 리뷰 과정에서 나온 혁신 아이디어 추적
claude "최근 코드 리뷰에서 제기된 혁신적 아이디어들을 정리해줘
- 새로운 기술 도입 제안
- 프로세스 개선 아이디어
- 도구와 자동화 기회
- 아키텍처 진화 방향
- 팀 생산성 향상 방안

각 아이디어의 실현 가능성과 ROI를 평가하고
실행 계획을 수립해줘"

S1CO → S1ST → S1WF → S1TO → S1QC → S1CM
→ S2CO → S2ST → S2WF → S2TO → S2QC → S2CM
→ S3CO → S3ST → S3WF → S3TO → S3QC → S3CM
→ 부록