Vibe Coding 패턴

# 1. Start with Intent (의도로 시작)
"무엇을"을 먼저, "어떻게"는 나중에
예: "사용자 인증이 필요해" → 구현은 AI와 협의

# 2. Iterate Quickly (빠른 반복)
완벽한 첫 시도보다 빠른 프로토타입 → 개선
예: 70% 완성도로 먼저 보고 피드백

# 3. Context is King (컨텍스트가 왕)
프로젝트 상황, 기술 스택, 제약사항 명확히
예: "Next.js 14, TypeScript, Prisma 사용 중"

# 4. Test First, Fix Fast (테스트 우선, 빠른 수정)
테스트를 먼저 생성하고 실패 시 즉시 수정
예: "테스트 작성 → 실패 → 코드 수정"

# 5. Document as You Go (진행하며 문서화)
코드 작성 중 문서도 함께 생성
예: "이 API를 문서화해줘"

# Step 1: 기본 골격
"FastAPI로 사용자 관리 API의 기본 골격을 만들어주세요.
- User 모델 (Pydantic)
- CRUD 엔드포인트 (함수 시그니처만)
- 라우터 설정"

# Step 2: CREATE 구현
"이제 POST /users 엔드포인트를 완성해주세요.
- 입력 검증 (이메일, 비밀번호 강도)
- bcrypt로 비밀번호 해싱
- PostgreSQL 저장
- 성공 시 201 응답"

# Step 3: READ 구현
"GET /users와 GET /users/{id}를 구현해주세요.
- 페이지네이션 (limit, offset)
- 비밀번호는 응답에서 제외
- 존재하지 않는 ID는 404"

# Step 4: 인증 추가
"JWT 인증을 추가해주세요.
- 로그인 엔드포인트 (POST /auth/login)
- 토큰 검증 미들웨어
- 보호된 엔드포인트에 적용"

# Step 5: 테스트
"모든 엔드포인트에 대한 pytest 테스트를 작성해주세요."

# Red: 실패하는 테스트 작성
프롬프트: "이메일 유효성 검증 함수에 대한 pytest 테스트를 작성해주세요.

테스트 케이스:
- 유효한 이메일: user@example.com ✅
- 로컬 파트 없음: @example.com ❌
- 도메인 없음: user@ ❌
- 공백 포함: user @example.com ❌
- 다중 @ 기호: user@@example.com ❌"

# Green: 테스트를 통과하는 최소 코드
프롬프트: "위 테스트를 통과하는 validate_email 함수를 작성해주세요.
정규식 사용, 타입 힌트 포함."

# Refactor: 코드 개선
프롬프트: "이 함수를 다음과 같이 개선해주세요:
1. 더 정확한 RFC 5322 정규식 사용
2. 상세한 에러 메시지 (어떤 부분이 잘못되었는지)
3. docstring 추가
4. 성능 최적화 (정규식 컴파일)"

"다음 코드에서 메모리 누수가 발생합니다. 단계별로 분석하겠습니다.

# 1. 증상
- 프로그램 실행 시간이 길어질수록 메모리 사용량 증가
- 30분 후 500MB → 2GB
- 특정 작업 후 메모리가 해제되지 않음

# 2. 문제 코드
[코드 첨부]

# 3. 의심되는 부분
- 이벤트 리스너를 제거하지 않고 계속 추가
- 클로저가 외부 변수를 참조하여 GC 방지
- 캐시를 무한정 저장

# 4. 질문
1. 어떤 부분이 메모리 누수의 원인인가요?
2. 어떻게 수정해야 하나요?
3. 메모리 누수를 방지하는 패턴은?"

# 프로젝트 컨텍스트

## 1. 프로젝트 개요
- 이름: 전자상거래 플랫폼
- 목적: 중소 쇼핑몰을 위한 SaaS
- 사용자: 월 1만 명, 피크 시 동시 접속 500명

## 2. 기술 스택
- Backend: FastAPI 0.104, Python 3.11
- Database: PostgreSQL 15, Redis 7
- Frontend: Next.js 14, TypeScript 5.3
- Deploy: Docker, Kubernetes, AWS

## 3. 현재 구조
```
app/
  api/
    routes/
      users.py
      products.py
    dependencies/
      auth.py
  models/
  schemas/
  services/
```

