chore: track shared agent skills in repository
This commit is contained in:
Eric Wang
@@ -0,0 +1,506 @@
|
||||
# Prompt Patterns
|
||||
|
||||
---
|
||||
|
||||
## Pattern Selection Guide
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────┐
|
||||
│ TASK CHARACTERISTICS │
|
||||
└─────────────────────────────────────┘
|
||||
│
|
||||
┌─────────────────────────────┼─────────────────────────────┐
|
||||
│ │ │
|
||||
Simple, Common Requires Reasoning Requires Actions
|
||||
│ │ │
|
||||
▼ ▼ ▼
|
||||
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
|
||||
│ Zero-Shot │ │ CoT or │ │ ReAct │
|
||||
│ │ │ Few-Shot │ │ │
|
||||
└─────────────┘ └─────────────┘ └─────────────┘
|
||||
```
|
||||
|
||||
| Pattern | Best For | Token Cost | Reliability |
|
||||
|---------|----------|------------|-------------|
|
||||
| Zero-shot | Simple, well-defined tasks | Low | Medium |
|
||||
| Few-shot | Tasks needing format guidance | Medium | High |
|
||||
| Chain-of-Thought | Reasoning, math, logic | Medium-High | High |
|
||||
| ReAct | Multi-step tasks with tools | High | Very High |
|
||||
| Tree-of-Thoughts | Complex problem solving | Very High | Very High |
|
||||
|
||||
---
|
||||
|
||||
## Zero-Shot Prompting
|
||||
|
||||
**When to use:** Simple classification, extraction, formatting, or generation tasks where the model has strong prior knowledge.
|
||||
|
||||
**When NOT to use:** Complex reasoning, domain-specific formats, or tasks requiring specific output structure.
|
||||
|
||||
### Basic Structure
|
||||
|
||||
```
|
||||
<role>You are a [specific role with relevant expertise].</role>
|
||||
|
||||
<task>
|
||||
[Clear, specific instruction]
|
||||
</task>
|
||||
|
||||
<constraints>
|
||||
- [Constraint 1]
|
||||
- [Constraint 2]
|
||||
</constraints>
|
||||
|
||||
<input>
|
||||
{user_content}
|
||||
</input>
|
||||
|
||||
<output_format>
|
||||
[Expected format description]
|
||||
</output_format>
|
||||
```
|
||||
|
||||
### Example: Sentiment Classification
|
||||
|
||||
```
|
||||
You are a sentiment analysis expert.
|
||||
|
||||
Classify the following customer review as POSITIVE, NEGATIVE, or NEUTRAL.
|
||||
Respond with only the classification label.
|
||||
|
||||
Review: "{review_text}"
|
||||
|
||||
Classification:
|
||||
```
|
||||
|
||||
### Example: Entity Extraction
|
||||
|
||||
```
|
||||
Extract all company names mentioned in the following text.
|
||||
Return them as a JSON array of strings.
|
||||
If no companies are mentioned, return an empty array.
|
||||
|
||||
Text: "{input_text}"
|
||||
|
||||
Companies:
|
||||
```
|
||||
|
||||
### Zero-Shot Best Practices
|
||||
|
||||
1. **Be specific about the task** - Avoid ambiguous instructions
|
||||
2. **Specify output format** - Tell the model exactly what to return
|
||||
3. **Include constraints** - What NOT to do is as important as what to do
|
||||
4. **Use role priming** - "You are an expert..." improves quality
|
||||
|
||||
---
|
||||
|
||||
## Few-Shot Prompting
|
||||
|
||||
**When to use:** Tasks needing specific output format, domain-specific reasoning, or consistent style.
|
||||
|
||||
**When NOT to use:** Simple tasks where examples add unnecessary tokens, or when examples might constrain creativity.
|
||||
|
||||
### Basic Structure
|
||||
|
||||
```
|
||||
<task>
|
||||
[Task description]
|
||||
</task>
|
||||
|
||||
<examples>
|
||||
Input: [example 1 input]
|
||||
Output: [example 1 output]
|
||||
|
||||
Input: [example 2 input]
|
||||
Output: [example 2 output]
|
||||
|
||||
Input: [example 3 input]
|
||||
Output: [example 3 output]
|
||||
</examples>
|
||||
|
||||
<input>
|
||||
{actual_input}
|
||||
</input>
|
||||
|
||||
Output:
|
||||
```
|
||||
|
||||
### Example: Code Review Comments
|
||||
|
||||
```
|
||||
Generate a constructive code review comment for the given code issue.
|
||||
|
||||
Example 1:
|
||||
Issue: Variable named 'x' in a function calculating total price
|
||||
Comment: Consider renaming 'x' to 'totalPrice' or 'priceSum' to improve readability. Descriptive variable names help future maintainers understand the code's intent without needing to trace through the logic.
|
||||
|
||||
Example 2:
|
||||
Issue: SQL query built with string concatenation using user input
|
||||
Comment: This code is vulnerable to SQL injection attacks. Consider using parameterized queries or an ORM to safely handle user input. For example: `cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))`
|
||||
|
||||
Example 3:
|
||||
Issue: Catch block that silently swallows exceptions
|
||||
Comment: Empty catch blocks can hide bugs and make debugging difficult. Consider logging the exception or, if the exception is truly expected, add a comment explaining why it's safe to ignore.
|
||||
|
||||
Issue: {code_issue}
|
||||
Comment:
|
||||
```
|
||||
|
||||
### Few-Shot Selection Strategies
|
||||
|
||||
| Strategy | Description | Best For |
|
||||
|----------|-------------|----------|
|
||||
| Diverse | Cover different cases/categories | Classification, categorization |
|
||||
| Similar | Match examples to input type | Consistent formatting |
|
||||
| Increasing complexity | Start simple, build up | Complex reasoning tasks |
|
||||
| Edge cases | Include boundary cases | Robust handling |
|
||||
|
||||
### Example Selection Guidelines
|
||||
|
||||
1. **Match the distribution** - Examples should represent real inputs
|
||||
2. **3-5 examples typically optimal** - Balance between guidance and token cost
|
||||
3. **Order matters** - Recent examples have more influence
|
||||
4. **Include edge cases** - Show how to handle unusual inputs
|
||||
5. **Keep format consistent** - All examples should follow the same structure
|
||||
|
||||
### Dynamic Few-Shot Selection
|
||||
|
||||
```python
|
||||
def select_examples(query: str, example_pool: list, k: int = 3) -> list:
|
||||
"""Select most relevant examples using embedding similarity."""
|
||||
query_embedding = embed(query)
|
||||
|
||||
scored = []
|
||||
for example in example_pool:
|
||||
score = cosine_similarity(query_embedding, example.embedding)
|
||||
scored.append((score, example))
|
||||
|
||||
# Return top-k most similar examples
|
||||
scored.sort(reverse=True)
|
||||
return [ex for _, ex in scored[:k]]
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Chain-of-Thought (CoT) Prompting
|
||||
|
||||
**When to use:** Math problems, logical reasoning, multi-step analysis, debugging, planning.
|
||||
|
||||
**When NOT to use:** Simple factual recall, creative generation, or tasks where reasoning steps aren't helpful.
|
||||
|
||||
### Zero-Shot CoT
|
||||
|
||||
Simply add "Let's think step by step" or similar phrase:
|
||||
|
||||
```
|
||||
Solve the following problem step by step:
|
||||
|
||||
{problem}
|
||||
|
||||
Let's work through this systematically:
|
||||
```
|
||||
|
||||
### Structured CoT
|
||||
|
||||
```
|
||||
Analyze the following problem and solve it step by step.
|
||||
|
||||
Problem: {problem}
|
||||
|
||||
## Step 1: Understand the problem
|
||||
[What are we trying to find?]
|
||||
|
||||
## Step 2: Identify relevant information
|
||||
[What data do we have?]
|
||||
|
||||
## Step 3: Plan the approach
|
||||
[What method will we use?]
|
||||
|
||||
## Step 4: Execute the solution
|
||||
[Work through the calculations/logic]
|
||||
|
||||
## Step 5: Verify the answer
|
||||
[Check if the answer makes sense]
|
||||
|
||||
Final Answer:
|
||||
```
|
||||
|
||||
### Example: Debugging with CoT
|
||||
|
||||
````
|
||||
Debug the following code by analyzing it step by step.
|
||||
|
||||
Code:
|
||||
```python
|
||||
def calculate_average(numbers):
|
||||
total = 0
|
||||
for num in numbers:
|
||||
total += num
|
||||
return total / len(numbers)
|
||||
```
|
||||
|
||||
Error: ZeroDivisionError when called with empty list
|
||||
|
||||
## Analysis
|
||||
|
||||
### Step 1: Trace the execution path
|
||||
Let me trace what happens when `numbers = []`:
|
||||
1. `total = 0` - total is initialized to 0
|
||||
2. `for num in numbers:` - loop doesn't execute (empty list)
|
||||
3. `return total / len(numbers)` - returns `0 / 0`
|
||||
|
||||
### Step 2: Identify the root cause
|
||||
The function doesn't handle the edge case of an empty list.
|
||||
`len([])` returns 0, causing division by zero.
|
||||
|
||||
### Step 3: Propose fix
|
||||
Add a check for empty input before division.
|
||||
|
||||
### Fixed Code:
|
||||
```python
|
||||
def calculate_average(numbers):
|
||||
if not numbers:
|
||||
return 0 # or raise ValueError("Cannot average empty list")
|
||||
total = sum(numbers)
|
||||
return total / len(numbers)
|
||||
```
|
||||
````
|
||||
|
||||
### CoT Variants
|
||||
|
||||
| Variant | Technique | Use Case |
|
||||
|---------|-----------|----------|
|
||||
| Zero-shot CoT | "Think step by step" | Quick reasoning tasks |
|
||||
| Manual CoT | Explicit step examples | Complex domain problems |
|
||||
| Self-consistency | Generate multiple paths, vote | High-stakes decisions |
|
||||
| Least-to-most | Decompose into subproblems | Complex multi-part problems |
|
||||
|
||||
---
|
||||
|
||||
## ReAct Pattern (Reasoning + Acting)
|
||||
|
||||
**When to use:** Tasks requiring external tools, information retrieval, or iterative problem solving.
|
||||
|
||||
**When NOT to use:** Pure text generation, simple Q&A, or tasks with no action component.
|
||||
|
||||
### ReAct Structure
|
||||
|
||||
```
|
||||
You are an assistant that solves problems by thinking and taking actions.
|
||||
|
||||
Available tools:
|
||||
- search(query): Search the web for information
|
||||
- calculate(expression): Evaluate a mathematical expression
|
||||
- lookup(term): Look up a definition or fact
|
||||
|
||||
Respond in this format:
|
||||
Thought: [Your reasoning about what to do next]
|
||||
Action: [tool_name(parameters)]
|
||||
Observation: [Result from the tool - provided by system]
|
||||
... (repeat Thought/Action/Observation as needed)
|
||||
Thought: I now have enough information to answer.
|
||||
Answer: [Final answer]
|
||||
|
||||
Question: {user_question}
|
||||
```
|
||||
|
||||
### Example: ReAct for Research
|
||||
|
||||
```
|
||||
Question: What is the current market cap of the company that created ChatGPT?
|
||||
|
||||
Thought: I need to find out which company created ChatGPT, then look up their market cap.
|
||||
Action: search("company that created ChatGPT")
|
||||
Observation: ChatGPT was created by OpenAI, an AI research company.
|
||||
|
||||
Thought: Now I need to find OpenAI's current market cap.
|
||||
Action: search("OpenAI market cap 2025")
|
||||
Observation: OpenAI's valuation reached $157 billion in 2024 after their latest funding round.
|
||||
|
||||
Thought: I now have the information needed to answer.
|
||||
Answer: ChatGPT was created by OpenAI, which has a valuation of approximately $157 billion (as of their 2024 funding round). Note: OpenAI is a private company, so this is a valuation rather than a public market cap.
|
||||
```
|
||||
|
||||
### ReAct Implementation Pattern
|
||||
|
||||
```python
|
||||
def react_loop(question: str, tools: dict, max_iterations: int = 10) -> str:
|
||||
"""Execute a ReAct reasoning loop."""
|
||||
context = f"Question: {question}\n\n"
|
||||
|
||||
for i in range(max_iterations):
|
||||
# Get next thought and action from LLM
|
||||
response = llm.complete(REACT_PROMPT + context)
|
||||
|
||||
# Parse thought and action
|
||||
thought, action = parse_react_response(response)
|
||||
context += f"Thought: {thought}\n"
|
||||
|
||||
if action.startswith("Answer:"):
|
||||
return action.replace("Answer:", "").strip()
|
||||
|
||||
# Execute action and get observation
|
||||
tool_name, params = parse_action(action)
|
||||
observation = tools[tool_name](*params)
|
||||
|
||||
context += f"Action: {action}\n"
|
||||
context += f"Observation: {observation}\n\n"
|
||||
|
||||
return "Max iterations reached without answer."
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Tree-of-Thoughts (ToT)
|
||||
|
||||
**When to use:** Complex problems requiring exploration of multiple solution paths, creative problem solving, strategic planning.
|
||||
|
||||
**When NOT to use:** Simple tasks, time-sensitive operations, or when token budget is limited.
|
||||
|
||||
### ToT Structure
|
||||
|
||||
```
|
||||
Problem: {complex_problem}
|
||||
|
||||
## Generate Candidate Approaches
|
||||
|
||||
### Approach A: [First strategy]
|
||||
- Pros: [advantages]
|
||||
- Cons: [disadvantages]
|
||||
- Estimated success: [low/medium/high]
|
||||
|
||||
### Approach B: [Second strategy]
|
||||
- Pros: [advantages]
|
||||
- Cons: [disadvantages]
|
||||
- Estimated success: [low/medium/high]
|
||||
|
||||
### Approach C: [Third strategy]
|
||||
- Pros: [advantages]
|
||||
- Cons: [disadvantages]
|
||||
- Estimated success: [low/medium/high]
|
||||
|
||||
## Evaluate and Select
|
||||
|
||||
Based on the analysis, Approach [X] is most promising because [reasoning].
|
||||
|
||||
## Execute Selected Approach
|
||||
|
||||
[Detailed execution of chosen approach]
|
||||
|
||||
## Verify Solution
|
||||
|
||||
[Check if solution meets requirements]
|
||||
```
|
||||
|
||||
### ToT for Code Architecture
|
||||
|
||||
```
|
||||
Design a caching system for a high-traffic API endpoint.
|
||||
|
||||
## Candidate Architectures
|
||||
|
||||
### Option A: In-Memory Cache (Redis)
|
||||
Thought: Use Redis for distributed caching
|
||||
Evaluation:
|
||||
- Latency: ~1ms (excellent)
|
||||
- Scalability: Horizontal scaling supported
|
||||
- Complexity: Low - well-established pattern
|
||||
- Risk: Cache invalidation complexity
|
||||
Score: 8/10
|
||||
|
||||
### Option B: CDN Edge Caching
|
||||
Thought: Cache at CDN level for static/semi-static content
|
||||
Evaluation:
|
||||
- Latency: ~10-50ms (good)
|
||||
- Scalability: Excellent - distributed globally
|
||||
- Complexity: Medium - cache headers management
|
||||
- Risk: Stale content for dynamic data
|
||||
Score: 6/10
|
||||
|
||||
### Option C: Multi-Layer Cache
|
||||
Thought: Combine L1 (local) + L2 (Redis) + L3 (CDN)
|
||||
Evaluation:
|
||||
- Latency: <1ms for hot data
|
||||
- Scalability: Excellent
|
||||
- Complexity: High - multiple invalidation points
|
||||
- Risk: Consistency challenges
|
||||
Score: 7/10
|
||||
|
||||
## Decision
|
||||
Option A (Redis) selected for initial implementation:
|
||||
- Lowest complexity for team's current expertise
|
||||
- Sufficient performance for projected load
|
||||
- Clear upgrade path to Option C if needed
|
||||
|
||||
## Implementation Plan
|
||||
[Detailed implementation steps...]
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Pattern Comparison Quick Reference
|
||||
|
||||
```
|
||||
┌────────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
|
||||
│ Pattern │ Tokens │ Complexity │ Reliability │ Best For │
|
||||
├────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
|
||||
│ Zero-shot │ Low │ Low │ Medium │ Simple tasks │
|
||||
├────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
|
||||
│ Few-shot │ Medium │ Medium │ High │Format/style │
|
||||
├────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
|
||||
│ CoT │ Medium │ Medium │ High │ Reasoning │
|
||||
├────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
|
||||
│ ReAct │ High │ High │ Very High │ Tool usage │
|
||||
├────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
|
||||
│ ToT │ Very High │ Very High │ Very High │Complex solve │
|
||||
└────────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Combining Patterns
|
||||
|
||||
Patterns can be combined for more powerful prompts:
|
||||
|
||||
### Few-Shot + CoT
|
||||
|
||||
```
|
||||
Solve math word problems by showing your work.
|
||||
|
||||
Example 1:
|
||||
Problem: If a train travels 60 mph for 2.5 hours, how far does it go?
|
||||
Solution:
|
||||
- Distance = Speed × Time
|
||||
- Distance = 60 mph × 2.5 hours
|
||||
- Distance = 150 miles
|
||||
Answer: 150 miles
|
||||
|
||||
Example 2:
|
||||
Problem: A store has a 20% off sale. If an item costs $45, what's the sale price?
|
||||
Solution:
|
||||
- Discount = Original × Discount Rate
|
||||
- Discount = $45 × 0.20 = $9
|
||||
- Sale Price = Original - Discount
|
||||
- Sale Price = $45 - $9 = $36
|
||||
Answer: $36
|
||||
|
||||
Problem: {new_problem}
|
||||
Solution:
|
||||
```
|
||||
|
||||
### ReAct + CoT
|
||||
|
||||
```
|
||||
Thought: Let me break this down step by step.
|
||||
First, I need to understand what information I'm looking for...
|
||||
[reasoning]
|
||||
Based on this analysis, I should search for...
|
||||
Action: search("specific query based on reasoning")
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Related Skills
|
||||
|
||||
- **RAG Architect** - Retrieval patterns for grounding prompts
|
||||
- **Fine-Tuning Expert** - When prompting isn't enough
|
||||
- **LLM Architect** - System-level prompt orchestration
|
||||
Reference in New Issue
Block a user