프롬프트 엔지니어링의 중요성

LLM을 효과적으로 활용하려면 프롬프트 엔지니어링이 필수입니다. 같은 모델이라도 프롬프트를 어떻게 작성하느냐에 따라 결과의 품질이 천차만별로 달라집니다.

실제 사례:

# 나쁜 프롬프트
"파이썬 코드 작성해줘"
# → 모호하고 일반적인 결과

# 좋은 프롬프트
"""
FastAPI를 사용하여 다음 요구사항을 만족하는 REST API를 작성해주세요:
1. /users 엔드포인트 (GET, POST)
2. Pydantic 모델로 입력 검증
3. async/await 사용
4. 에러 핸들링 포함
5. 타입 힌트 포함
"""
# → 구체적이고 정확한 결과

핵심 프롬프트 엔지니어링 기법

1. Zero-Shot vs Few-Shot vs Many-Shot

Zero-Shot Prompting

설명 없이 바로 작업 요청:

from openai import OpenAI

client = OpenAI()

prompt = """
다음 텍스트의 감정을 분석해주세요:
"오늘 프로젝트가 성공적으로 배포되어서 너무 기쁩니다!"
"""

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}]
)

print(response.choices[0].message.content)
# 출력: "긍정적 (Positive)"

Few-Shot Prompting

예시를 제공하여 성능 향상:

prompt = """
다음은 텍스트의 감정을 분석하는 예시입니다:

예시 1:
입력: "이번 업데이트는 정말 최악이에요."
감정: 부정적 (Negative)

예시 2:
입력: "새로운 기능이 생겨서 편리해졌어요."
감정: 긍정적 (Positive)

예시 3:
입력: "오늘 날씨는 그냥 그래요."
감정: 중립적 (Neutral)

이제 다음 텍스트의 감정을 분석해주세요:
입력: "AI 기술 발전이 빠르긴 한데 윤리 문제가 걱정됩니다."
감정:
"""

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}]
)

print(response.choices[0].message.content)
# 출력: "혼합적 (Mixed) - 긍정적 측면과 부정적 우려를 동시에 표현"

Few-Shot의 장점:

• ✅ 정확도 향상 (평균 20-30%)
• ✅ 출력 형식 일관성
• ✅ 도메인 특화 작업에 효과적

2. Chain of Thought (CoT)

모델이 단계별로 사고하도록 유도:

# 기본 프롬프트 (정확도 낮음)
prompt_basic = """
문제: 한 상점에 사과가 23개 있었습니다.
아침에 16개를 팔고, 오후에 45개를 새로 들여왔습니다.
그리고 저녁에 28개를 더 팔았습니다.
이제 사과는 몇 개 남았습니까?
"""

# CoT 프롬프트 (정확도 높음)
prompt_cot = """
문제: 한 상점에 사과가 23개 있었습니다.
아침에 16개를 팔고, 오후에 45개를 새로 들여왔습니다.
그리고 저녁에 28개를 더 팔았습니다.
이제 사과는 몇 개 남았습니까?

단계별로 생각해봅시다:
"""

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt_cot}]
)

print(response.choices[0].message.content)

예상 출력:

1단계: 초기 사과 개수 = 23개
2단계: 아침에 판매 후 = 23 - 16 = 7개
3단계: 오후에 입고 후 = 7 + 45 = 52개
4단계: 저녁에 판매 후 = 52 - 28 = 24개

답: 24개

Few-Shot CoT (가장 강력)

