What is Prompt Engineering?

What Is a Prompt?

A prompt is the input you send to an LLM to communicate a task. It may be a question, instruction, conversation, document, examples, or a combination of these.

Prompt Engineering Is an Iteration Loop

Good prompts usually come from testing, not from guessing the perfect sentence on the first attempt.

Engineering mindset: test a prompt on several representative inputs. One impressive response does not prove a prompt is reliable.

Vague Prompt vs. Engineered Prompt

Imagine an application that summarizes customer incidents.

Summarize this.

You are a customer-support assistant.
Summarize the incident in 3 bullets.
Include: problem, customer impact, and duration.
Do not invent facts.

The Anatomy of a Useful Prompt

Not every task needs every component, but these building blocks are useful when a task requires predictable behavior.

Example: Improve a Python Error Prompt

Compare these two requests when you want an LLM to help debug code.

Another useful pattern is to specify the audience. “Explain embeddings.” becomes “Explain embeddings to a Python beginner using one shopping-search example and no equations.”

Run a Real Prompt Experiment

Use the same input with two different instructions. The goal is not to expect identical output every time, but to see whether the engineered prompt makes the desired requirements clearer.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
text = "Our API returned 503 errors for 20 minutes. Checkout requests failed."

def run_prompt(instruction):
    response = client.responses.create(
        model="gpt-5-mini",
        input=[
            {"role": "system", "content": instruction},
            {"role": "user", "content": text},
        ],
    )
    return response.output_text

vague = "Summarize this."
engineered = "Summarize in 3 bullets. Include problem, impact, and duration. Do not add facts."

print(run_prompt(vague))
print(run_prompt(engineered))

Important: keep API keys in environment variables. Model outputs can vary, so evaluate whether requirements are met instead of comparing exact wording.

Context + Instructions

Context tells the model what information is available. Instructions tell it how to use that information.

Output Format Is Part of the Design

If another program must consume the answer, define a predictable structure and validate it in your application.

The ticket looks like billing and seems urgent.

{
  "category": "billing",
  "priority": "high"
}

Build a Reusable Prompt Template

Templates keep the instructions stable while application data changes.

def build_prompt(customer_message, policy):
    return f"""You are a customer-support assistant.
Use only the policy below.
Do not invent information.
If the policy is insufficient, say so.

POLICY:
{policy}

CUSTOMER MESSAGE:
{customer_message}

OUTPUT:
Return exactly 3 bullet points:
1. Issue
2. Policy-based answer
3. Next step
"""

print(build_prompt(
    "Can I return my order after 20 days?",
    "Unused products can be returned within 30 days with proof of purchase.",
))

Later, the policy variable can come from a database or RAG retrieval step. The prompt template remains the reusable instruction layer.

Test Prompts Like an Engineer

Change one meaningful variable at a time and compare several representative inputs.

Common Mistakes

Mini-Project: Support Ticket Classifier

Build a small workflow that classifies support messages into billing, technical, shipping, or account.