프롬프트 최적화

# 장황한 표현 (많은 토큰)
Application Programming Interface 설계
Structured Query Language 쿼리 작성
Hypertext Markup Language 문서 생성

# 간결한 표현 (적은 토큰)
API 설계
SQL 쿼리 작성
HTML 문서 생성

# 기호 활용
"A 그리고 B 그리고 C" → "A, B, C"
"1번부터 10번까지" → "1-10"
"보다 큰" → ">"
"이하" → "<="

아까 우리가 얘기했던 그 React 컴포넌트 있잖아요.
그게 지금 useState를 사용하고 있는데,
이전에 말씀하신 것처럼 useReducer로 바꾸려고 하는데,
근데 제가 생각해보니까 Context API도 필요할 것 같아서요.
그래서 이 세 가지를 어떻게 조합하면 좋을지 궁금합니다.

이전 React 컴포넌트를 다음과 같이 개선하려 합니다:
- useState → useReducer 전환
- Context API 추가

구현 방법을 제시해주세요.

사용자 피드백을 감성 분석하여 긍정/부정/중립으로 분류해주세요.

# 예제
입력: "제품이 정말 마음에 들어요. 배송도 빨랐습니다."
출력: 긍정 (이유: "마음에 들어요", "빨랐습니다" 등 긍정 표현)

입력: "가격 대비 품질이 별로입니다. 실망했어요."
출력: 부정 (이유: "별로", "실망" 등 부정 표현)

입력: "그냥 평범한 제품이에요."
출력: 중립 (이유: 특별한 감정 표현 없음)

# 분류할 피드백
"배송은 빨랐는데 포장이 좀 아쉬웠어요."

Python으로 이진 검색 트리를 구현해주세요.

# 제약사항 (MUST)
- 재귀 함수 사용 금지 (스택 오버플로 방지)
- 표준 라이브러리만 사용 (외부 패키지 X)
- 타입 힌트 필수
- 중복 값 허용 안 함

# 제약사항 (SHOULD)
- 평균 시간 복잡도 O(log n)
- 메모리 사용 최소화

# 제약사항 (MUST NOT)
- 전역 변수 사용 금지
- mutable default arguments 금지
- 예외를 무시하는 bare except 금지

이메일 유효성 검증 함수를 작성해주세요.

# 검증 통과 케이스
✅ user@example.com
✅ user.name@example.co.kr
✅ user+tag@example.com
✅ user123@subdomain.example.com

# 검증 실패 케이스
❌ @example.com (로컬 파트 없음)
❌ user@.com (도메인 시작이 점)
❌ user@example (TLD 없음)
❌ user name@example.com (공백 포함)
❌ user@exam ple.com (도메인 공백)

# 성능 검증
- 10만 개 이메일 검증 < 1초
- 정규식 ReDoS 공격에 안전할 것

# 일반 프롬프트
"React 성능 최적화 방법을 알려주세요."

# 페르소나 설정 프롬프트
"당신은 10년 경력의 시니어 React 개발자입니다.
대규모 트래픽 서비스(일 방문자 100만+)를 운영한 경험이 있습니다.

다음 React 애플리케이션의 성능 문제를 진단하고 해결책을 제시해주세요:
- 초기 로딩 시간: 5초 (목표: 2초 이하)
- FCP: 3초, LCP: 4.5초
- 번들 크기: 2.5MB

실전 경험에 기반한 우선순위별 최적화 전략을 제안해주세요."

다음 API 설계를 리뷰해주세요.

# 출력 형식
## 1. 장점 (Strengths)
- [구체적인 장점]

## 2. 개선 사항 (Improvements)
### 2.1 Critical (즉시 수정 필요)
- [문제점]: [개선 방법]
  - 영향도: [High/Medium/Low]
  - 예상 작업 시간: [시간]

### 2.2 Recommended (권장)
- [문제점]: [개선 방법]

### 2.3 Optional (선택)
- [문제점]: [개선 방법]

## 3. 코드 예시
[개선된 코드]

## 4. 참고 자료
- [관련 문서 링크]

# 1차 프롬프트
"Python으로 CSV 파일을 읽는 함수를 작성해주세요."