## 4. 코딩 규칙
- 함수명: snake_case
- 클래스명: PascalCase
- 타입 힌트 필수
- Docstring: Google 스타일
- 최대 줄 길이: 100자

## 5. 현재 작업
장바구니 기능 추가 중
- [ ] Cart 모델 정의
- [ ] 장바구니 추가/삭제 API
- [ ] 재고 확인 로직
- [ ] 테스트 작성

## 요청
Cart 모델과 CRUD API를 작성해주세요.

# Step 1: 스펙 정의
"다음 요구사항에 맞는 OpenAPI 3.0 스펙을 작성해주세요:

## 엔드포인트
POST /api/orders - 주문 생성
GET /api/orders - 주문 목록
GET /api/orders/{id} - 주문 상세
PATCH /api/orders/{id} - 주문 상태 변경

## 데이터 모델
Order:
  - id: string (UUID)
  - user_id: string
  - items: OrderItem[]
  - total: number
  - status: 'pending' | 'paid' | 'shipped' | 'completed'
  - created_at: datetime"

# Step 2: 스펙에서 코드 생성
"위 OpenAPI 스펙을 기반으로 FastAPI 코드를 생성해주세요:
1. Pydantic 모델
2. 라우터 (함수 시그니처 + docstring)
3. 응답 예시"

# Step 3: 구현
"각 엔드포인트의 비즈니스 로직을 구현해주세요."

"다음과 같이 사용할 수 있는 데이터 검증 라이브러리를 만들어주세요.

# 사용 예제
const schema = {
  name: [required(), minLength(2), maxLength(50)],
  email: [required(), email()],
  age: [required(), number(), min(18), max(120)],
  password: [
    required(),
    minLength(8),
    pattern(/^(?=.*[A-Z])(?=.*[0-9])/, '대문자와 숫자 포함')
  ]
};

const validator = createValidator(schema);
const result = validator.validate(userData);

if (!result.valid) {
  console.log(result.errors);
  // { email: ['유효한 이메일 형식이 아닙니다'], age: ['18 이상이어야 합니다'] }
}

# 요구사항
1. TypeScript로 작성
2. 체이닝 가능한 밸리데이터
3. 커스텀 밸리데이터 지원
4. 상세한 에러 메시지
5. 비동기 검증 지원 (예: 이메일 중복 확인)"

## 1. 요구사항 정리
프롬프트: "다음 기능의 요구사항을 정리해주세요:
- 소셜 로그인 (Google, GitHub)
- 기존 이메일 로그인과 통합
- 프로필 자동 생성"

## 2. 설계 리뷰
프롬프트: "OAuth 2.0 흐름을 설명하고, 다음을 포함한 설계안을 제시해주세요:
- 데이터베이스 스키마 (User, SocialAccount 테이블)
- API 엔드포인트
- 보안 고려사항"

## 3. 모델 정의
프롬프트: "SQLAlchemy로 User와 SocialAccount 모델을 작성해주세요.
- User: 기존 모델 확장
- SocialAccount: provider, provider_id, access_token 등"

## 4. API 구현
프롬프트: "FastAPI로 OAuth 콜백 엔드포인트를 구현해주세요:
GET /auth/google/callback
- 인증 코드 → 액세스 토큰 교환
- 사용자 정보 조회
- 신규 사용자는 자동 생성, 기존 사용자는 연동"

## 5. 프론트엔드 연동
프롬프트: "Next.js에서 Google 로그인 버튼을 구현해주세요.
- next-auth 사용
- 세션 관리
- 로그인 상태에 따른 UI 변경"

## 6. 테스트
프롬프트: "OAuth 콜백 엔드포인트에 대한 테스트를 작성해주세요:
- 성공 케이스: 신규 사용자, 기존 사용자
- 실패 케이스: 잘못된 코드, 만료된 토큰
- httpx_mock 사용"

## 7. 문서화
프롬프트: "소셜 로그인 사용 가이드를 Markdown으로 작성해주세요:
- 사용자 가이드
- 개발자 가이드 (환경 변수 설정)
- 트러블슈팅"

## 1. 이해하기
프롬프트: "다음 레거시 코드의 동작을 설명해주세요:

[레거시 코드 500줄]

다음을 포함:
1. 전체 흐름
2. 각 함수의 역할
3. 의존성 관계
4. 숨겨진 가정(assumptions)"

