prompt patterns
**Prompt engineering patterns** are **reusable templates and techniques for structuring LLM interactions** — providing proven approaches like few-shot examples, chain-of-thought reasoning, and role-based prompting that improve response quality, consistency, and task performance across different use cases.
**What Are Prompt Patterns?**
- **Definition**: Standardized templates for effective LLM prompting.
- **Purpose**: Improve quality, consistency, and reliability.
- **Approach**: Reusable structures that work across tasks.
- **Evolution**: Patterns discovered through experimentation.
**Why Patterns Matter**
- **Consistency**: Same structure produces predictable results.
- **Quality**: Proven techniques outperform ad-hoc prompts.
- **Efficiency**: Don't reinvent the wheel for each task.
- **Scalability**: Libraries of prompts for different needs.
- **Debugging**: Structured prompts are easier to iterate.
**Core Prompt Patterns**
**Pattern 1: Role-Based Prompting**:
```python
SYSTEM_PROMPT = """
You are an expert {role} with {years} years of experience.
Your specialty is {specialty}.
When answering:
- Be precise and technical
- Cite sources when possible
- Acknowledge uncertainty
"""
# Example
SYSTEM_PROMPT = """
You are an expert machine learning engineer with 10 years
of experience. Your specialty is optimizing LLM inference.
When answering:
- Be precise and technical
- Provide code examples when helpful
- Acknowledge uncertainty
"""
```
**Pattern 2: Few-Shot Examples**:
```python
prompt = """
Classify the sentiment of these reviews:
Review: "This product exceeded my expectations!"
Sentiment: Positive
Review: "Terrible quality, broke after one day."
Sentiment: Negative
Review: "It works, nothing special."
Sentiment: Neutral
Review: "{user_review}"
Sentiment:"""
```
**Pattern 3: Chain-of-Thought (CoT)**:
```python
prompt = """
Solve this step by step:
Question: {question}
Let's think through this step by step:
1. First, I need to understand...
2. Then, I should consider...
3. Finally, I can conclude...
Answer:"""
# Zero-shot CoT (simpler)
prompt = """
{question}
Let's think step by step.
"""
```
**Pattern 4: Output Formatting**:
```python
prompt = """
Analyze this code and respond in JSON format:
```python
{code}
```
Respond with:
{
"issues": [{"line": int, "description": str, "severity": str}],
"suggestions": [str],
"overall_quality": str // "good", "needs_work", "poor"
}
"""
```
**Advanced Patterns**
**Self-Consistency** (Multiple samples):
```python
# Generate multiple responses
responses = [llm.generate(prompt) for _ in range(5)]
# Take majority vote or consensus
final_answer = most_common(responses)
```
**ReAct (Reasoning + Acting)**:
```
Question: What is the population of Paris?
Thought: I need to look up the current population of Paris.
Action: search("population of Paris 2024")
Observation: Paris has approximately 2.1 million people.
Thought: I have the answer.
Answer: Paris has approximately 2.1 million people.
```
**Decomposition**:
```python
prompt = """
Break this complex task into subtasks:
Task: {complex_task}
Subtasks:
1.
2.
3.
...
Now complete each subtask:
"""
```
**Prompt Template Library**
```python
TEMPLATES = {
"summarize": """
Summarize the following text in {length} sentences:
{text}
Summary:""",
"extract": """
Extract the following information from the text:
{fields}
Text: {text}
Extracted (JSON):""",
"transform": """
Transform this {source_format} to {target_format}:
Input:
{input}
Output:""",
"critique": """
Review this {artifact_type} and provide:
1. Strengths
2. Weaknesses
3. Suggestions for improvement
{artifact}
Review:"""
}
```
**Best Practices**
**Structure**:
```
1. Role/Context (who the LLM is)
2. Task (what to do)
3. Format (how to respond)
4. Examples (if few-shot)
5. Input (user's content)
```
**Tips**:
- Be specific and explicit.
- Use delimiters for sections (```, ---, ###).
- Put instructions before content.
- Include format examples.
- Test with edge cases.
**Anti-Patterns to Avoid**:
```
❌ Vague: "Make this better"
✅ Specific: "Improve clarity by using shorter sentences"
❌ No format: "Analyze this"
✅ With format: "Analyze this and list 3 key points"
❌ Contradictory: "Be brief but comprehensive"
✅ Clear: "Summarize in 2-3 sentences"
```
Prompt engineering patterns are **the design patterns of AI development** — proven templates that solve common problems, enabling faster development and better results than starting from scratch for every LLM interaction.