# 1차 응답 (가정)
def read_csv(file_path):
    with open(file_path) as f:
        return f.read()

# 2차 프롬프트 (구체적 피드백)
"좋은 시작입니다. 다음을 추가해주세요:
1. pandas 사용하여 DataFrame 반환
2. 인코딩 에러 처리 (utf-8, cp949 자동 감지)
3. 파일이 없을 때 명확한 에러 메시지
4. 타입 힌트 추가"

# 3차 프롬프트 (추가 개선)
"거의 완벽합니다. 마지막으로:
1. 대용량 파일 처리를 위한 청크 읽기 옵션 추가
2. 로깅 추가 (파일 크기, 행 수 출력)
3. docstring을 Google 스타일로 작성"

다음 제품 리뷰를 분석하여 JSON 형식으로 출력해주세요.

# 출력 스키마
{
  "sentiment": "positive|negative|neutral",
  "score": 0.0 to 1.0,
  "aspects": [
    {
      "category": "quality|price|delivery|service",
      "sentiment": "positive|negative|neutral",
      "keywords": ["keyword1", "keyword2"]
    }
  ],
  "summary": "한 줄 요약"
}

# 분석할 리뷰
"제품 품질은 좋은데 배송이 너무 느렸어요. 가격은 적당합니다."

{
  "sentiment": "neutral",
  "score": 0.6,
  "aspects": [
    {
      "category": "quality",
      "sentiment": "positive",
      "keywords": ["품질", "좋은"]
    },
    {
      "category": "delivery",
      "sentiment": "negative",
      "keywords": ["배송", "느렸어요"]
    },
    {
      "category": "price",
      "sentiment": "positive",
      "keywords": ["가격", "적당"]
    }
  ],
  "summary": "품질과 가격은 만족스러우나 배송이 지연됨"
}

이 API를 문서화해주세요. Markdown 형식으로 출력하되 다음 구조를 따르세요:

# 구조
# API 이름
간단한 설명

## Endpoint
`METHOD /path`

## Parameters
| Name | Type | Required | Description |
|------|------|----------|-------------|
| ... | ... | ... | ... |

## Request Example
```json
{ ... }
```

## Response
### Success (200)
```json
{ ... }
```

### Error (4xx/5xx)
```json
{ ... }
```

## Notes
- 주의사항
- 제한사항

다음 프레임워크들을 비교하여 테이블로 출력해주세요:
React, Vue, Angular, Svelte

# 비교 항목
- 학습 곡선
- 성능 (번들 크기, 렌더링 속도)
- 생태계 (라이브러리, 도구)
- 커뮤니티 규모
- 기업 지원
- 적합한 프로젝트 규모

# 출력 형식
Markdown 테이블, 각 항목에 간단한 평가 (상/중/하 또는 1-5점)

Python으로 LRU 캐시를 구현해주세요.