prompt_few_shot_cot = """
다음은 단계별 추론의 예시입니다:

Q: 로저는 테니스공 5개를 가지고 있었습니다. 그는 테니스공 통을 2개 더 샀습니다.
각 통에는 테니스공이 3개씩 들어있습니다. 이제 그는 테니스공을 몇 개 가지고 있습니까?

A: 로저는 처음에 5개의 공을 가지고 있었습니다.
2통 x 통당 3개 = 6개의 공을 더 샀습니다.
5 + 6 = 11개입니다.
답: 11개

Q: 식당에는 23개의 사과가 있었습니다.
점심과 저녁에 각각 20개씩 사용했다면, 식당에는 이제 사과가 몇 개 남았습니까?

A: 식당은 처음에 23개의 사과가 있었습니다.
점심에 20개, 저녁에 20개를 사용했으므로 총 20 + 20 = 40개를 사용했습니다.
23 - 40 = -17개입니다.
하지만 사과는 음수가 될 수 없으므로, 사과가 부족했다는 것을 의미합니다.
답: 0개 (17개 부족)

Q: {실제 문제를 여기에 입력}

A:
"""

3. Self-Consistency

같은 질문에 여러 번 답변을 생성하고 다수결로 결정:

def self_consistency_prompting(question: str, num_samples: int = 5) -> str:
    """Self-Consistency 기법으로 답변 생성"""

    prompt = f"""
    다음 문제를 단계별로 풀어주세요:

    {question}

    단계별로 생각하고, 마지막에 "최종 답:"으로 시작하는 줄에 답을 작성해주세요.
    """

    answers = []

    # 여러 번 샘플링
    for _ in range(num_samples):
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7  # 다양성을 위해 temperature 설정
        )

        answer = response.choices[0].message.content

        # "최종 답:" 추출
        if "최종 답:" in answer:
            final_answer = answer.split("최종 답:")[1].strip().split('\n')[0]
            answers.append(final_answer)

    # 가장 많이 나온 답 선택
    from collections import Counter
    most_common = Counter(answers).most_common(1)[0][0]

    return most_common

# 사용 예시
question = """
한 농장에서 첫째 날 계란을 40개 생산했습니다.
둘째 날에는 첫째 날보다 50% 더 많이 생산했습니다.
셋째 날에는 둘째 날의 2/3만큼 생산했습니다.
3일간 총 몇 개의 계란을 생산했습니까?
"""

result = self_consistency_prompting(question)
print(f"Self-Consistency 결과: {result}")

4. ReAct (Reasoning + Acting)

추론과 행동을 결합:

prompt_react = """
당신은 질문에 답하기 위해 다음 도구를 사용할 수 있습니다:
- Search: 웹 검색
- Calculator: 계산
- Database: 데이터베이스 조회

다음 형식으로 응답하세요:

Thought: (현재 상황에 대한 생각)
Action: (사용할 도구와 입력)
Observation: (도구의 출력)
... (필요한 만큼 반복)
Thought: 이제 최종 답을 알 수 있습니다
Final Answer: (최종 답변)

질문: 2024년 노벨 물리학상 수상자는 누구이며, 그들의 업적은 무엇입니까?

Thought: 먼저 2024년 노벨 물리학상 수상자를 검색해야 합니다.
Action: Search["2024 노벨 물리학상 수상자"]
Observation: 존 홉필드와 제프리 힌턴이 인공신경망 연구로 수상했습니다.
Thought: 이제 그들의 구체적인 업적을 알아봐야 합니다.
Action: Search["존 홉필드 제프리 힌턴 업적"]
Observation: 홉필드는 연상 기억을 위한 홉필드 네트워크를 개발했고, 힌턴은 딥러닝의 기초를 마련했습니다.
Thought: 이제 최종 답을 알 수 있습니다.
Final Answer: 2024년 노벨 물리학상은 존 홉필드와 제프리 힌턴이 수상했습니다. 홉필드는 연상 기억 네트워크를, 힌턴은 딥러닝의 기초를 개발한 공로를 인정받았습니다.
"""

5. Tree of Thoughts (ToT)

여러 사고 경로를 탐색:

