Prompt Engineering 101

What Is Prompt Engineering?

Prompt engineering is the practice of designing, optimising, and iterating on the text instructions given to an AI language model to achieve specific, reliable, and high-quality outputs.

Think of it like programming, but in natural language. Just as a software engineer writes code to instruct a computer, a prompt engineer writes instructions to direct an LLM. The difference: the "compiler" is a probabilistic model that responds to nuance, context, tone, and structure in ways that traditional code does not.

Prompt engineering sits at the intersection of linguistics, psychology, and computer science. The best prompt engineers understand how language models process tokens, what patterns they reward, and how to exploit or constrain their tendencies.

Why Prompt Engineering Matters in 2026

By 2026, prompt engineering has moved from a niche skill to a foundational literacy. The same underlying model can produce a masterpiece or a meaningless paragraph depending entirely on how it is instructed. Three forces make this skill critical:

1. AI is everywhere in the workplace. Customer support, legal drafting, code review, data analysis — all increasingly AI-assisted. The quality gap between a well-prompted and a poorly-prompted AI is measured in hours of human correction time.
2. Models are general-purpose but deployment is specific. Fine-tuning is expensive. Prompt engineering is the primary lever for making a general model behave as a domain expert.
3. Agentic AI requires reliable prompting. When AI agents act autonomously — browsing the web, writing code, booking appointments — a flawed prompt doesn't just produce bad text; it takes wrong actions. Reliability at the prompt level is now a safety concern.

Zero-Shot Prompting

Zero-shot prompting means giving the model a task with no examples. You rely entirely on the model's pre-trained knowledge and your ability to describe what you want.

Zero-shot works best for well-defined tasks that match the model's training distribution — summarisation, translation, classification, and simple question-answering.

Classify this customer review as Positive, Negative, or Neutral.
Output only the label, nothing else.

Review: "Delivery took 12 days but the product itself is excellent."

Notice the key techniques already: explicit output constraint ("output only the label"), and a clear classification schema. Even zero-shot prompts benefit from structure.

Few-Shot Prompting

Few-shot prompting provides examples of the desired input-output pattern before the actual task. The model learns the pattern from examples rather than relying solely on instructions.

Few-shot is most powerful for tasks where the output format or style is hard to describe in words — where showing is faster than telling.

Write a product description in this style:

Product: Noise-cancelling headphones
Description: Block out the world. Pure sound, zero distraction.

Product: Wireless charging pad
Description: Drop it, charge it. No cables. No fuss.

Product: Smart water bottle
Description: [Your output here]

The two examples teach the model a specific copywriting style — short, imperative, benefit-focused — without you having to describe it. The model infers the pattern.

Tip: Use 2-5 examples for most tasks. More examples rarely help and add token cost. Ensure your examples are consistent — contradictory examples confuse the model.

Chain-of-Thought Prompting

Chain-of-thought (CoT) prompting instructs the model to reason step-by-step before giving its final answer. Introduced in a 2022 Google Brain paper, CoT dramatically improves performance on reasoning tasks — maths, logic, multi-step analysis.

A store buys a jacket for £40 and marks it up 50%.
Then runs a 20% sale. What is the final sale price?

Think step by step:
1. Calculate the marked-up price.
2. Apply the 20% discount.
3. State the final price.

The phrase "think step by step" is the minimum CoT trigger. Providing a numbered structure is stronger — it forces the model through each calculation rather than jumping to an answer.

Role Prompting

Role prompting assigns the model a specific persona, expertise level, or character before the task. This activates different "knowledge registers" in the model's training distribution.

You are a senior UK employment lawyer with 20 years of experience
in tribunal cases. You always cite the relevant section of the
Employment Rights Act 1996 when applicable.

Question: Can an employer require employees to work on bank holidays?

The role here does three things: sets expertise level (senior), sets jurisdiction (UK), and sets a citation requirement (Employment Rights Act). Each constraint narrows the output distribution toward more accurate, useful responses.

Caution: Role prompting does not grant the model knowledge it doesn't have. A model told to be a medical doctor doesn't become more accurate on rare conditions. Role prompting improves tone, format, and reasoning style — not factual accuracy.

Output Formatting and Structure

Specifying output format is one of the highest-leverage prompt engineering techniques. Unformatted outputs require manual parsing; formatted outputs slot directly into workflows.

Common format specifications:

• JSONAPI responses, structured data extraction, machine-readable output
• Markdown tableComparisons, feature matrices, ranked lists
• Numbered listStep-by-step instructions, ranked items
• Bullet pointsFeature lists, summaries, key takeaways
• CSVBatch classification, data labelling, bulk analysis
• Plain prose (no formatting)Marketing copy, blog content, email drafts

Extract the named entities from this sentence and return ONLY
valid JSON — no prose, no markdown code blocks:

{"persons": [], "organisations": [], "locations": []}

Sentence: "Elon Musk's SpaceX launched a Falcon 9 from Cape Canaveral."

Providing the empty JSON schema as a template dramatically reduces format errors. The model fills in values rather than inventing structure.

Constraint Stacking

Constraint stacking is the technique of layering multiple constraints into a single prompt to precisely bound the output space. Each constraint eliminates a failure mode.

Generate 5 product names for an AI scheduling assistant.
Constraints:
1. Each name under 10 characters
2. No existing brand names
3. One word or portmanteau only
4. Must suggest speed or intelligence
5. No names starting with "AI" or "Smart"
Output: numbered list, names only, no explanations.

Each constraint here addresses a specific failure mode: length (constraint 1), trademark risk (2), format (3), semantic relevance (4), overused prefixes (5). The output constraint (numbered list, names only) prevents verbose padding.

Rule of thumb: Start with your minimum viable prompt, then add one constraint per failure mode you observe. Don't preload constraints for problems that haven't appeared — that's speculative over-engineering.

Self-Verification Techniques

Self-verification instructs the model to check its own output before presenting it. This creates an internal review loop that catches errors the model would otherwise confidently assert.

Self-verification adds tokens and latency. Use it selectively — for high-stakes outputs, numerical tasks, and multi-constraint prompts where silent failure is costly.

Advanced Techniques

Common Mistakes

• ✗

  Vague task description

  Replace "write a blog post" with "write a 600-word blog post for senior HR managers on remote work burnout, with an actionable conclusion."

• ✗

  No output format specified

  Always specify format: JSON, table, numbered list, plain prose. Unspecified format leads to inconsistent structure.

• ✗

  Expecting factual accuracy without verification

  LLMs hallucinate. Always ask for sources, add confidence scores, or verify critical facts independently.

• ✗

  Adding constraints you don't need

  Prompt iteratively — start minimal, add constraints only when you observe failure modes.

• ✗

  Conflicting instructions

  Audit your prompt for contradictions: "be concise" + "cover all aspects" conflict. Resolve explicitly.

• ✗

  One-shot evaluation

  Run every prompt at least 5-10 times to assess reliability, not just quality of a single output.

How to Practice

Prompt engineering is a craft. Reading about it improves your theory; writing prompts improves your skill. The fastest path to competence:

1. Solve 5 challenges per week. Each PromptQuest challenge targets a specific technique. Work through one difficulty tier before advancing.
2. Keep a prompt library. When a prompt works well, save it with notes on why. Your library is your professional edge.
3. Study failures systematically. When a prompt fails, identify exactly which part failed — task description, format, constraints, or context. Fix only that part.
4. Read model release notes. New model versions change what works. A technique that required complex CoT in GPT-3.5 may work zero-shot in GPT-4o.
5. Build a real project. Prompt engineering under production constraints — latency, cost, reliability, user unpredictability — teaches things no tutorial can.