# 출력 형식
1. 코드 블록은 ```python으로 시작
2. 각 메서드 위에 docstring 추가 (Google 스타일)
3. 복잡한 로직에는 인라인 주석
4. 타입 힌트 포함
5. 사용 예제 별도 코드 블록으로 제공

다음 코드를 리뷰해주세요.

# 리뷰 기준
1. 가독성 (네이밍, 구조)
2. 성능 (시간/공간 복잡도)
3. 보안 (취약점)
4. 유지보수성 (SOLID 원칙)
5. 테스트 가능성

# 출력 형식
## 점수
- 가독성: [1-10점]
- 성능: [1-10점]
- 보안: [1-10점]
- 유지보수성: [1-10점]
- 테스트 가능성: [1-10점]
- **총점: [평균]**

## Critical Issues (즉시 수정)
- [문제]: [해결 방법]

## Suggestions (권장 개선)
- [문제]: [해결 방법]

## Best Practices
- [칭찬할 부분]

## Refactored Code
```python
[개선된 코드]
```

# 리뷰 대상 코드
[코드 삽입]

다음 버그를 디버깅해주세요.

# 증상
- 예상 동작: [기대하는 결과]
- 실제 동작: [실제 발생하는 결과]
- 재현율: [항상/간헐적]
- 에러 메시지: [에러 내용 또는 "없음"]

# 환경
- OS: [운영체제]
- 언어/프레임워크 버전: [버전]
- 의존성: [관련 라이브러리]

# 재현 단계
1. [단계]
2. [단계]
3. [단계]

# 문제 코드
[코드]

# 원하는 출력
1. **근본 원인 분석**
2. **수정된 코드**
3. **테스트 코드** (재발 방지)
4. **설명** (왜 버그가 발생했는지)

다음 코드를 최적화해주세요.

# 현재 성능
- 실행 시간: [측정값]
- 메모리 사용: [측정값]
- 처리량: [측정값]

# 목표 성능
- 실행 시간: [목표값]
- 메모리 사용: [목표값]
- 처리량: [목표값]

# 제약사항
- 정확도: [유지/근사 허용]
- 메모리 제한: [제한사항]
- 코드 복잡도: [유지보수성 우선/성능 우선]

# 최적화 대상 코드
[코드]

# 원하는 출력
1. **병목 분석** (프로파일링 결과)
2. **최적화 전략** (우선순위별)
3. **최적화된 코드**
4. **성능 비교** (Before/After)
5. **trade-offs** (성능 vs 가독성 등)

[테스트 프레임워크]로 다음 함수의 테스트를 작성해주세요.

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

# 테스트 범위
1. **Happy Path**: 정상 동작
2. **Edge Cases**: 경계값, 특수 케이스
3. **Error Cases**: 예외 상황
4. **Performance**: 대용량 데이터 처리

# 요구사항
- AAA 패턴 (Arrange-Act-Assert)
- 테스트 함수명: test_[기능]_[시나리오]_[예상결과]
- 모킹: [모킹 대상 명시]
- 커버리지: Line 95%+, Branch 90%+

# 출력 형식
```python
import pytest

# Fixtures
@pytest.fixture
def setup():
    pass

# Tests
def test_example():
    # Arrange

    # Act

    # Assert
    pass
