Prompt Engineering Patterns

Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability.

Do not use this skill when

• •The task is unrelated to prompt engineering patterns
• •You need a different domain or tool outside this scope

Instructions

• •Clarify goals, constraints, and required inputs.
• •Apply relevant best practices and validate outcomes.
• •Provide actionable steps and verification.
• •If detailed examples are required, open resources/implementation-playbook.md.

Use this skill when

• •Designing complex prompts for production LLM applications
• •Optimizing prompt performance and consistency
• •Implementing structured reasoning patterns (chain-of-thought, tree-of-thought)
• •Building few-shot learning systems with dynamic example selection
• •Creating reusable prompt templates with variable interpolation
• •Debugging and refining prompts that produce inconsistent outputs
• •Implementing system prompts for specialized AI assistants

Core Capabilities

1. Few-Shot Learning

• •Example selection strategies (semantic similarity, diversity sampling)
• •Balancing example count with context window constraints
• •Constructing effective demonstrations with input-output pairs
• •Dynamic example retrieval from knowledge bases
• •Handling edge cases through strategic example selection

2. Chain-of-Thought Prompting

• •Step-by-step reasoning elicitation
• •Zero-shot CoT with "Let's think step by step"
• •Few-shot CoT with reasoning traces
• •Self-consistency techniques (sampling multiple reasoning paths)
• •Verification and validation steps

3. Prompt Optimization

• •Iterative refinement workflows
• •A/B testing prompt variations
• •Measuring prompt performance metrics (accuracy, consistency, latency)
• •Reducing token usage while maintaining quality
• •Handling edge cases and failure modes

4. Template Systems

• •Variable interpolation and formatting
• •Conditional prompt sections
• •Multi-turn conversation templates
• •Role-based prompt composition
• •Modular prompt components

5. System Prompt Design

• •Setting model behavior and constraints
• •Defining output formats and structure
• •Establishing role and expertise
• •Safety guidelines and content policies
• •Context setting and background information

Quick Start

from prompt_optimizer import PromptTemplate, FewShotSelector

# Define a structured prompt template
template = PromptTemplate(
    system="You are an expert SQL developer. Generate efficient, secure SQL queries.",
    instruction="Convert the following natural language query to SQL:\n{query}",
    few_shot_examples=True,
    output_format="SQL code block with explanatory comments"
)

# Configure few-shot learning
selector = FewShotSelector(
    examples_db="sql_examples.jsonl",
    selection_strategy="semantic_similarity",
    max_examples=3
)

# Generate optimized prompt
prompt = template.render(
    query="Find all users who registered in the last 30 days",
    examples=selector.select(query="user registration date filter")
)

Key Patterns

Progressive Disclosure

Start with simple prompts, add complexity only when needed:

1. •

   Level 1: Direct instruction

   • •"Summarize this article"
2. •

   Level 2: Add constraints

   • •"Summarize this article in 3 bullet points, focusing on key findings"
3. •

   Level 3: Add reasoning

   • •"Read this article, identify the main findings, then summarize in 3 bullet points"
4. •

   Level 4: Add examples

   • •Include 2-3 example summaries with input-output pairs

Instruction Hierarchy

[System Context] → [Task Instruction] → [Examples] → [Input Data] → [Output Format]

Error Recovery

Build prompts that gracefully handle failures:

• •Include fallback instructions
• •Request confidence scores
• •Ask for alternative interpretations when uncertain
• •Specify how to indicate missing information

Best Practices

1. •Be Specific: Vague prompts produce inconsistent results
2. •Show, Don't Tell: Examples are more effective than descriptions
3. •Test Extensively: Evaluate on diverse, representative inputs
4. •Iterate Rapidly: Small changes can have large impacts
5. •Monitor Performance: Track metrics in production
6. •Version Control: Treat prompts as code with proper versioning
7. •Document Intent: Explain why prompts are structured as they are

Common Pitfalls

• •Over-engineering: Starting with complex prompts before trying simple ones
• •Example pollution: Using examples that don't match the target task
• •Context overflow: Exceeding token limits with excessive examples
• •Ambiguous instructions: Leaving room for multiple interpretations
• •Ignoring edge cases: Not testing on unusual or boundary inputs

Integration Patterns

With RAG Systems

# Combine retrieved context with prompt engineering
prompt = f"""Given the following context:
{retrieved_context}

{few_shot_examples}

Question: {user_question}

Provide a detailed a