Skip to content

Advanced Prompting Techniques

This guide presents 58 research-backed prompting techniques mapped to Instructor implementations. Based on The Prompt Report by Learn Prompting which analyzed over 1,500 academic papers on prompting.

Zero-Shot

These techniques improve model performance without examples:

Technique Description Use Case
Emotional Language Add emotional tone to prompts Creative writing, empathetic responses
Role Assignment Give the model a specific role Expert knowledge, specialized perspectives
Style Definition Specify writing style Content with particular tone or format
Prompt Refinement Automatic prompt optimization Iterative improvement of results
Perspective Simulation Have the model adopt viewpoints Multiple stakeholder analysis
Ambiguity Clarification Identify and resolve unclear aspects Improving precision of responses
Query Repetition Ask model to restate the task Better task understanding
Follow-Up Generation Generate clarifying questions Deep exploration of topics

Few-Shot

Techniques for effectively using examples in prompts:

Technique Description Use Case
Example Generation Automatically create examples Domains with limited example data
Example Ordering Optimal sequencing of examples Improved pattern recognition
KNN Example Selection Choose examples similar to query Domain-specific accuracy
Vote-K Selection Advanced similarity-based selection Complex pattern matching

Thought Generation

Methods to encourage human-like reasoning in models:

Zero-Shot Reasoning

Technique Description Use Case
Analogical CoT Generate reasoning using analogies Complex problem-solving
Step-Back Prompting Consider higher-level questions first Scientific and abstract reasoning
Thread of Thought Encourage step-by-step analysis Detailed explanation generation
Tabular CoT Structure reasoning in table format Multi-factor analysis

Few-Shot Reasoning

Technique Description Use Case
Active Prompting Annotate uncertain examples Improved accuracy on edge cases
Auto-CoT Choose diverse examples Broad domain coverage
Complexity-Based CoT Use complex examples Challenging problem types
Contrastive CoT Include correct and incorrect cases Error detection and avoidance
Memory of Thought Use high-certainty examples Reliability in critical applications
Uncertainty-Routed CoT Select the most certain reasoning path Decision-making under uncertainty
Prompt Mining Generate templated prompts Efficient prompt engineering

Ensembling

Techniques for combining multiple prompts or responses:

Technique Description Use Case
Consistent, Diverse Sets Build consistent example sets Stable performance
Batched In-Context Examples Efficient example batching Performance optimization
Step Verification Validate individual steps Complex workflows
Maximizing Mutual Information Information theory optimization Information-dense outputs
Meta-CoT Merge multiple reasoning chains Complex problem-solving
Specialized Experts Use different "expert" prompts Multi-domain tasks
Self-Consistency Choose most consistent reasoning Logical accuracy
Universal Self-Consistency Domain-agnostic consistency General knowledge tasks
Task-Specific Selection Choose examples per task Specialized domain tasks
Prompt Paraphrasing Use variations of the same prompt Robust outputs

Self-Criticism

Methods for models to verify or improve their own responses:

Technique Description Use Case
Chain of Verification Generate verification questions Fact-checking, accuracy
Self-Calibration Ask if answer is correct Confidence estimation
Self-Refinement Auto-generate feedback and improve Iterative improvement
Self-Verification Score multiple solutions Quality assessment
Reverse CoT Reconstruct the problem Complex reasoning verification
Cumulative Reasoning Generate possible steps Thorough analysis

Decomposition

Techniques for breaking down complex problems:

Technique Description Use Case
Functional Decomposition Implement subproblems as functions Modular problem-solving
Faithful CoT Use natural and symbolic language Mathematical reasoning
Least-to-Most Solve increasingly complex subproblems Educational applications
Plan and Solve Generate a structured plan Project planning
Program of Thought Use code for reasoning Algorithmic problems
Recursive Thought Recursively solve subproblems Hierarchical problems
Skeleton of Thought Generate outline structure Writing, planning
Tree of Thought Search through possible paths Decision trees, exploration

Implementation with Instructor

All these prompting techniques can be implemented with Instructor by:

  1. Defining appropriate Pydantic models that capture the expected structure
  2. Incorporating the prompting technique in your model docstrings or field descriptions
  3. Using the patched LLM client with your response model
import instructor
from openai import OpenAI
from pydantic import BaseModel, Field

# Example implementing Chain of Thought with a field
class ReasonedAnswer(BaseModel):
    """Answer the following question with detailed reasoning."""

    chain_of_thought: str = Field(
        description="Step-by-step reasoning process to solve the problem"
    )
    final_answer: str = Field(
        description="The final conclusion after reasoning"
    )

client = instructor.from_openai(OpenAI())

response = client.chat.completions.create(
    model="gpt-4",
    response_model=ReasonedAnswer,
    messages=[
        {"role": "user", "content": "What is the cube root of 27?"}
    ]
)

print(f"Reasoning: {response.chain_of_thought}")
print(f"Answer: {response.final_answer}")

References

* Based on The Prompt Report: A Systematic Survey of Prompting Techniques