## 2. 테스트 작성 (보호망)
프롬프트: "기존 동작을 보장하는 테스트를 작성해주세요:
- 모든 공개 함수에 대한 테스트
- 엣지 케이스 포함
- 100% 브랜치 커버리지 목표"

## 3. 문제점 파악
프롬프트: "이 코드의 문제점을 분석해주세요:
- 코드 스멜 (긴 함수, 중복 코드 등)
- 성능 이슈
- 보안 취약점
- 유지보수성 문제"

## 4. 리팩토링 계획
프롬프트: "단계별 리팩토링 계획을 수립해주세요:
- 각 단계마다 테스트 통과 보장
- 리스크가 낮은 것부터 시작
- 각 단계의 예상 시간"

## 5. 점진적 리팩토링
프롬프트 1: "먼저 함수명을 의미 있게 변경해주세요. 테스트는 그대로 통과해야 합니다."
프롬프트 2: "긴 함수를 작은 함수로 분해해주세요."
프롬프트 3: "중복 코드를 제거하고 공통 함수로 추출해주세요."
프롬프트 4: "성능을 개선해주세요 (알고리즘 최적화)."

## 6. 검증
프롬프트: "리팩토링 전후를 비교해주세요:
- 코드 라인 수
- 순환 복잡도
- 테스트 커버리지
- 성능 (벤치마크)"

## 1. 재현 가능한 테스트 케이스
프롬프트: "이 버그를 재현하는 최소한의 테스트 케이스를 작성해주세요.

# 버그 설명
특정 입력에서만 간헐적으로 발생
에러 메시지: [에러 메시지]
스택 트레이스: [스택 트레이스]"

## 2. 원인 가설 수립
프롬프트: "가능한 원인을 우선순위별로 나열해주세요:
1. [가능성 높음]
2. [가능성 중간]
3. [가능성 낮음]

각 가설에 대한 검증 방법도 제시"

## 3. 로깅 추가
프롬프트: "디버깅을 위한 로깅을 추가해주세요:
- 함수 입출력
- 중요 변수 값
- 분기 조건
- 성능 측정 (타임스탬프)"

## 4. 이분 탐색 디버깅
프롬프트: "코드의 절반씩 주석 처리하며 문제 위치를 좁혀주세요.
1단계: 전체 → 버그 발생
2단계: 앞쪽 절반 주석 → 버그 발생/미발생?
3단계: ...
최종: 버그 발생 라인 특정"

## 5. 수정 및 검증
프롬프트: "버그를 수정하고 다음을 확인해주세요:
1. 재현 테스트 케이스 통과
2. 기존 테스트 모두 통과
3. 유사한 버그가 다른 곳에도 있는지 검색
4. 재발 방지 방법 (정적 분석, 추가 테스트)"

## 6. 사후 분석
프롬프트: "버그 리포트를 작성해주세요:
- 원인: 왜 발생했는가?
- 해결책: 어떻게 수정했는가?
- 예방책: 같은 실수를 어떻게 방지할 것인가?
- 배운 점"

## 1. 프로파일링
프롬프트: "이 코드를 프로파일링하는 스크립트를 작성해주세요:
- Python: cProfile + snakeviz
- 시간이 오래 걸리는 함수 Top 10
- 메모리 사용량 측정 (memory_profiler)"

## 2. 병목 지점 파악
프롬프트: "프로파일링 결과를 분석해주세요:

[프로파일링 출력]

다음을 식별:
1. 가장 많은 시간을 소비하는 함수
2. 불필요하게 반복 호출되는 함수
3. 비효율적인 알고리즘
4. I/O 대기 시간"

## 3. 최적화 전략 수립
프롬프트: "우선순위별 최적화 전략을 제시해주세요:

# High Impact, Low Effort (먼저 수행)
- 캐싱 추가
- 불필요한 DB 쿼리 제거

# High Impact, High Effort (다음 수행)
- 알고리즘 개선 (O(n²) → O(n log n))
- 병렬 처리

# Low Impact (나중에 또는 스킵)
- 미세한 코드 최적화"

