Prompt Engineering — Advanced Techniques for LLMs in 2026

from openai import OpenAI
 
client = OpenAI()
 
# Vague prompt — unpredictable output
bad_prompt = "Tell me about transformers"
 
# Precise prompt — reliable output
good_prompt = """You are a senior ML engineer writing documentation.
 
Explain the transformer architecture in exactly 3 paragraphs:
1. Core attention mechanism
2. Encoder-decoder structure
3. Why transformers replaced RNNs
 
Use technical but accessible language for developers familiar with deep learning."""
 
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": good_prompt}],
    temperature=0.3
)
print(response.choices[0].message.content)

def build_few_shot_prompt(task_description: str, examples: list[dict], query: str) -> str:
    """Construct a few-shot prompt from examples."""
    lines = [task_description, ""]
    for ex in examples:
        lines.append(f"Input: {ex['input']}")
        lines.append(f"Output: {ex['output']}")
        lines.append("")
    lines.append(f"Input: {query}")
    lines.append("Output:")
    return "\n".join(lines)
 
examples = [
    {"input": "The food was cold and service was slow.", "output": "negative"},
    {"input": "Best meal I've had in years!", "output": "positive"},
    {"input": "It was fine, nothing special.", "output": "neutral"},
]
 
prompt = build_few_shot_prompt(
    "Classify customer review sentiment as positive, negative, or neutral.",
    examples,
    "Fast delivery but the packaging was damaged."
)

import json
 
def extract_structured_data(text: str) -> dict:
    """Extract person info as structured JSON."""
    prompt = f"""Extract information from the text and return ONLY valid JSON.
 
Schema:
{{
  "name": "string",
  "age": "integer or null",
  "skills": ["string"],
  "location": "string or null"
}}
 
Text: {text}
 
JSON output:"""
 
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        response_format={"type": "json_object"}
    )
 
    return json.loads(response.choices[0].message.content)
 
result = extract_structured_data(
    "Maria Chen, 34, is a Python developer and ML engineer based in Seattle."
)
print(result)
# {"name": "Maria Chen", "age": 34, "skills": ["Python", "ML"], "location": "Seattle"}

system_prompts = {
    "code_reviewer": """You are a staff-level software engineer with 15 years of experience.
Review code for: correctness, performance, security, readability, and edge cases.
Structure feedback as: Critical Issues, Improvements, Positives.""",
 
    "technical_writer": """You are a technical writer specializing in developer documentation.
Write in second person, active voice, and present tense.
Include: overview, parameters, return values, and a working code example.""",
 
    "security_auditor": """You are a CISO and penetration tester.
Analyze systems for OWASP Top 10 vulnerabilities, data exposure, and authentication weaknesses.
Rate each finding: Critical, High, Medium, Low."""
}
 
def get_expert_response(role: str, query: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_prompts[role]},
            {"role": "user", "content": query}
        ],
        temperature=0.2
    )
    return response.choices[0].message.content

# Deterministic output for extraction and classification
def classify(text: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": f"Classify as spam or not_spam: {text}"}],
        temperature=0,       # Fully deterministic
        max_tokens=10,       # Short output only
        seed=42              # Reproducible across runs
    )
    return response.choices[0].message.content.strip()
 
# Creative output for writing tasks
def brainstorm(topic: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": f"Generate 10 unique angles on: {topic}"}],
        temperature=1.0,     # High creativity
        top_p=0.95
    )
    return response.choices[0].message.content

def evaluate_prompt(prompt_template: str, test_cases: list[dict]) -> dict:
    """Measure prompt accuracy against labeled test cases."""
    correct = 0
    results = []
 
    for case in test_cases:
        prompt = prompt_template.format(input=case["input"])
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0
        )
        prediction = response.choices[0].message.content.strip().lower()
        expected = case["expected"].lower()
        is_correct = prediction == expected
        correct += int(is_correct)
        results.append({"input": case["input"], "expected": expected,
                         "predicted": prediction, "correct": is_correct})
 
    accuracy = correct / len(test_cases)
    return {"accuracy": accuracy, "results": results}
 
# Compare two prompt variants
v1_accuracy = evaluate_prompt("Sentiment of this review: {input}\nAnswer:", test_cases)
v2_accuracy = evaluate_prompt(
    "You are a sentiment classifier. Return only: positive, negative, or neutral.\nReview: {input}",
    test_cases
)
print(f"V1: {v1_accuracy['accuracy']:.0%}, V2: {v2_accuracy['accuracy']:.0%}")

guardrailed_system = """You are a customer support assistant for an e-commerce platform.
 
DO:
- Answer questions about orders, shipping, and returns
- Provide accurate policy information
- Escalate complex issues politely
 
DO NOT:
- Discuss competitors or make comparisons
- Promise refunds or resolutions you cannot guarantee
- Reveal internal pricing structures or supplier names
- Use filler phrases like "Great question!" or "Certainly!"
 
If a question is outside your scope, say: "I'll connect you with our specialist team."
"""