Part 13 — Prompt Engineering: The Art of Talking to AI

When ChatGPT gives you a bad answer, 90% of the time it's not the AI's fault — it's the prompt. The exact same model can give you a brilliant, actionable response or a vague, useless one. The only difference is how you asked. This isn't about magic words; it's about understanding how the model "reads" your message and structuring requests to match.

The Signal-to-Noise Problem

When a model receives your message, it processes the entire context and predicts the most likely helpful continuation. That prediction's quality depends entirely on how much useful signal you provided. Every ambiguity is a place where the model has to guess — and guessing means variance, which means inconsistency.

The model isn't "smarter" with the second prompt — it just has more signal to work with.

The Two-Layer System

If you're building an AI application and not using system prompts, you're leaving most of the model's capability on the table. Compare:

Weak:   "You are a helpful AI assistant."
        → says nothing; the model still guesses domain, audience, format, detail.

Strong: "You are a technical advisor specializing in wearable devices for 2026.
         Always respond in casual English. Include the price with every recommendation.
         If you're not sure, say 'I'm not certain' instead of guessing.
         Keep responses under 200 words unless asked for more detail."
        → a complete specification. Every response is consistent and relevant.

The Five Essential Techniques

Technique 1: Be Specific

The single most impactful technique — replace vague descriptions with precise specs:

Before sending, ask: have I specified the topic precisely, the scope (include/exclude), the purpose (what I'll do with it), and the constraints (length, format, audience)?

Technique 2: Few-Shot Examples

Instead of describing the format in words, show it once:

Example:
Name: Samsung Galaxy Ring v2
Description: A lightweight smart ring (2.8g) that tracks sleep and health 24/7.
No charging for 10 days. Priced at $349.

Now write a description for:
Name: Ray-Ban Meta Ultra
→ "A premium smart glasses frame (48g) with a 48MP camera and real-time
   translation in 40 languages. Designed for all-day wear. Priced at $549."

The model learned the pattern — 3 sentences, parenthetical weight, end with price — from one example. Few-shot shines for consistent generation, custom JSON/XML, domain-specific style, and classification.

Technique 3: Chain-of-Thought (CoT)

For complex reasoning, asking the model to "think step by step" gives it room in the context window to work through the problem before committing to an answer:

A 2022 Google paper showed that adding "Let's think step by step" raised accuracy on math word problems from 17.7% to 78.7% — a 4× improvement with no model change. Use CoT for multi-step math/logic, multi-variable decisions, debugging, and strategic trade-offs.

Technique 4: Role Assignment

Assigning a role activates domain knowledge, sets tone, and calibrates assumed expertise. Same question, three roles:

• Expert for a beginner: "You are a tech expert with 20 years in wearables. The user is a complete beginner — use simple language and everyday analogies."
• Peer for a professional: "You are a senior ML engineer. The user is debugging a production issue — be technical, concise, assume PyTorch/CUDA familiarity."
• Domain specialist: "You are a legal advisor for UAE tech-startup formation. Reference relevant law; always recommend consulting a licensed attorney."

A good role names the persona, the domain (not just "expert" — expert in what), the audience, and the constraints.

Technique 5: Output Format Specification

Telling the model exactly what format you need eliminates post-processing — critical when output feeds other code. Specify a structured template, strict JSON ("Return a valid JSON object with fields name (string), price_usd (number), pros (array, max 3). No other text."), or a markdown table with named columns and a row count.

Combining All 5: The Production RAG Template

In production RAG (next article), you combine all five into one prompt:

def rag_query(user_question: str, retrieved_documents: str) -> str:
    system_prompt = """You are a specialized technical advisor in consumer electronics.
Rules:
- Answer ONLY based on the retrieved documents below.
- If the info is NOT in the documents, say exactly: "This information is not available in my current data."
- NEVER invent prices, specs, or product names.
- Include the product name and price with every recommendation.
- Rank multiple options from most to least suitable.
- Keep responses under 150 words unless asked for more detail."""   # Role + Format + Constraints

    user_prompt = f"""## Retrieved Product Data:
{retrieved_documents}

## User Question:
{user_question}

## Instructions:                                # Chain-of-Thought ordering
1. Find the relevant products in the data above
2. Identify which best match the question
3. Rank them if multiple options exist
4. State clearly if any requested info is missing"""

    return client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "system", "content": system_prompt},
                  {"role": "user", "content": user_prompt}],
        temperature=0.1,   # low = consistent, factual
        max_tokens=300,
    ).choices[0].message.content

This single function uses Specificity, an implicit Few-Shot format, Chain-of-Thought step ordering, a Role, and a strict output Format — all at once.

Pre-Send Checklist

Quick Reference: When to Use Each Technique

Try It Yourself

Run the same question through a weak vs. strong system prompt, then with and without a CoT trigger, and feel the difference:

from openai import OpenAI
client = OpenAI()
q = "What smart glasses should I buy?"

weak = client.chat.completions.create(model="gpt-4o", max_tokens=150,
    messages=[{"role":"system","content":"You are a helpful assistant."},
              {"role":"user","content":q}])

strong = client.chat.completions.create(model="gpt-4o", max_tokens=150,
    messages=[{"role":"system","content":"You are a 2026 wearables advisor. "
        "For any product, state price, weight, and one key limitation. Rank multiple "
        "recommendations. Keep under 100 words."},
              {"role":"user","content":q}])

print(weak.choices[0].message.content, "\n---\n", strong.choices[0].message.content)

Key Takeaways

Up Next in the Series