## 4. 최적화 구현
프롬프트: "다음 최적화를 적용해주세요:
1. 반복되는 DB 쿼리를 캐싱 (Redis, TTL 5분)
2. N+1 쿼리 문제 해결 (select_related)
3. 리스트 컴프리헨션을 제너레이터로 변경
4. 정규식 컴파일 (루프 밖으로 이동)"

## 5. 벤치마크
프롬프트: "최적화 전후를 비교하는 벤치마크를 작성해주세요:
- 100, 1000, 10000개 데이터로 테스트
- 실행 시간, 메모리 사용량 측정
- 결과를 표로 출력"

## 6. 트레이드오프 문서화
프롬프트: "최적화의 트레이드오프를 문서화해주세요:
- 얻은 것: 성능 향상 (50% 속도 증가)
- 잃은 것: 코드 복잡도 증가, 메모리 10% 증가
- 언제 사용: 대용량 데이터 처리 시
- 언제 피해야: 소규모 데이터, 메모리 제약 환경"

## 1. 프로젝트 구조 생성
프롬프트: "Next.js 14 + TypeScript + Tailwind 프로젝트 구조를 제안해주세요.

요구사항:
- App Router 사용
- src/ 디렉토리 구조
- 컴포넌트, 훅, 유틸리티 분리
- 환경 변수 관리
- ESLint + Prettier 설정

다음 형식으로:
```
project/
  src/
    app/
    components/
    ...
```"

## 2. 기본 설정 파일
프롬프트: "다음 설정 파일을 생성해주세요:
1. tsconfig.json (strict 모드)
2. .eslintrc.json (Airbnb 스타일)
3. .prettierrc (일관된 포맷팅)
4. .env.example (필요한 환경 변수 목록)"

## 3. 공통 컴포넌트
프롬프트: "재사용 가능한 기본 컴포넌트를 생성해주세요:
- Button (variant: primary, secondary, danger)
- Input (type, validation)
- Modal (header, body, footer)
- Loading Spinner
- Toast Notification

각 컴포넌트는:
- TypeScript 타입 정의
- Tailwind CSS 스타일링
- Storybook 스토리 포함"

## 4. 유틸리티 함수
프롬프트: "자주 사용하는 유틸리티 함수를 작성해주세요:
- 날짜 포맷팅 (formatDate, relativeTime)
- 문자열 처리 (truncate, slugify)
- 숫자 포맷팅 (formatCurrency, formatNumber)
- 검증 (isEmail, isURL)

각 함수에 테스트 포함"

## 5. API 클라이언트
프롬프트: "타입 안전한 API 클라이언트를 작성해주세요:
- Axios 래퍼
- 인터셉터 (인증 토큰, 에러 처리)
- 자동 재시도
- 타입 추론"

프롬프트: "전자상거래 플랫폼의 백엔드 아키텍처를 설계해주세요.

# 요구사항
- 예상 사용자: 10만 명
- 동시 접속: 피크 5000명
- 주요 기능: 상품 관리, 주문, 결제, 리뷰
- 확장 가능해야 함

# 다음을 포함
1. 시스템 아키텍처 다이어그램 (Mermaid)
2. 기술 스택 추천 (DB, 캐시, 메시지 큐 등)
3. 마이크로서비스 vs 모놀리스 선택 근거
4. 확장 전략 (수평 확장, 샤딩 등)
5. 보안 고려사항
6. 모니터링 & 로깅 전략

# 출력 형식
## 1. Overview
[전체 아키텍처 설명]

## 2. Architecture Diagram
```mermaid
[다이어그램]
```

## 3. Technology Stack
| Component | Technology | Reason |
|-----------|------------|--------|
| ... | ... | ... |

## 4. Scaling Strategy
[확장 전략]

## 5. Security
[보안 조치]"

"다음 Pull Request를 리뷰해주세요.

# PR 정보
- 제목: 사용자 인증 API 추가
- 변경 파일: 5개 (models.py, routes.py, schemas.py, auth.py, tests.py)
- 추가: +350줄, 삭제: -20줄

# 리뷰 기준
1. 기능 정확성
   - 요구사항 충족 여부
   - 엣지 케이스 처리
   - 에러 처리

2. 코드 품질
   - 가독성 (네이밍, 구조)
   - DRY 원칙 준수
   - SOLID 원칙 준수

3. 보안
   - SQL Injection 방지
   - XSS 방지
   - 비밀번호 해싱
   - 민감 정보 노출

