Prompt Engineering

Prompt Engineering

Prompt engineering is the art and science of crafting inputs (prompts) to foundation models to elicit the most accurate, relevant, and useful outputs. It is a critical skill for the AIF-C01 exam.

Zero-Shot Prompting

• What: Asking the model to perform a task without providing any examples
• How: Simply describe the task in the prompt and let the model use its pre-trained knowledge
• When to Use:

  • The task is straightforward and well-understood
  • You don't have examples to provide
  • You're testing the model's baseline capability
• Strengths:

  • Simplest approach — no data preparation needed
  • Works well for common, well-defined tasks
• Limitations:

  • May not produce desired format or style
  • Less accurate for domain-specific or nuanced tasks

Example:

Few-Shot Prompting (One-Shot, Single-Shot)

• What: Providing the model with one or more examples of the desired input-output behavior before asking it to perform the task
• Variants:

  • One-Shot (Single-Shot): Provide exactly one example
  • Few-Shot: Provide 2-6 examples (typically 3-5)
• How: Include example input-output pairs in the prompt, followed by the actual query
• When to Use:

  • You need the model to follow a specific format or style
  • The task is domain-specific or uncommon
  • Zero-shot isn't producing acceptable results
• Strengths:

  • Significantly improves accuracy for specific tasks
  • Teaches the model the desired format without fine-tuning
  • Quick to implement — no training required
• Limitations:

  • Uses more tokens (costs more, uses context window)
  • Quality depends on example selection
  • May not generalize to edge cases

Example (Few-Shot):

Chain of Thought (CoT)

• What: Prompting the model to show its reasoning step-by-step before arriving at a final answer
• How: Include instructions like "Think step by step" or provide examples with explicit reasoning chains
• When to Use:

  • Complex reasoning tasks (math, logic, multi-step problems)
  • Tasks requiring analysis before a conclusion
  • When you need to verify the model's reasoning process
• Strengths:

  • Dramatically improves accuracy on complex reasoning tasks
  • Makes the model's logic transparent and verifiable
  • Reduces errors in multi-step problems
• Limitations:

  • Uses more tokens (longer responses)
  • Slower response time
  • May over-explain simple tasks

Example:

Tree of Thoughts

• What: An advanced prompting technique where the model explores multiple reasoning paths simultaneously, evaluates each path, and selects the best one
• How: The model generates multiple possible next steps, evaluates them, and backtracks if a path seems wrong — like a tree search
• When to Use:

  • Highly complex problems with multiple possible approaches
  • Strategic planning and decision-making tasks
  • Tasks where the first approach may not be optimal
• Strengths:

  • Handles complex problems better than linear CoT
  • Can recover from wrong initial reasoning paths
  • More thorough exploration of solution space
• Limitations:

  • Very token-intensive (expensive)
  • Slower response time
  • Overkill for simple tasks
• Relationship to CoT: Tree of Thoughts extends CoT by exploring multiple reasoning branches rather than a single linear chain

Retrieval-Augmented Generation (RAG)

• What: A prompting/architecture pattern that retrieves relevant information from external sources and adds it to the prompt before generation
• How:

  1. Convert user query to embedding
  2. Search vector database for relevant documents
  3. Add retrieved documents to the prompt as context
  4. Model generates response grounded in retrieved information
• When to Use:

  • Model needs access to proprietary/current information
  • You want to reduce hallucinations
  • You need citations/sources for responses
  • Knowledge changes frequently
• Strengths:

  • Grounds responses in factual data
  • No model re-training needed when information changes
  • Can provide source citations
  • Dramatically reduces hallucinations
• Limitations:

  • Quality depends on retrieval accuracy
  • Adds latency (retrieval step)
  • Requires maintaining a knowledge base

Prompt Templates

• What: Pre-defined, reusable prompt structures with placeholder variables that get filled in at runtime
• How: Define a template with variables (e.g.,

  {{context}}

  ,

  {{question}}

  ) and fill them programmatically
• When to Use:

  • Standardize prompt format across an application
  • Ensure consistency in prompt structure
  • Simplify prompt management at scale
• Benefits:

  • Consistency across all invocations
  • Easier to version and manage
  • Separation of prompt structure from content
  • A/B testing different templates

Example:

Best Practices

General Best Practices

1. Be Specific: Clearly state what you want — vague prompts produce vague outputs
2. Provide Context: Give the model relevant background information
3. Specify Format: Tell the model how you want the output structured (JSON, bullets, table)
4. Set Constraints: Define boundaries (word count, language, tone)
5. Use System Prompts: Define the model's role and behavior ("You are a helpful assistant...")
6. Iterate: Start simple, test, and refine the prompt based on outputs

Reducing Hallucinations

• Use RAG to ground responses in factual data
• Include instructions like "Only answer based on the provided context"
• Add "If you don't know, say 'I don't know'" to the prompt
• Use Guardrails contextual grounding checks

Improving Output Quality

• Temperature: Lower values (0.0-0.3) for factual/deterministic tasks; higher values (0.7-1.0) for creative tasks
• Top-P: Control the diversity of token selection
• Max Tokens: Set appropriate limits for response length
• Stop Sequences: Define where the model should stop generating

Prompt Structure