Advanced Prompting Techniques - Actionable Summary

Core Principles

Use clear, unambiguous language

❌ Don't: "Think about summarizing this"
✅ Do: "Summarize the following text in 3 bullet points"

Keep instructions concise and direct

❌ Don't: "Could you perhaps, if possible, translate this text that I'm providing"
✅ Do: "Translate this text to French:"

Use strong action verbs

(Analyze, Create, Extract, Summarize, Compare, Generate, Evaluate)

❌ Don't: "Can you look at this data?"
✅ Do: "Analyze this data and identify trends"

Frame as positive instructions, not constraints

❌ Don't: "Don't use technical jargon"
✅ Do: "Explain in simple terms for a general audience"

Iterate and document prompt attempts

❌ Don't: Use first draft without testing
✅ Do: Test → Analyze output → Refine → Document results

Basic Techniques

Start with zero-shot for simple tasks

❌ Don't: Overcomplicate with examples for basic tasks
✅ Do: "What is the capital of France?"

Add one example for specific format/style needs

❌ Don't: Provide multiple examples when one suffices
✅ Do: Show one translation example, then request similar translation

Use 3-5 diverse examples for few-shot prompting

❌ Don't: Use similar or biased examples
✅ Do: Mix positive, negative, and neutral sentiment examples for classification

Randomize class order in classification examples

❌ Don't: All positive examples first, then all negative
✅ Do: Alternate between different classes randomly

Prompt Structure

Set system context at the beginning

❌ Don't: Mix system instructions with user queries
✅ Do: "You are a helpful AI assistant. Always respond politely."

Assign specific roles when needed

❌ Don't: "Write about Rome"
✅ Do: "Act as a travel blogger. Write about Rome's hidden gems"

Use clear delimiters

(Triple backticks, XML tags, dashes)

❌ Don't: Mix instructions with content
✅ Do: <instruction>Summarize this</instruction> <article>[content]</article>

Request structured output explicitly

❌ Don't: "Give me the information"
✅ Do: "Return as JSON with keys: name, date, location"

Reasoning Enhancement

Add "Let's think step by step" for complex problems

❌ Don't: "What's 847293 × 652847?"
✅ Do: "What's 847293 × 652847? Let's think step by step."

Set temperature to 0 for deterministic reasoning

❌ Don't: High temperature for math problems
✅ Do: Temperature=0 for calculations and logic tasks

Ask general principles before specific tasks (Step-Back)

❌ Don't: "Write a detective story"
✅ Do: "What makes a good detective story? Now write one using those principles"

Generate multiple reasoning paths for critical tasks (Self-Consistency)

❌ Don't: Rely on single output for important decisions
✅ Do: Run 3-5 times with higher temperature, take majority vote

Tool Use & Actions

Provide clear tool descriptions with parameters

❌ Don't: "You can search the web"
✅ Do: "Tool: web_search(query: string) - searches for current information"

Use ReAct pattern for multi-step tasks

❌ Don't: Single-shot complex queries
✅ Do: Thought → Action → Observation → loop until complete

Include tool outputs as context for next steps

❌ Don't: Ignore tool results
✅ Do: "Based on search results: [data], now analyze..."

Advanced Optimization

Break complex tasks into sub-tasks

❌ Don't: "Write a complete research paper on AI"
✅ Do: Separate prompts for outline → sections → conclusion

Use RAG for current/specialized information

❌ Don't: Ask about recent events without context
✅ Do: Retrieve relevant docs first, then include as context

Specify target audience explicitly (Persona Pattern)

❌ Don't: "Explain quantum physics"
✅ Do: "Explain quantum physics to a high school student"

Use LLMs to refine your prompts

❌ Don't: Manual trial and error only
✅ Do: "Analyze this prompt and suggest improvements: [prompt]"

Code & Technical Tasks

Specify language and version

❌ Don't: "Write code to sort a list"
✅ Do: "Write Python 3.9 code to sort a list"

Provide context and error messages for debugging

❌ Don't: "Fix this code"
✅ Do: "Fix this Python code giving NameError: [code + traceback]"

Quality Control

Test prompts with edge cases

❌ Don't: Test with ideal inputs only
✅ Do: Test with incomplete, ambiguous, or unusual inputs

Validate structured outputs programmatically

(Use schemas like Pydantic for JSON validation)

❌ Don't: Assume JSON is always valid
✅ Do: Parse and validate with schema enforcement

Save successful prompts in version control

❌ Don't: Keep prompts in chat history only
✅ Do: Store in .txt/.md files in your codebase

Monitor prompt performance with automated tests

❌ Don't: Manual checking only
✅ Do: Create test suites with expected outputs

Update prompts when models change

❌ Don't: Assume prompts work across all versions
✅ Do: Re-test and adjust for new model releases

Quick Reference - Action Verbs for Prompting

Analysis: Analyze, Evaluate, Assess, Compare, Contrast, Examine
Creation: Generate, Create, Produce, Design, Develop, Compose
Extraction: Extract, Identify, Find, Locate, Retrieve, Isolate
Transformation: Convert, Transform, Translate, Reformat, Adapt
Summarization: Summarize, Condense, Abstract, Outline, Highlight
Organization: Categorize, Classify, Sort, Group, Organize, Structure

Template Examples

Basic Task Template

Role: [Optional specific role]
Task: [Clear action verb + specific requirement]
Input: [Clearly delimited content]
Output: [Expected format/structure]

Complex Reasoning Template

Context: [Background information]
Task: [Main objective]
Steps:
1. [First sub-task]
2. [Second sub-task]
3. [Final synthesis]
Format: [Output requirements]

Tool-Using Template

Available Tools:
- tool_name(parameters): description

Task: [Complex query requiring tools]
Process: Use ReAct pattern
Expected: [Final deliverable]