4. 성능
   - 불필요한 쿼리
   - N+1 문제
   - 비효율적 알고리즘

5. 테스트
   - 테스트 커버리지
   - 테스트 품질
   - 누락된 테스트 케이스

6. 문서화
   - Docstring
   - 주석 (필요한 곳에만)
   - README 업데이트

# 출력 형식
## Summary
- 전반적 평가: [Approve / Request Changes / Comment]
- 주요 장점 3가지
- 주요 개선점 3가지

## Critical Issues (즉시 수정 필요)
- [파일명:라인] [문제]: [해결 방법]

## Suggestions (권장)
- [파일명:라인] [제안]: [이유]

## Nitpicks (선택적)
- [사소한 개선 사항]

## Positive Feedback
- [잘한 부분]

# 코드
[PR diff 첨부]"

"다음 코드를 보안 관점에서 리뷰해주세요.

# OWASP Top 10 체크
- [ ] A01: Broken Access Control
- [ ] A02: Cryptographic Failures
- [ ] A03: Injection
- [ ] A04: Insecure Design
- [ ] A05: Security Misconfiguration
- [ ] A06: Vulnerable Components
- [ ] A07: Authentication Failures
- [ ] A08: Data Integrity Failures
- [ ] A09: Logging Failures
- [ ] A10: SSRF

# 구체적 검증 항목
1. SQL Injection:
   - 파라미터화된 쿼리 사용?
   - ORM 사용?

2. XSS:
   - 사용자 입력 이스케이프?
   - Content-Type 헤더 설정?

3. 인증/인가:
   - 비밀번호 해싱 (bcrypt, scrypt)?
   - JWT 서명 검증?
   - 역할 기반 접근 제어?

4. 민감 정보:
   - 환경 변수로 관리?
   - 로그에 노출되지 않음?

5. HTTPS:
   - 쿠키에 Secure 플래그?
   - HSTS 헤더?

# 출력
각 항목에 대해:
- 상태: ✅ 안전 / ⚠️ 주의 / ❌ 취약
- 설명
- 수정 방법 (취약한 경우)

# 코드
[코드 첨부]"

"다음 API 코드를 분석하여 OpenAPI 3.0 문서를 생성해주세요.

# 코드
[FastAPI 라우터 코드]

# 요구사항
1. 모든 엔드포인트 문서화
2. Request/Response 스키마
3. 인증 방법 (Bearer Token)
4. 에러 응답 형식
5. 예제 포함 (curl, JavaScript, Python)
6. Rate limiting 정보

# 추가로 생성
1. Markdown 사용자 가이드
2. Postman Collection
3. 통합 테스트 예제"

"이 프로젝트의 README.md를 작성해주세요.

# 프로젝트 정보
- 이름: E-Commerce Platform
- 목적: 중소 쇼핑몰 SaaS
- 기술 스택: Next.js, FastAPI, PostgreSQL
- 현재 상태: Beta

# 포함할 섹션
1. 프로젝트 소개 (배지 포함)
2. 주요 기능
3. 스크린샷 또는 데모
4. 시작하기
   - 사전 요구사항
   - 설치 방법
   - 환경 변수 설정
   - 실행 방법
5. 사용 예제
6. API 문서 링크
7. 프로젝트 구조
8. 개발 가이드
   - 로컬 개발 환경 설정
   - 테스트 실행
   - 빌드 & 배포
9. 기여 가이드
10. 라이선스
11. 문의처

# 스타일
- 간결하고 명확하게
- 코드 블록 문법 강조
- 이모지 적절히 사용
- 뱃지 (build, coverage, license 등)"

"다음 함수에 Google 스타일 docstring을 추가해주세요.

# 함수
def process_payment(user_id, amount, payment_method):
    # 결제 처리 로직
    pass

# 요구사항
1. Google 스타일 docstring
2. Args: 각 파라미터 설명, 타입
3. Returns: 반환값 설명, 타입
4. Raises: 발생 가능한 예외
5. Examples: 사용 예제
6. Notes: 주의사항 (있다면)