def tree_of_thoughts(problem: str, num_branches: int = 3, depth: int = 2):
    """Tree of Thoughts 구현"""

    prompt_template = """
    문제: {problem}

    이 문제를 해결하기 위한 {num_branches}가지 서로 다른 접근 방법을 제시해주세요.
    각 접근 방법에 대해:
    1. 방법 설명
    2. 장점
    3. 단점

    형식:
    접근 방법 1:
    - 설명: ...
    - 장점: ...
    - 단점: ...
    """

    # 1단계: 여러 접근 방법 생성
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{
            "role": "user",
            "content": prompt_template.format(
                problem=problem,
                num_branches=num_branches
            )
        }]
    )

    approaches = response.choices[0].message.content
    print("=== 가능한 접근 방법들 ===")
    print(approaches)

    # 2단계: 각 접근 방법 평가
    eval_prompt = f"""
    다음은 문제 해결을 위한 여러 접근 방법입니다:

    {approaches}

    각 접근 방법을 1-10점으로 평가하고, 가장 좋은 방법을 선택해주세요.
    선택한 방법으로 문제를 실제로 해결해주세요.
    """

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": eval_prompt}]
    )

    return response.choices[0].message.content

# 사용 예시
problem = """
온라인 쇼핑몰의 추천 시스템을 개선하려고 합니다.
현재 단순 협업 필터링을 사용 중이며, 콜드 스타트 문제가 있습니다.
어떻게 개선할 수 있을까요?
"""

result = tree_of_thoughts(problem)
print("\n=== 최종 해결책 ===")
print(result)

실전 프롬프트 패턴

1. 역할 기반 프롬프팅

prompt = """
당신은 20년 경력의 시니어 Python 개발자입니다.
코드 리뷰 전문가로서 다음 코드를 검토해주세요:

```python
def calc(a, b):
    return a + b

result = calc(5, 3)
print(result)

다음 관점에서 피드백을 제공해주세요:

1. 네이밍
2. 타입 힌팅
3. 문서화
4. 에러 핸들링
5. 테스트 가능성 """

response = client.chat.completions.create( model=“gpt-4”, messages=[{“role”: “user”, “content”: prompt}] )

### 2. 제약 조건 명시

