Awesome Prompt Engineering

Home

AI Cheat Sheet

Quick reference for working with LLMs. Copy-paste patterns, parameter settings, and practical formulas.

Contents

• Prompt Patterns
• API Parameters
• Token Estimation
• Model Selection
• Cost Optimization
• Evaluation Metrics
• Common Patterns
• Troubleshooting

Prompt Patterns

Basic Structure

[ROLE/PERSONA]
You are a [role] who [key trait]. Your goal is to [objective].

[CONTEXT]
Background information the model needs.

[TASK]
Specific instruction for what to do.

[FORMAT]
How to structure the output.

[CONSTRAINTS]
What NOT to do or boundaries to respect.

System Prompt Template

You are [role] with expertise in [domain].

Your responsibilities:
- [Primary task]
- [Secondary task]

Guidelines:
- [Behavior 1]
- [Behavior 2]

Constraints:
- Never [prohibited action]
- Always [required action]

Output format: [format specification]

Few-Shot Template

Here are examples of the task:

Example 1:
Input: [example input]
Output: [example output]

Example 2:
Input: [example input]
Output: [example output]

Now complete this:
Input: [actual input]
Output:

Chain-of-Thought Triggers

Output Format Specifiers

# JSON
Respond in JSON format:
{"field1": "value", "field2": "value"}

# Markdown
Use markdown with headers and bullet points.

# XML
Wrap your response in <response></response> tags.

# Structured
Use this exact format:
ANALYSIS: [your analysis]
RECOMMENDATION: [your recommendation]
CONFIDENCE: [high/medium/low]

API Parameters

Temperature Guide

Top-p (Nucleus Sampling)

Common Parameter Combinations

Stop Sequences

# Common stop sequences
stop_sequences = [
    "\n\n",           # Double newline
    "Human:",         # Conversation boundary
    "```",            # End of code block
    "</response>",    # XML tag closure
    "---",            # Section break
]

Token Estimation

Quick Rules of Thumb

Estimation Formulas

# English text
tokens ≈ words × 1.3
tokens ≈ characters / 4

# Code
tokens ≈ characters / 2.5

# Quick estimate
tokens ≈ len(text.split()) * 1.3

Context Window Budgeting

Total Context = System Prompt + Conversation History + Retrieved Context + User Message + Output Buffer

Example for 128K context:
- System prompt: 2,000 tokens
- Conversation history: 10,000 tokens  
- Retrieved context (RAG): 50,000 tokens
- User message: 1,000 tokens
- Output buffer: 4,000 tokens
- Safety margin (10%): 12,800 tokens
─────────────────────────────────
Available for retrieval: ~48,200 tokens

Model Context Limits (January 2026)

Model Selection

Decision Matrix

Pricing Quick Reference (per 1M tokens, approximate)

Prices change frequently — verify current rates

Cost Optimization

Strategies

Prompt Caching Pattern

# Structure prompts with static content first
prompt = f"""
{STATIC_SYSTEM_PROMPT}      # Cached
{STATIC_EXAMPLES}           # Cached
{STATIC_INSTRUCTIONS}       # Cached
---
{dynamic_user_input}        # Not cached
"""

Cost Estimation Formula

cost = (input_tokens / 1_000_000 * input_price) + 
       (output_tokens / 1_000_000 * output_price)

# Example: GPT-4o, 2000 input, 500 output
cost = (2000 / 1_000_000 * 2.50) + (500 / 1_000_000 * 10.00)
cost = $0.005 + $0.005 = $0.01 per request

Evaluation Metrics

Classification Metrics (for LLM outputs)

Generation Quality Metrics

RAG-Specific Metrics

LLM-as-Judge Template

You are evaluating an AI response on a scale of 1-5.

Criteria:
- Accuracy: Is the information correct?
- Completeness: Does it fully address the question?
- Clarity: Is it well-organized and easy to understand?
- Relevance: Does it stay on topic?

Response to evaluate:
{response}

Original question:
{question}

Provide scores for each criterion and an overall score with brief justification.

Common Patterns

RAG Pattern

# 1. Embed query
query_embedding = embed(user_query)

# 2. Retrieve relevant chunks
chunks = vector_db.search(query_embedding, top_k=5)

# 3. Construct prompt
prompt = f"""
Use the following context to answer the question.
If the context doesn't contain the answer, say so.

Context:
{format_chunks(chunks)}

Question: {user_query}

Answer:
"""

# 4. Generate response
response = llm.generate(prompt)

ReAct Agent Pattern

Thought: I need to [reasoning about what to do]
Action: tool_name(param1="value1", param2="value2")
Observation: [result from tool]
Thought: Based on this, I should [next reasoning]
Action: another_tool(param="value")
Observation: [result]
Thought: I now have enough information
Answer: [final response to user]

Tool Definition (OpenAI Format)

tools = [{
    "type": "function",
    "function": {
        "name": "search_database",
        "description": "Search the product database for items",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Search query"
                },
                "category": {
                    "type": "string",
                    "enum": ["electronics", "clothing", "home"],
                    "description": "Product category filter"
                },
                "max_results": {
                    "type": "integer",
                    "default": 10
                }
            },
            "required": ["query"]
        }
    }
}]

Retry with Exponential Backoff

import time
import random

def call_with_retry(func, max_retries=5, base_delay=1):
    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError:
            if attempt == max_retries - 1:
                raise
            delay = base_delay * (2 ** attempt) + random.uniform(0, 1)
            time.sleep(delay)

Troubleshooting

Common Issues and Fixes

Prompt Debugging Checklist

□ Is the instruction clear and unambiguous?
□ Is there an example of the expected output?
□ Are constraints explicitly stated?
□ Is the most important instruction near the end?
□ Is the context relevant and not too long?
□ Are delimiters used to separate sections?
□ Is the output format specified?
□ Are edge cases addressed?

Error Messages Quick Reference

Quick Reference Cards

Prompt Engineering Principles

1. Be specific, not vague
2. Show, don't just tell (use examples)
3. Structure with clear sections
4. Put critical instructions last
5. Specify what NOT to do
6. Request step-by-step for complex tasks
7. Define output format explicitly
8. Test with edge cases

Token-Saving Tips

1. Remove redundant phrases ("I want you to", "Please")
2. Use abbreviations in system prompts
3. Compress examples to minimum needed
4. Summarize conversation history
5. Use structured formats over prose
6. Cache static prompt components

Notes

This cheat sheet is maintained for quick reference. For deeper explanations, see:

• Deep Learning Guide — Conceptual understanding
• Advanced Prompting — Detailed techniques
• AI Tools — Tool recommendations

Feedback and suggestions are welcome!

Last updated: January 2026