# 예상 출력
def process_payment(user_id: int, amount: Decimal, payment_method: str) -> PaymentResult:
    """결제를 처리합니다.

    사용자의 결제 수단으로 지정된 금액을 청구합니다.
    결제 실패 시 자동으로 3회 재시도하며, 모두 실패하면 예외를 발생시킵니다.

    Args:
        user_id (int): 사용자 ID
        amount (Decimal): 결제 금액 (소수점 2자리까지)
        payment_method (str): 결제 수단 ('card', 'bank', 'paypal')

    Returns:
        PaymentResult: 결제 결과 객체
            - transaction_id (str): 거래 ID
            - status (str): 결제 상태
            - timestamp (datetime): 처리 시각

    Raises:
        InvalidPaymentMethodError: 지원하지 않는 결제 수단
        InsufficientFundsError: 잔액 부족
        PaymentTimeoutError: 결제 타임아웃 (30초 초과)

    Examples:
        >>> result = process_payment(123, Decimal('99.99'), 'card')
        >>> print(result.status)
        'completed'

    Notes:
        - 결제 금액은 0.01 이상이어야 합니다
        - 일일 결제 한도는 사용자 등급에 따라 다릅니다
    """
    pass"

"다음 함수에 대한 포괄적인 유닛 테스트를 작성해주세요.

# 테스트 대상
[함수 코드]

# 테스트 요구사항
1. Happy Path: 정상 동작 (최소 3개 케이스)
2. Edge Cases:
   - 경계값 (0, 음수, 최대값)
   - 빈 입력 (빈 문자열, 빈 리스트)
   - None 입력
   - 특수 문자
3. Error Cases:
   - TypeError (잘못된 타입)
   - ValueError (유효하지 않은 값)
   - 커스텀 예외
4. Performance:
   - 대용량 입력 (1만 개 데이터)
   - 타임아웃 체크

# 테스트 구조
- pytest 사용
- AAA 패턴 (Arrange-Act-Assert)
- 테스트 함수명: test_[기능]_[시나리오]_[예상결과]
- Fixture로 공통 설정 분리
- parametrize로 여러 케이스 한 번에

# 커버리지 목표
- Line coverage: 100%
- Branch coverage: 95%+

# 예시 출력
import pytest

@pytest.fixture
def sample_data():
    """테스트 데이터 생성"""
    return {...}

def test_function_name_with_valid_input_returns_expected(sample_data):
    # Arrange
    expected = ...

    # Act
    result = function_name(sample_data)

    # Assert
    assert result == expected"

"사용자 회원가입부터 주문까지 E2E 테스트를 작성해주세요.

# 시나리오
1. 회원가입 (POST /auth/register)
2. 이메일 인증 (GET /auth/verify?token=...)
3. 로그인 (POST /auth/login) → JWT 토큰 획득
4. 상품 목록 조회 (GET /products)
5. 장바구니 추가 (POST /cart)
6. 주문 생성 (POST /orders)
7. 결제 (POST /payments)
8. 주문 확인 (GET /orders/{id})

# 요구사항
- pytest + httpx (비동기)
- 테스트 DB 사용 (격리)
- 테스트 후 롤백
- 각 단계별 응답 검증
- 최종 DB 상태 검증

# 모킹
- 외부 API: 결제 게이트웨이 모킹
- 이메일 발송: SMTP 모킹
- S3 업로드: 모킹

# 실패 시나리오도 테스트
- 중복 회원가입
- 잘못된 토큰
- 재고 부족
- 결제 실패"

# ❌ 너무 모호함
"좋은 코드 작성해줘"

# ❌ 컨텍스트 부족
"API 만들어줘"

# ❌ 제약사항 없음
"빠른 정렬 알고리즘 작성해줘"
→ 어떤 언어? 어떤 데이터 타입? in-place? stable?

# ❌ 측정 불가능한 목표
"성능을 개선해줘"
→ 어떤 메트릭? 목표값은?

# ❌ 매번 새로운 대화 시작
대화 1: "Python으로 함수 작성"
대화 2: "테스트 작성" (어떤 함수?)
대화 3: "문서화" (무엇을?)

# ✅ 하나의 대화에서 진행
대화 1: "Python으로 이메일 검증 함수 작성"
대화 2: "방금 작성한 함수의 테스트를 작성해주세요"
대화 3: "이 함수를 문서화해주세요"

# ✅ 또는 명시적 참조
대화 2: "다음 함수의 테스트를 작성해주세요:\n[함수 코드]"