```python
prompt = """
다음 조건을 모두 만족하는 Python 함수를 작성해주세요:

필수 조건:
- 함수명: validate_email
- 입력: 문자열
- 출력: bool (유효하면 True, 아니면 False)
- 정규표현식 사용
- 타입 힌트 포함
- Docstring 포함

검증 규칙:
1. @ 기호 포함
2. @ 앞에 1개 이상의 문자
3. @ 뒤에 도메인 (예: example.com)
4. 도메인에 . 포함
5. 최상위 도메인은 2-6자

추가 요구사항:
- 예외 처리 포함
- 최소 3개의 테스트 케이스 주석으로 제공
"""

3. 출력 형식 지정

prompt = """
다음 텍스트에서 정보를 추출하여 JSON 형식으로 출력해주세요:

텍스트:
"김철수 고객님의 주문이 접수되었습니다.
주문번호는 ORD-2025-001234이며,
배송지는 서울시 강남구 테헤란로 123입니다.
총 금액은 45,000원이고,
예상 배송일은 2025년 10월 25일입니다."

출력 형식:
{
  "customer_name": "...",
  "order_id": "...",
  "address": "...",
  "total_amount": 숫자,
  "estimated_delivery": "YYYY-MM-DD"
}

중요: JSON만 출력하고, 다른 설명은 포함하지 마세요.
"""

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}],
    response_format={"type": "json_object"}  # JSON 모드
)

import json
data = json.loads(response.choices[0].message.content)
print(data)

4. 반복 개선 (Iterative Refinement)

class PromptRefiner:
    def __init__(self, client):
        self.client = client
        self.conversation = []

    def initial_prompt(self, task: str) -> str:
        """초기 프롬프트 생성"""
        self.conversation = [{
            "role": "user",
            "content": task
        }]

        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=self.conversation
        )

        result = response.choices[0].message.content
        self.conversation.append({
            "role": "assistant",
            "content": result
        })

        return result

    def refine(self, feedback: str) -> str:
        """피드백을 바탕으로 개선"""
        self.conversation.append({
            "role": "user",
            "content": f"개선 요청: {feedback}"
        })

        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=self.conversation
        )

        result = response.choices[0].message.content
        self.conversation.append({
            "role": "assistant",
            "content": result
        })

        return result

# 사용 예시
refiner = PromptRefiner(client)

# 1차 시도
result1 = refiner.initial_prompt(
    "FastAPI로 사용자 인증 API를 만들어주세요."
)
print("=== 1차 결과 ===")
print(result1)

# 개선 1
result2 = refiner.refine(
    "JWT 토큰을 사용하고, 리프레시 토큰도 구현해주세요."
)
print("\n=== 2차 결과 ===")
print(result2)

# 개선 2
result3 = refiner.refine(
    "Redis를 사용한 토큰 블랙리스트 기능도 추가해주세요."
)
print("\n=== 최종 결과 ===")
print(result3)

프롬프트 최적화 전략

1. 명확성 (Clarity)

# ❌ 나쁜 예
"코드 짜줘"

# ✅ 좋은 예
"""
Python으로 CSV 파일을 읽어서 데이터를 분석하는 스크립트를 작성해주세요.

요구사항:
- pandas 사용
- 결측치 처리
- 기술 통계량 출력
- 시각화 (matplotlib)
- 함수로 모듈화
"""

2. 구체성 (Specificity)

# ❌ 나쁜 예
"웹사이트 만들어줘"

# ✅ 좋은 예
"""
React와 TypeScript를 사용한 할 일 관리 웹앱을 만들어주세요.

기능:
1. 할 일 추가/수정/삭제
2. 완료 상태 토글
3. 로컬 스토리지에 저장
4. 날짜별 필터링
5. 검색 기능

기술 스택:
- React 18
- TypeScript
- Tailwind CSS
- React Hooks (useState, useEffect)

코드 스타일:
- 함수형 컴포넌트
- 커스텀 훅 활용
- TypeScript 인터페이스 정의
"""

3. 컨텍스트 제공

prompt = """
컨텍스트:
- 프로젝트: 전자상거래 플랫폼
- 현재 상황: 결제 시스템 구현 중
- 기술 스택: Node.js, Express, PostgreSQL
- 이미 구현됨: 사용자 인증, 상품 관리

작업:
결제 API 엔드포인트를 설계하고 구현해주세요.

고려사항:
1. PG사 연동 (토스페이먼츠)
2. 트랜잭션 처리
3. 결제 실패 시 롤백
4. 웹훅으로 결제 완료 처리
5. 재시도 로직

제약사항:
- RESTful API 원칙 준수
- 에러 처리 포함
- 로깅 추가
- 테스트 코드 작성
"""

4. 예제 기반 학습

prompt = """
다음 예제를 참고하여 새로운 함수를 작성해주세요:

예제 1 - 간단한 유효성 검사:
```python
def validate_age(age: int) -> bool:
    \"\"\"나이 유효성 검사\"\"\"
    if not isinstance(age, int):
        raise TypeError("나이는 정수여야 합니다")
    if age < 0 or age > 150:
        raise ValueError("유효하지 않은 나이입니다")
    return True

예제 2 - 복잡한 유효성 검사:

def validate_password(password: str) -> tuple[bool, list[str]]:
    \"\"\"비밀번호 유효성 검사\"\"\"
    errors = []

    if len(password) < 8:
        errors.append("최소 8자 이상이어야 합니다")
    if not any(c.isupper() for c in password):
        errors.append("대문자를 포함해야 합니다")
    if not any(c.isdigit() for c in password):
        errors.append("숫자를 포함해야 합니다")

    return len(errors) == 0, errors

