Prompt Engineering

What is Prompt Engineering?

Prompt engineering is the art and science of designing inputs to large language models to achieve desired outputs. It's a critical skill for effectively using generative AI.

Core Techniques

Zero-shot Prompting

# Zero-shot: Direct instruction without examples
prompt = """Classify the following text as positive, negative, or neutral:

Text: "The movie was absolutely fantastic, I loved every minute!"
Classification:"""

# Output: Positive

Few-shot Prompting

# Few-shot: Providing examples to guide the model
prompt = """Classify the sentiment of these reviews:

Review: "Terrible service, never coming back"
Sentiment: Negative

Review: "Pretty good, exceeded expectations"
Sentiment: Positive

Review: "It was okay, nothing special"
Sentiment: Neutral

Review: "Best purchase I've ever made!"
Sentiment:"""

# Output: Positive

Advanced Techniques

Chain-of-Thought (CoT)

# Chain-of-Thought: Step-by-step reasoning
cot_prompt = """Question: Roger has 5 tennis balls. He buys 2 cans of 3 each. How many does he have now?

Let's think step by step:
1. Roger starts with 5 tennis balls
2. He buys 2 cans, each with 3 balls
3. 2 cans x 3 balls = 6 balls added
4. 5 + 6 = 11 balls total

Answer: 11

Question: The cafeteria had 23 apples. They used 20 for lunch and bought 6 more. How many do they have now?

Let's think step by step:"""

Self-Consistency

import random

def self_consistency(model, prompt, n_samples=5):
    """Generate multiple reasoning paths and vote on the answer."""
    responses = []

    for _ in range(n_samples):
        response = model.generate(
            prompt,
            temperature=0.7,
            do_sample=True
        )
        answer = extract_answer(response)
        responses.append(answer)

    # Majority vote
    from collections import Counter
    vote = Counter(responses).most_common(1)[0][0]
    return vote

Tree-of-Thought

def tree_of_thought(problem, model, depth=3, branching=3):
    """Explore multiple solution paths."""
    root = {"problem": problem, "children": [], "score": 0}

    def expand(node, current_depth):
        if current_depth >= depth:
            return

        for _ in range(branching):
            thought = model.generate(
                f"Consider this approach to: {node['problem']}"
            )
            child = {
                "thought": thought,
                "children": [],
                "score": evaluate_thought(thought, problem)
            }
            node["children"].append(child)
            expand(child, current_depth + 1)

    expand(root, 0)

    # Find best path
    return find_best_path(root)

Prompt Templates

Role-Based Prompting

role_prompt = """You are an expert {role} with {experience} years of experience.

Task: {task}

Requirements:
{requirements}

Provide a detailed response:"""

Structured Output Prompting

structured_prompt = """Analyze the following text and provide output in JSON format:

Text: {text}

Required JSON structure:
{
    "sentiment": "positive/negative/neutral",
    "confidence": 0.0-1.0,
    "key_topics": ["topic1", "topic2"],
    "summary": "brief summary"
}"""

Best Practices

1. Be Specific: Clear, unambiguous instructions
2. Provide Context: Relevant background information
3. Use Delimiters: Separate instructions from content
4. Specify Format: Define output structure
5. Iterate: Test and refine prompts

Summary

Effective prompt engineering significantly impacts model performance. Master these techniques to unlock the full potential of generative AI.

Next: We'll explore in-context learning in depth.