```

다음 API를 문서화해주세요.

# API 코드
[코드]

# 문서 형식
Markdown, OpenAPI 3.0 스펙 참고

# 포함 내용
1. **Overview**: API 목적 및 간단한 설명
2. **Authentication**: 인증 방법
3. **Endpoints**: 모든 엔드포인트 상세
   - HTTP 메서드, 경로
   - 요청 파라미터 (경로/쿼리/바디)
   - 응답 형식 (성공/에러)
   - 예제 (curl, JavaScript, Python)
4. **Rate Limiting**: 제한사항
5. **Error Codes**: 에러 코드 설명
6. **Changelog**: 버전 변경 이력

# 출력 언어
한국어 (코드 예제 제외)

# 1단계: 가설 수립
"구체적인 예제를 포함하면 코드 품질이 향상될 것이다"

# 2단계: 변형 작성
Variant A (Control): "Python으로 정렬 함수를 작성해주세요"
Variant B (Treatment): "Python으로 정렬 함수를 작성해주세요. 예: [3,1,2] → [1,2,3]"

# 3단계: 평가 기준 정의
- 정확성: 요구사항 충족 여부 (0-10점)
- 코드 품질: 가독성, 효율성 (0-10점)
- 완성도: 에러 처리, 엣지 케이스 (0-10점)

# 4단계: 반복 테스트
각 변형을 3-5회 반복하여 평균 점수 계산

# 5단계: 결과 분석
통계적 유의성 확인 (t-test 등)

# 정확성 (Accuracy)
- [ ] 요구사항 100% 충족
- [ ] 엣지 케이스 처리
- [ ] 에러 케이스 처리

# 완성도 (Completeness)
- [ ] 모든 기능 구현
- [ ] 문서화 (docstring, 주석)
- [ ] 예제 코드 포함

# 품질 (Quality)
- [ ] 코드 스타일 준수
- [ ] 네이밍 일관성
- [ ] 적절한 추상화 수준

# 효율성 (Efficiency)
- [ ] 시간 복잡도 최적
- [ ] 공간 복잡도 최적
- [ ] 불필요한 연산 없음

# 점수 계산
각 항목 0-10점, 평균 계산

# 토큰 효율성
효율성 = 품질 점수 / (입력 토큰 + 출력 토큰)

# 시간 효율성
시간 효율성 = 품질 점수 / 응답 시간(초)

# 비용 효율성
비용 효율성 = 품질 점수 / 비용($)

# 반복 횟수
이상적 반복: 1-2회 (첫 응답이 만족스러울수록 좋음)

# 예시
프롬프트 A: 품질 7점, 500토큰, 5초 → 효율성 0.014
프롬프트 B: 품질 9점, 300토큰, 4초 → 효율성 0.030 (B가 2배 이상 효율적)

# Plan (계획)
1. 목표 정의: "코드 생성 품질을 8점 이상으로"
2. 가설 수립: "타입 힌트를 명시하면 품질 향상"
3. 테스트 설계: 5개 샘플로 A/B 테스트

# Do (실행)
1. 기존 프롬프트로 5회 생성 (Baseline)
2. 개선된 프롬프트로 5회 생성
3. 결과 수집 및 저장

# Check (확인)
1. 품질 점수 비교
2. 토큰/시간 측정
3. 통계적 유의성 검증

# Act (조치)
1. 개선이 확인되면 프롬프트 업데이트
2. 개선이 없으면 다른 가설 테스트
3. 결과 문서화 및 공유

# 프롬프트 개선 로그

## 버전 1.0 (Baseline)
- 프롬프트: "Python으로 함수를 작성해주세요"
- 품질: 6.2/10
- 토큰: 800
- 문제점: 에러 처리 누락, 타입 힌트 없음

## 버전 1.1
- 변경사항: 타입 힌트 요구 추가
- 품질: 7.5/10 (+1.3)
- 토큰: 850 (+50)
- 개선점: 타입 안전성 향상

## 버전 1.2
- 변경사항: Few-shot 예제 추가
- 품질: 8.8/10 (+1.3)
- 토큰: 900 (+50)
- 개선점: 코드 스타일 일관성

## 버전 2.0 (최종)
- 변경사항: 불필요한 설명 제거, 구조화
- 품질: 9.2/10 (+0.4)
- 토큰: 450 (-450, 50% 절약!)
- 결과: 품질 향상 + 토큰 절약 달성

import tiktoken

# Claude는 Claude 토크나이저 사용 (GPT 토크나이저와 유사)
encoding = tiktoken.get_encoding("cl100k_base")

prompt = "Python으로 사용자 인증 코드를 작성해주세요."
tokens = encoding.encode(prompt)

print(f"토큰 수: {len(tokens)}")
print(f"토큰: {tokens}")

import anthropic
import tiktoken
import time

def evaluate_prompt(prompt: str, test_cases: list) -> dict:
    client = anthropic.Anthropic()
    encoding = tiktoken.get_encoding("cl100k_base")

    results = []
    for test_case in test_cases:
        start_time = time.time()

        response = client.messages.create(
            model="claude-",
            max_tokens=4096,
            messages=[{"role": "user", "content": prompt}]
        )

        elapsed = time.time() - start_time
        input_tokens = len(encoding.encode(prompt))
        output_tokens = len(encoding.encode(response.content[0].text))

        results.append({
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "time": elapsed,
            "response": response.content[0].text
        })

    return {
        "avg_input_tokens": sum(r["input_tokens"] for r in results) / len(results),
        "avg_output_tokens": sum(r["output_tokens"] for r in results) / len(results),
        "avg_time": sum(r["time"] for r in results) / len(results),
        "responses": results
    }

# 사용 예시
prompt_a = "Python으로 사용자 인증 함수를 작성해주세요."
prompt_b = "Python으로 사용자 인증 함수를 작성해주세요. JWT 토큰 검증, bcrypt 비밀번호 해싱 포함."

result_a = evaluate_prompt(prompt_a, test_cases=[{} for _ in range(3)])
result_b = evaluate_prompt(prompt_b, test_cases=[{} for _ in range(3)])

print("Prompt A:", result_a)
print("Prompt B:", result_b)