이제 위 패턴을 따라 전화번호 유효성 검사 함수를 작성해주세요:

• 한국 휴대폰 번호 형식 (010-XXXX-XXXX)
• 에러 메시지 리스트 반환
• 타입 힌트 포함
• Docstring 포함 """

## 고급 테크닉

### 1. 메타 프롬프팅

프롬프트를 작성하는 프롬프트:

```python
meta_prompt = """
다음 작업을 수행하기 위한 최적의 프롬프트를 작성해주세요:

작업: {사용자가 원하는 작업}

좋은 프롬프트의 조건:
1. 명확한 목표 정의
2. 구체적인 요구사항
3. 제약 조건 명시
4. 예제 포함
5. 출력 형식 지정

프롬프트를 작성한 후, 그 프롬프트를 사용하여 실제 결과도 생성해주세요.
"""

# 예시
task = "Python으로 웹 스크래핑 스크립트 작성"

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{
        "role": "user",
        "content": meta_prompt.replace("{사용자가 원하는 작업}", task)
    }]
)

print(response.choices[0].message.content)

2. 프롬프트 체이닝

여러 단계로 나누어 처리:

class PromptChain:
    def __init__(self, client):
        self.client = client

    def step1_analyze(self, code: str) -> str:
        """1단계: 코드 분석"""
        prompt = f"""
        다음 코드를 분석하고 개선할 점을 나열해주세요:

        ```python
        {code}
        ```

        분석 항목:
        1. 코드 스타일
        2. 성능
        3. 보안
        4. 가독성
        """

        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

    def step2_improve(self, analysis: str, code: str) -> str:
        """2단계: 개선된 코드 생성"""
        prompt = f"""
        다음은 코드 분석 결과입니다:
        {analysis}

        원본 코드:
        ```python
        {code}
        ```

        분석 결과를 바탕으로 개선된 코드를 작성해주세요.
        """

        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

    def step3_test(self, improved_code: str) -> str:
        """3단계: 테스트 코드 생성"""
        prompt = f"""
        다음 코드에 대한 pytest 테스트를 작성해주세요:

        {improved_code}

        테스트 커버리지:
        - 정상 케이스
        - 경계값
        - 예외 상황
        """

        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

    def execute(self, code: str) -> dict:
        """전체 체인 실행"""
        analysis = self.step1_analyze(code)
        improved = self.step2_improve(analysis, code)
        tests = self.step3_test(improved)

        return {
            "analysis": analysis,
            "improved_code": improved,
            "tests": tests
        }

# 사용 예시
chain = PromptChain(client)

original_code = """
def calc(x, y):
    return x / y
