Prompt Engineering 2025: Getting Maximum Performance from Modern LLMs

model capability x prompt quality = output quality

# Bad system prompt (how most people start)
bad_prompt = "You are a helpful assistant."
# Problem: so vague the model doesn't know what to do

# Good system prompt using the COSTAR framework
good_prompt = """
## Role
You are a senior customer service specialist at TechCorp.

## Context
TechCorp sells B2B SaaS software for HR management.
Customers are typically HR managers at companies with 100-5,000 employees.

## Objective
Help customers resolve issues and answer product questions.
Escalate billing issues to finance@techcorp.com.

## Style
- Professional but warm English
- Keep responses under 150 words
- Always end with a follow-up question

## Tone
Professional, empathetic, solution-oriented

## Audience
HR managers, often non-technical

## Response Format
1. Acknowledge the issue
2. Provide solution (step-by-step if needed)
3. Close with: "Is there anything else I can help you with?"
"""

# Zero-shot (no examples)
zero_shot = """
Classify the sentiment of this review: 'Delivery took way too long'
"""
# Works, but output format and consistency may vary

# Few-shot (with examples)
few_shot = """
Classify review sentiment as: positive / negative / neutral

Review: "Absolutely love this product!" -> positive
Review: "Shipping was slow but the product is great" -> neutral
Review: "Complete junk, want a refund" -> negative
Review: "Nothing special for the price" -> neutral

Review: "Delivery took way too long" -> """
# Output: negative (much more reliably structured)

# Without CoT (unreliable)
no_cot = """
A train travels 120km in 2 hours, then 180km in 3 hours.
What is the average speed?
"""
# LLM might compute (120/2 + 180/3) / 2 = 60 incorrectly using the wrong formula

# With CoT (reliable)
with_cot = """
A train travels 120km in 2 hours, then 180km in 3 hours.
What is the average speed?

Let me think through this step by step:
"""
# LLM: "Total distance = 120 + 180 = 300km.
#        Total time = 2 + 3 = 5 hours.
#        Average speed = 300 / 5 = 60 km/h"
# Correct!

# Zero-shot CoT (simplest form — often works just as well)
zero_shot_cot = """
Problem: [complex reasoning problem]
Solution: Let's think step by step.
"""

import json
from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

# Method 1: JSON Mode (simple cases)
response = client.chat.completions.create(
    model="gpt-4o",
    response_format={"type": "json_object"},
    messages=[{
        "role": "user",
        "content": """
        Extract product info from this text and return JSON:
        "iPhone 15 Pro Max, 256GB, Space Black, retail price $1,199"

        Return: {"name": ..., "storage": ..., "color": ..., "price_usd": ...}
        """
    }]
)
data = json.loads(response.choices[0].message.content)

# Method 2: Structured Outputs (type-safe, more reliable)
class ProductInfo(BaseModel):
    name: str
    storage: str
    color: str
    price_usd: float

response = client.beta.chat.completions.parse(
    model="gpt-4o-2024-08-06",
    messages=[{
        "role": "user",
        "content": "iPhone 15 Pro Max, 256GB, Space Black, retail price $1,199"
    }],
    response_format=ProductInfo
)
product = response.choices[0].message.parsed
print(product.price_usd)  # 1199.0, guaranteed float type

import anthropic

client = anthropic.Anthropic()

prompt = """
<task>
Summarize the following document.
</task>

<document>
[long document content here]
</document>

<constraints>
- Maximum 3 bullet points
- Each bullet: 1-2 sentences
- Focus on actionable items only
- Replace jargon with plain language
</constraints>

<output_format>
Return as JSON:
{
  "summary_bullets": ["...", "...", "..."],
  "key_action": "Single most important action item"
}
</output_format>
"""

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": prompt}]
)

def create_production_prompt(
    role: str,
    context: str,
    task: str,
    constraints: list[str],
    output_format: str
) -> str:
    constraints_text = "\n".join(f"- {c}" for c in constraints)
    return f"""# Role
{role}

# Context
{context}

# Task
{task}

# Constraints
{constraints_text}

# Output Format
{output_format}"""

# Example usage
prompt = create_production_prompt(
    role="You are a senior copywriter with 10 years of experience targeting Gen Z audiences.",
    context="Client: startup coffee brand 'BREW'. New cold brew product launch.",
    task="Write 3 versions of an Instagram caption.",
    constraints=[
        "Each caption under 50 characters",
        "Include 1-2 emojis",
        "No mention of price or promotions",
        "Do not include hashtags"
    ],
    output_format="Return as JSON array: ['caption1', 'caption2', 'caption3']"
)

# Bad: hardcoded in business logic
def summarize(text):
    prompt = f"Summarize: {text}"  # untracked, untestable
    return call_llm(prompt)

# Good: manage prompts as separate versioned artifacts
class PromptManager:
    def __init__(self):
        self.prompts = {}
        self.active_versions = {}

    def register(self, name: str, version: str, template: str):
        self.prompts[f"{name}_v{version}"] = template

    def get(self, name: str, version: str = None) -> str:
        v = version or self.active_versions.get(name, "1")
        return self.prompts[f"{name}_v{v}"]

    def set_active(self, name: str, version: str):
        self.active_versions[name] = version

pm = PromptManager()
pm.register("summarize", "1", "Summarize: {text}")
pm.register("summarize", "2", "You are a business analyst. Summarize in 3 lines: {text}")
pm.set_active("summarize", "2")

GPT-4o:
- Prefers clear, direct instructions
- Follows Markdown formatting well
- Responds well to "You are a [role]" framing

Claude 3.5/3.7:
- Especially responsive to XML tag structure
- Handles long system prompts well
- Compliant with strong constraints ("you must...", "never...")

Gemini:
- Stronger at multimodal contexts
- Built-in search grounding support

Open-source (Llama, Mistral, etc.):
- Always use the model's specific chat template
- Instruction-following may be weaker than commercial models
- Requires more explicit and specific instructions

1. Set temperature to 0
   -> Get reproducible results for diagnosis

2. Make instructions more specific
   -> "Write it well" -> "Professional tone, active voice, under 50 words"

3. Add output examples (few-shot)
   -> Showing is more effective than describing

4. Specify what NOT to do
   -> Negative constraints reduce failure cases

5. Add chain-of-thought
   -> "Let's think step by step" meaningfully improves complex reasoning

6. Optimize prompt length
   -> Longer isn't always better. Remove what isn't earning its place