Prompt Engineering: Mastering LLM Interactions

# Bad prompt
prompt = "Write about AI"

# Good prompt with structure
system_message = """You are an expert technical writer specializing in AI and software development.
Your writing is clear, accessible, and well-structured.
Always use markdown formatting with proper headings."""

user_message = """Write a 500-word article about AI Engineering that:
1. Defines AI Engineering clearly
2. Explains 3 key responsibilities
3. Lists essential skills
4. Provides practical examples

Target audience: Software developers considering a career change.
Tone: Professional but approachable.
Format: Markdown with H2 headings for each section."""

# Using with OpenAI API
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": system_message},
        {"role": "user", "content": user_message}
    ],
    temperature=0.7,
    max_tokens=1000
)

Structured prompts with clear instructions, context, and format specifications produce much better results. The system message sets the tone and behavior.

# Few-shot example: Data extraction
prompt = """Extract key information from product reviews:

Review: "I bought this laptop last month. It's fast, has great battery life, and the screen is amazing. However, it's quite expensive at $1,299."
Extracted: {
  "product": "laptop",
  "purchase_time": "last month",
  "positives": ["fast", "great battery life", "amazing screen"],
  "negatives": ["expensive"],
  "price": "$1,299"
}

Review: "This phone camera is incredible! Photos look professional. The only downside is the battery drains quickly."
Extracted: {
  "product": "phone",
  "positives": ["incredible camera", "professional photos"],
  "negatives": ["battery drains quickly"]
}

Review: "Great headphones, comfortable for long sessions. Sound quality is excellent. Worth the $199 price tag."
Extracted:"""

# Few-shot example: Code generation
prompt = """Generate Python functions following these patterns:

Example 1:
Input: Create a function that calculates factorial
Output:
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

Example 2:
Input: Create a function that finds the maximum in a list
Output:
def find_max(numbers):
    if not numbers:
        return None
    return max(numbers)

Example 3:
Input: Create a function that reverses a string
Output:"""

Few-shot learning is powerful for tasks requiring specific formats or styles. The examples teach the model the pattern you want.

# Chain-of-thought for problem solving
prompt = """Solve this problem step by step, showing your reasoning:

Problem: A company has 3 products. Product A sells for $50, Product B for $75, and Product C for $100.
Last month, they sold 20 units of A, 15 units of B, and 10 units of C.
What was their total revenue, and which product contributed the most?

Let's solve this step by step:

1. Calculate revenue for each product:
   - Product A: 20 units × $50 = $1,000
   - Product B: 15 units × $75 = $1,125
   - Product C: 10 units × $100 = $1,000

2. Calculate total revenue:
   Total = $1,000 + $1,125 + $1,000 = $3,125

3. Identify highest contributor:
   Product B contributed $1,125, which is the highest.

Answer: Total revenue was $3,125. Product B contributed the most."""

# Chain-of-thought for code review
prompt = """Review this code and identify issues. Think through it step by step:

Code:
def calculate_total(items):
    total = 0
    for item in items:
        total += item.price
    return total

Step-by-step analysis:
1. Function purpose: Calculate sum of item prices
2. Check logic: Iterates through items, adds prices - looks correct
3. Check edge cases: What if items is empty? Function returns 0, which is correct
4. Check error handling: No validation - what if item.price doesn't exist?
5. Potential issues:
   - No validation that items is a list/iterable
   - No handling if item.price is missing or not a number
   - No type hints for clarity

Issues found:
- Missing input validation
- No error handling for missing price attribute
- No type hints"""

Chain-of-thought prompting improves accuracy on reasoning tasks by making the model's thinking process explicit. This is especially useful for complex analysis.

# Role-playing pattern
system_message = """You are a senior software engineer conducting a code review.
You are thorough, constructive, and focus on:
- Code quality and best practices
- Performance optimizations
- Security concerns
- Maintainability

Provide feedback in a professional, helpful tone."""

# Template-based prompt
def create_review_prompt(code: str, focus_areas: list) -> str:
    return f"""Review this code focusing on: {', '.join(focus_areas)}

Code:
{code}

Provide:
1. Overall assessment
2. Specific issues found
3. Suggestions for improvement
4. Security considerations"""

# Multi-step reasoning
def analyze_code_with_steps(code: str):
    # Step 1: Initial analysis
    step1 = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
            "role": "user",
            "content": f"Analyze this code and identify potential issues:

{code}"
        }]
    )
    
    issues = step1.choices[0].message.content
    
    # Step 2: Deep dive into issues
    step2 = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
            "role": "user",
            "content": f"Here are issues found in code:
{issues}

Provide detailed solutions for each issue."
        }]
    )
    
    return {
        "issues": issues,
        "solutions": step2.choices[0].message.content
    }

# Self-correction pattern
prompt = """Write a function to calculate fibonacci numbers.

After writing it, review your code and:
1. Check for correctness
2. Identify any edge cases not handled
3. Suggest optimizations
4. Provide an improved version if needed"""

Advanced patterns like role-playing, templates, and multi-step reasoning enable complex AI applications. These patterns are used in production systems.

# Prompt testing framework
import openai
from typing import List, Dict

class PromptTester:
    def __init__(self, model: str = "gpt-3.5-turbo"):
        self.model = model
        self.test_cases = []
    
    def add_test_case(self, input_text: str, expected_aspects: List[str]):
        """Add a test case with expected aspects to check."""
        self.test_cases.append({
            "input": input_text,
            "expected": expected_aspects
        })
    
    def test_prompt(self, prompt_template: str) -> Dict:
        """Test a prompt template against all test cases."""
        results = {
            "passed": 0,
            "failed": 0,
            "details": []
        }
        
        for test_case in self.test_cases:
            # Format prompt with test input
            prompt = prompt_template.format(input=test_case["input"])
            
            # Get response
            response = openai.ChatCompletion.create(
                model=self.model,
                messages=[{"role": "user", "content": prompt}]
            )
            
            output = response.choices[0].message.content
            
            # Check if output contains expected aspects
            passed = all(aspect.lower() in output.lower() for aspect in test_case["expected"])
            
            if passed:
                results["passed"] += 1
            else:
                results["failed"] += 1
            
            results["details"].append({
                "input": test_case["input"],
                "output": output,
                "passed": passed
            })
        
        return results

# Usage
tester = PromptTester()
tester.add_test_case(
    "Extract info from: John Doe, age 30, email john@example.com",
    ["John Doe", "30", "john@example.com"]
)

prompt_template = """Extract name, age, and email from: {input}"""

results = tester.test_prompt(prompt_template)
print(f"Passed: {results['passed']}, Failed: {results['failed']}")

Systematic testing helps optimize prompts. Track what works and what doesn't, then iterate. This is how professional AI Engineers refine their prompts.