What is Prompt Engineering?

Article

Definition

Prompt engineering is the design of the inputs given to a language model, instructions, context, examples, constraints, and structure, so that the output is correct, consistent, and useful for a specific task.

It is not magic, not "asking nicely," and not the same thing as writing a search query. A good prompt is closer to a small specification document, written for a very literal but very capable collaborator.

Why it still matters in 2026

Every release cycle brings the same claim: "models got smarter, so prompts matter less." It is true for casual chat, GPT-5 and Claude Sonnet 4.5 are forgiving of vague questions. It is false for everything else.

In production we still see:

- A two-line prompt rewrite take a JSON extraction task from 71% to 96% accuracy. - A single misplaced example flip an agent from "stops at step 3" to "completes 18 steps reliably." - One tag in a system prompt cutting hallucinated citations by 80%.

At scale, "the model is the program and the prompt is the source code" is no longer a metaphor. It’s the architecture.

Anatomy of a prompt

A production prompt typically has six parts:

1. Role, who the model is in this conversation. 2. Task, what it must do. 3. Context, relevant facts, documents, or prior turns. 4. Examples, input/output pairs that show the pattern. 5. Constraints, what must be true of the output (length, format, tone, what to avoid). 6. Output format, exact structure required (JSON schema, headings, XML tags).

Missing any one of these is the most common cause of poor results. Missing two is fatal.

Fundamentals

1. Be specific

"Write me a marketing email" is a wish. "Write a 120-word email to existing customers announcing our new pricing tier, friendly tone, ending with a one-sentence CTA to /pricing" is a prompt.

2. Show, don’t tell

Two examples beat two paragraphs of description. If you can’t show an example, your specification is probably ambiguous.

3. Separate instructions from content

Use clear delimiters, XML tags work best with Claude, JSON or triple-backticks with GPT-5. This prevents the model from confusing your instructions with the document you’re asking it to process.

``` <instructions> Summarize the article in 3 bullet points. </instructions>

<article> ... the article text ... </article> ```

4. Constrain the output

If you want JSON, say so and give a schema. If you want a specific length, give a number. Modern models almost always honor explicit constraints; they guess when you don’t give any.

Core techniques

Zero-shot prompting

Ask without examples. Works for general tasks the model has seen a million times in training. Falls apart on anything domain-specific.

Few-shot prompting

Give 2-5 input/output examples before the real task. Still the highest ROI technique in 2026. Three rules:

- Examples must match the format you want back exactly. - Cover the edge cases you care about, not just the easy ones. - More than 7 examples usually hurts, pick the most distinguishing.

Chain-of-thought (CoT)

Ask the model to think step by step before producing an answer. Frontier models do this internally now, but explicit CoT still helps on smaller models and complex multi-step problems. The 2026 variant is structured CoT, telling the model exactly which steps to take, not just "think step by step."

Role prompting

"You are a senior tax accountant with 20 years of US small-business experience." This works less than it used to on frontier models, but still measurably nudges tone and depth. Use it for tone, not for bypassing limitations.

Output formatting with JSON schema or XML

For anything programmatic, force structured output. Both OpenAI and Anthropic now support strict JSON-schema mode, when available, use it instead of asking nicely.

Retrieval-augmented generation (RAG)

When the answer depends on private or fresh data, retrieve it and put it in the prompt. RAG is not a competitor to prompt engineering, it is prompt engineering, with the context section filled by a retriever.

Advanced patterns

Self-consistency

Run the same prompt N times with a non-zero temperature, then take the majority answer. Doubles cost, often halves error rate on reasoning tasks. Use sparingly, only on the high-stakes call.

ReAct (reason + act)

Interleave thought, action, and observation. This is the prompt pattern underneath most agent frameworks. See How to build AI agents for the full walkthrough.

Prompt chaining

Instead of one giant prompt, split a task into a pipeline of small prompts. Easier to debug, easier to evaluate, often cheaper because early stages can use a smaller model.

Critique-and-revise

Have the model produce a draft, then a second call critiques it against a rubric, then a third revises. Adds latency but routinely lifts quality from "acceptable" to "ship it."

Meta-prompting

Use the LLM to write your prompts. Give it the task description and five sample inputs; ask it to produce three candidate prompts; eval them. The best AI engineers in 2026 spend more time evaluating prompts than writing them.

Real-world examples

Example 1, Bad vs good extraction prompt

Bad:

``` Extract the company name from this email. ```

Good:

``` You extract structured data from emails.

Output a JSON object with this exact shape: { "company": string | null, "confidence": "high" | "medium" | "low" }

Rules: - "company" is the customer’s company, not the sender’s. - If no company is mentioned, return null and confidence "high". - Never invent a company. If unsure, return null and confidence "low".

<email> {{email_body}} </email> ```

In our test set, the bad prompt scores 64%. The good prompt scores 94%. Same model.

Example 2, Tone-locked writing

Want the model to write in your voice? Give it three short samples of your actual writing, then ask it to match the cadence and vocabulary -- not the topic. This out-performs every "write like Hemingway" trick.

Example 3, Agent tool selection

For agents calling 10+ tools, prefix the prompt with a short decision tree:

``` If the user asks for data -> use query_db. If the user asks to send something -> use send_email. If unsure -> ask one clarifying question, do not call any tool. ```

This single addition usually cuts wrong-tool errors in half.

Common mistakes

1. Vague tasks. "Make this better" gives random results. "Tighten this paragraph to under 60 words, keep the second sentence as-is" doesn’t. 2. Negative-only instructions. "Don’t be verbose" without telling the model what to be invites the same problem in a new shape. Always pair "don’t X" with "do Y." 3. Burying the instruction. Models attend more to the start and end of long prompts. Put the actual task at the very top or very bottom, never in the middle. 4. Examples that don’t match the target. Few-shot examples are templates. The model copies the structure literally. Mismatched examples are worse than none. 5. No evals. If you can’t measure prompt quality on a fixed dataset, you’re not engineering, you’re vibing. Build a 20-prompt eval before you optimize. 6. Treating the prompt as static. Models change. Prompts that scored 95% on GPT-4 sometimes score 70% on GPT-5 because the new model interprets a constraint differently. Re-eval on every model bump.

Tools & frameworks

- LangSmith, the standard for prompt and trace observability. - Promptfoo, open-source eval harness. The fastest way to A/B prompts. - DSPy, treats prompts as compilable programs; auto-optimizes them against your eval set. - Anthropic Workbench / OpenAI Playground, the rapid-iteration UIs. - Helicone / Langfuse, production logging and cost tracking.

For ready-to-use templates, browse our best ChatGPT prompts collection.

Is it still a career?

The title "Prompt Engineer" peaked in 2023 and is fading. The underlying skill is more valuable than ever, it’s just been absorbed into broader roles: AI engineer, applied AI lead, ML platform engineer. Anyone shipping AI features today does prompt engineering, the same way anyone shipping web features does HTML.

If you want to go deep, the highest-leverage adjacent skills are: evals, RAG, agent frameworks (LangGraph), and basic LLM fine-tuning.

Where to go next

Read How to build AI agents to see prompts inside larger systems, or jump to GPT-5 vs Claude Sonnet to choose the model your prompts will run on. The fastest way to get good is to write 100 prompts against tasks you actually have. Open the prompt library and start copying.

Sources and further reading

- Anthropic, Prompt engineering overview -- provider documentation on prompt design techniques. - OpenAI, Prompt engineering guide -- provider guidance on writing effective prompts. - Google, Prompting strategies -- provider prompting guidance for the Gemini API.