"""

result = chain.execute(original_code)
print("=== 분석 ===")
print(result["analysis"])
print("\n=== 개선된 코드 ===")
print(result["improved_code"])
print("\n=== 테스트 ===")
print(result["tests"])

3. 동적 Few-Shot 선택

유사한 예제를 자동으로 선택:

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

class DynamicFewShot:
    def __init__(self, client):
        self.client = client
        self.examples = []
        self.embeddings = []

    def add_example(self, input_text: str, output_text: str):
        """예제 추가"""
        # 임베딩 생성
        response = self.client.embeddings.create(
            model="text-embedding-3-small",
            input=input_text
        )

        embedding = response.data[0].embedding

        self.examples.append({
            "input": input_text,
            "output": output_text
        })
        self.embeddings.append(embedding)

    def get_relevant_examples(self, query: str, k: int = 3) -> list:
        """쿼리와 유사한 예제 k개 선택"""
        # 쿼리 임베딩 생성
        response = self.client.embeddings.create(
            model="text-embedding-3-small",
            input=query
        )

        query_embedding = response.data[0].embedding

        # 유사도 계산
        similarities = cosine_similarity(
            [query_embedding],
            self.embeddings
        )[0]

        # 상위 k개 선택
        top_k_indices = np.argsort(similarities)[-k:][::-1]

        return [self.examples[i] for i in top_k_indices]

    def generate(self, query: str) -> str:
        """동적 Few-Shot 생성"""
        relevant_examples = self.get_relevant_examples(query)

        # Few-Shot 프롬프트 구성
        prompt = "다음은 예제입니다:\n\n"

        for i, ex in enumerate(relevant_examples, 1):
            prompt += f"예제 {i}:\n"
            prompt += f"입력: {ex['input']}\n"
            prompt += f"출력: {ex['output']}\n\n"

        prompt += f"이제 다음 입력에 대해 출력을 생성해주세요:\n"
        prompt += f"입력: {query}\n"
        prompt += f"출력:"

        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

# 사용 예시
few_shot = DynamicFewShot(client)

# 예제 추가
few_shot.add_example(
    "사용자 로그인 API",
    "POST /api/auth/login\nBody: { username, password }\nResponse: { token, user }"
)

few_shot.add_example(
    "상품 목록 조회 API",
    "GET /api/products?page=1&limit=20\nResponse: { products: [], total, page }"
)

few_shot.add_example(
    "주문 생성 API",
    "POST /api/orders\nBody: { items, address, payment }\nResponse: { orderId, status }"
)

# 쿼리 실행
query = "결제 처리 API"
result = few_shot.generate(query)
print(result)

프롬프트 평가 및 최적화

1. A/B 테스팅

class PromptABTest:
    def __init__(self, client):
        self.client = client

    def test_prompts(
        self,
        prompts: dict[str, str],
        test_cases: list[str],
        evaluator_prompt: str
    ) -> dict:
        """여러 프롬프트 버전을 테스트"""

        results = {name: [] for name in prompts.keys()}

        for test_case in test_cases:
            for name, prompt_template in prompts.items():
                # 프롬프트 실행
                prompt = prompt_template.format(input=test_case)

                response = self.client.chat.completions.create(
                    model="gpt-4",
                    messages=[{"role": "user", "content": prompt}]
                )

                output = response.choices[0].message.content

                # 평가
                eval_prompt = evaluator_prompt.format(
                    input=test_case,
                    output=output
                )

                eval_response = self.client.chat.completions.create(
                    model="gpt-4",
                    messages=[{"role": "user", "content": eval_prompt}]
                )

                score = float(eval_response.choices[0].message.content.strip())

                results[name].append({
                    "test_case": test_case,
                    "output": output,
                    "score": score
                })

        # 통계 계산
        stats = {}
        for name, scores in results.items():
            avg_score = np.mean([s["score"] for s in scores])
            stats[name] = {
                "average_score": avg_score,
                "results": scores
            }

        return stats

# 사용 예시
ab_test = PromptABTest(client)

prompts = {
    "버전A": "다음 텍스트를 요약해주세요: {input}",
    "버전B": """
    다음 텍스트를 3문장 이내로 요약해주세요.
    핵심 내용만 포함하고, 불필요한 세부사항은 제외하세요.

    텍스트: {input}
    """,
    "버전C": """
    당신은 전문 에디터입니다.
    다음 텍스트의 핵심 메시지를 3문장으로 요약해주세요.

    텍스트: {input}

    요약:
    """
}

test_cases = [
    "인공지능 기술의 발전으로...",  # 실제 텍스트
    "기후 변화는 전 세계적인...",
    "최근 경제 상황을..."
]

evaluator = """
다음 요약의 품질을 1-10점으로 평가해주세요:

원문: {input}
요약: {output}

평가 기준:
- 정확성 (핵심 내용 포함)
- 간결성 (불필요한 내용 제외)
- 가독성

점수만 숫자로 출력하세요 (예: 8.5):
"""

results = ab_test.test_prompts(prompts, test_cases, evaluator)

for name, stats in results.items():
    print(f"{name}: 평균 점수 = {stats['average_score']:.2f}")

프롬프트 라이브러리 구축

실무에서 재사용 가능한 프롬프트 라이브러리:

class PromptLibrary:
    """재사용 가능한 프롬프트 템플릿 라이브러리"""

    CODE_REVIEW = """
당신은 시니어 {{language}} 개발자입니다.
다음 코드를 리뷰해주세요:

(코드 블록)

다음 관점에서 피드백을 제공해주세요:
{{review_points}}

각 항목에 대해:
- 현재 상태 평가
- 개선 제안 (구체적인 코드 포함)
- 우선순위 (높음/중간/낮음)
"""

    DOCUMENTATION = """
다음 코드에 대한 문서를 작성해주세요:

(코드 블록)

포함할 내용:
1. 함수/클래스 설명
2. 매개변수 설명
3. 반환값 설명
4. 사용 예제
5. 주의사항 (있는 경우)

형식: {{doc_format}}
"""

    TEST_GENERATION = """
다음 코드에 대한 테스트를 작성해주세요:

(코드 블록)

테스트 프레임워크: {{framework}}

포함할 테스트:
1. 정상 동작 테스트
2. 경계값 테스트
3. 예외 처리 테스트
4. {{additional_tests}}

테스트 커버리지: {{coverage_target}}%
"""

    DEBUGGING = """
다음 코드에서 버그를 찾고 수정해주세요:

(코드 블록)

에러 메시지:
{{error_message}}

다음 형식으로 응답해주세요:
1. 버그 위치 및 원인
2. 수정된 코드
3. 설명
4. 유사한 버그 예방 방법
"""

    REFACTORING = """
다음 코드를 리팩토링해주세요:

(코드 블록)

리팩토링 목표:
{{goals}}

적용할 패턴:
{{patterns}}

제약사항:
- 기존 기능 유지
- 하위 호환성 보장
- {{additional_constraints}}
"""

    OPTIMIZATION = """
다음 코드의 성능을 최적화해주세요:

(코드 블록)

현재 성능 문제:
{{performance_issues}}

목표:
- 시간 복잡도: {{time_complexity}}
- 공간 복잡도: {{space_complexity}}

최적화 후:
1. 개선된 코드
2. 성능 개선 설명
3. 트레이드오프 분석
"""

# 사용 예시
library = PromptLibrary()

code_review_prompt = library.CODE_REVIEW.format(
    language="Python",
    code="def process_data(data):\n    return [x*2 for x in data]",
    review_points="""
    - 타입 힌팅
    - 에러 처리
    - 성능
    - 문서화
    """
)

print(code_review_prompt)

결론

프롬프트 엔지니어링은 LLM 활용의 핵심 기술입니다.

핵심 요약:

1. 기본 기법

   • Zero-Shot: 빠르지만 정확도 낮음
   • Few-Shot: 예제로 성능 향상
   • Chain of Thought: 단계별 추론

2. 고급 기법

   • Self-Consistency: 여러 답변 조합
   • ReAct: 추론 + 행동
   • Tree of Thoughts: 다양한 경로 탐색

3. 최적화 전략

   • 명확성과 구체성
   • 컨텍스트 제공
   • 출력 형식 지정
   • 반복적 개선

4. 실전 팁

   • 프롬프트 라이브러리 구축
   • A/B 테스팅으로 최적화
   • 체이닝으로 복잡한 작업 분해
   • 메타 프롬프팅 활용

시작하기:

# 오늘부터 적용할 수 있는 것들
1. Few-Shot 예제 3개 추가하기
2. CoT "단계별로 생각해봅시다" 추가
3. 역할과 제약조건 명시하기
4. 출력 형식을 JSON으로 지정하기
5. 프롬프트 템플릿 라이브러리 만들기

효과적인 프롬프트 엔지니어링으로 LLM의 잠재력을 최대한 활용하세요!