15 Prompt Engineering Techniques That Actually Work

The most effective prompt engineering techniques are few-shot prompting, chain-of-thought, role prompting, and self-consistency. They all follow the same principle: you give the model more structure, more examples, or more room to reason, instead of hoping for a lucky guess. This guide covers 15 techniques that deliver measurably better results in practice — each with a concrete example and a clear use case.

In 2026, prompt engineering is no longer an art but a craft with documented patterns. The techniques below come from research at OpenAI, Google DeepMind, and Anthropic, as well as daily work with models like GPT-4o, Claude, and Gemini. You don't need to apply them all at once. Learn them, pick the right one for your task, and combine them when needed. If you want to solidify the basics first, start with our guide to [prompt engineering fundamentals](/magazin/prompt-engineering-fundamentals).

A note up front: none of these techniques is a trick that fools a model. Each works because it gives the model more information, more structure, or more room to compute. Once you understand the principle, you can invent your own variants instead of memorizing recipes. That is the focus of this article: not just the what, but the why behind every technique.

What are the most effective prompting techniques?

The most effective techniques are the ones that give the model either examples, reasoning steps, or a clear role. In practice, four dominate: few-shot prompting (show examples), chain-of-thought (let it think aloud), role prompting (set the perspective), and structured output (enforce a format). These four cover the bulk of everyday cases.

Why these specifically? Because they address the core weakness of language models: missing context. A model doesn't know your intent — it only predicts the most likely next word. According to the 2022 study by Wei et al. at Google, chain-of-thought raised the success rate on math problems from 17.9 to 58.1 percent simply by asking the model to reason step by step. The remaining eleven techniques in this article are special cases and refinements of that core idea: more structure produces more reliable answers.

A sensible learning order: start with role prompting and structured output, because they work instantly with no preparation. Then add few-shot once format or tone start to matter. Reach for chain-of-thought when the task requires genuine reasoning. Only after that do the advanced patterns like self-consistency or decomposition pay off. Following this progression avoids the most common beginner mistake: throwing too much technique at a simple task.

How does few-shot prompting work?

Few-shot prompting means showing the model two to five solved examples inside the prompt before you state the actual task. The model recognizes the pattern in the examples and applies it to the new case. It is the most reliable way to control format, tone, and logic precisely, without writing long explanations.

The difference from zero-shot prompting (no examples) is substantial. According to the GPT-3 paper by Brown et al. (OpenAI, 2020), accuracy improved markedly on many tasks once a few examples were placed in the prompt. One good example replaces a paragraph of instruction.

A practical example for classifying support tickets:

"Classify the sentiment as positive, neutral, or negative.

Text: The delivery arrived two days late. → negative Text: Everything went smoothly, thank you! → positive Text: The invoice has arrived. → neutral Text: The product was damaged, I'm disappointed. →"

Mind your consistency: the format, order, and style of the examples must be identical. Inconsistent examples confuse the model more than they help. Two or three clean examples beat ten sloppy ones.

A common mistake is showing only easy examples. Instead, choose examples that cover the range and the edge cases of your real data. If your tickets also contain ironic or ambiguous sentiments, at least one example must reflect exactly that case — otherwise the model guesses wrong on precisely the inputs that are hardest. Few-shot is also the natural bridge to reusable templates: a curated example set can be applied across hundreds of tasks.

How does chain-of-thought prompting work?

Chain-of-thought (CoT) asks the model to write out its intermediate steps before giving an answer. Instead of jumping straight to the result, the model thinks "aloud" — and this dramatically improves accuracy on logic, math, and multi-step tasks. The simplest trigger is the phrase "think step by step."

The effect is well documented. In the original study by Wei et al. (Google, 2022), CoT lifted a large model's success rate on the GSM8K math benchmark from roughly 18 to 58 percent. The reason: by formulating intermediate results, the model gains more "computation room" and grounds each step on the previous one.

An example for a multi-step task:

"A café sells 23 coffees at 3.50 euros each and 15 slices of cake at 4.20 euros each. What is the daily revenue? Think step by step and show your calculation."

An advanced variant is zero-shot CoT: you need no examples, just the sentence "Let's work through this step by step." For even higher reliability, combine CoT with self-consistency (technique 7). For an in-depth treatment, see our guide to [chain-of-thought prompting](/magazin/chain-of-thought-prompting).

The boundary matters: CoT helps on tasks with a traceable solution path — arithmetic, logic puzzles, multi-step planning. On pure taste or style questions it adds little and only lengthens the answer. Note too that modern "reasoning" models such as OpenAI's o-series already do step-by-step thinking internally; with them, an explicit "think step by step" is often redundant. So always check whether your model has the technique built in before forcing it manually.

When should you use role prompting?

Use role prompting when the answer needs a particular perspective, technical vocabulary, or a specific tone. You assign the model a role — "You are an experienced tax advisor" — and it draws on the matching part of its knowledge and style. It is ideal for specialist topics, audience targeting, and a consistent brand voice.

The role acts as a filter over the model's entire knowledge. "Explain inflation" yields a different answer than "You are an economics teacher at a secondary school. Explain inflation to an 8th-grade class." The second version is more concrete because the role sets the level, word choice, and examples.

Example:

"You are an experienced data protection officer. Review the following newsletter text for GDPR issues and name concrete risks with suggested improvements."

However, don't use role prompting for pure factual questions — there it adds little and can even put style over correctness. It is strongest in combination with context and a format requirement. A role alone doesn't make a good prompt; it is one building block alongside task, context, and output format.

The remaining 11 techniques at a glance

The four core techniques cover a lot — but for demanding tasks, these eleven additional patterns are worth knowing. Each solves a specific problem.

5. Enforce structured output

Demand a concrete format: JSON, table, Markdown, or a numbered list. "Respond only as valid JSON with the fields name, priority, deadline." This makes the output machine-processable and saves you from parsing free-form prose afterward. Many models now offer a dedicated JSON or structured-output mode that guarantees the format — use it when you process the output in an application, rather than relying on prompt wording alone.

6. Use delimiters and sections

Separate instruction, context, and data clearly — using triple quotes, XML tags, or headings. This prevents the model from confusing your input data with your instructions, and it also guards against accidental prompt injection. Anthropic explicitly recommends XML tags like ⟨document⟩ … ⟨/document⟩ for Claude, because the model is trained to recognize such markers reliably. Clear boundaries make long prompts more robust and easier to maintain.

7. Self-consistency

Have the model answer the same question several times with chain-of-thought and take the most frequent answer. According to Wang et al. (Google, 2022), this majority vote improves accuracy noticeably over single CoT — especially on tasks with a single correct solution. The price is higher cost, since you pay for multiple runs. So use the technique deliberately where correctness is critical, such as calculations or classification decisions with consequences.

8. Step-by-step decomposition

Break a large task into subtasks and solve them in sequence. Instead of "write a business plan," first ask for the target audience, then the value proposition, then the finances. Each step builds on the verified result of the previous one. The advantage: you can intervene and correct after each step, instead of receiving one long result at the end that may have derailed at an early point. Decomposition is the backbone of nearly every AI agent and multi-step workflow.

9. Use negative instructions sparingly

Tell the model what to do, not just what to avoid. "Write in short sentences" works better than "Don't write so long." If prohibitions are necessary, make them concrete: "Do not use jargon without explanation." The reason is both psychological and statistical: a prohibition draws attention to exactly the word you want to avoid and, paradoxically, raises its probability. Positive, descriptive instructions guide the model to the goal more reliably.

10. Few-shot with counter-examples

Show not only correct but also incorrect examples with a reason. This teaches the model the boundary between acceptable and unacceptable — useful for moderation, quality checks, and classification of edge cases. Label the counter-examples unambiguously ("Wrong, because …") so the model doesn't accidentally imitate them. On sensitive tasks like compliance checks, a well-chosen counter-example sharpens the dividing line far more precisely than any abstract rule.

11. Self-critique and reflection

Ask the model to review its first answer: "Check your answer for errors and correct them." This second pass often catches careless mistakes and logical gaps that arise on the first attempt. Even more effective is to give a concrete review criterion: "Check that every number in the text matches the table." This loop, known as "self-refine," is well researched and especially worthwhile for text and code.

12. Control temperature deliberately

For models with a temperature parameter: choose low values (0–0.3) for facts, code, and classification; higher values (0.7–1.0) for creative writing and brainstorming. Temperature controls how "risk-taking" the model is when choosing words. At zero, output becomes nearly deterministic — ideal when you want to process the same input reproducibly. This technique belongs not in the prompt text but in the API setting; many users overlook it entirely.

13. Fill the context window deliberately (RAG style)

Provide relevant source texts directly in the prompt and instruct the model to answer only from them: "Answer solely on the basis of the following document." This reduces hallucinations and anchors answers in your data. Add an escape hatch to the instruction: "If the answer is not in the document, say: not found." This forces the model to be honest rather than supply a plausible-sounding invention — the foundation of any reliable retrieval system.

14. Prompt templates and variables

Build reusable templates with placeholders for changing content. Instead of rewriting every prompt, you maintain one tested template — the foundation of any professional [prompt library](/magazin/prompt-bibliothek-aufbauen). Templates make quality repeatable and team-ready: a prompt optimized once is available to everyone, and improvements land in one central place. Version your templates like code so you can trace which change had which effect.

15. Iterative refinement

Treat the first prompt as a draft. Review the output, identify the weak point (missing context? unclear format?), and change exactly one factor. Systematic iteration beats guessing and makes good prompts reproducible. Note what you changed and how the output shifted — over time this builds a personal feel for which lever works on which model. Prompt engineering is ultimately an empirical discipline: measure, change, measure again.

Do the techniques differ depending on the model?

Yes — and in 2026 this matters more, not less. The core principles hold across all major models, but every provider has quirks worth exploiting in practice. Running the same prompt blindly across all models leaves quality on the table.

Anthropic explicitly documents Claude's preference for XML tags as structure, and it responds especially well to detailed role and context information. OpenAI's GPT line leans heavily on system messages, where you set persistent behavior rules separate from the actual user request. Google's Gemini shines on very long contexts and multimodal inputs, for example when images or tables are part of the prompt.

On top of this comes the growing class of reasoning models. They run chain-of-thought internally and often need fewer explicit thinking instructions but more clarity about the desired final format. A short rule of thumb: classic models benefit from explicit guidance to reason; reasoning models benefit from precise specification of the result. Which model is right for your case is something we compare in detail in our [model comparison Claude vs. ChatGPT vs. Gemini](/magazin/claude-vs-chatgpt-vs-gemini-vergleich). The key consequence for your prompt strategy: test your important prompts on every model you run in production, instead of assuming one winner wins everywhere.

How do you combine multiple techniques effectively?

The real power emerges when you stack techniques — but in the right order, and only as many as the task needs. A typical professional prompt combines four building blocks: a role, clearly delimited context, a task broken into steps, and an enforced output format. This combination is no accident; it mirrors the natural structure of a good brief given to a person.

An example of a combined prompt for contract analysis:

"You are an experienced commercial lawyer. Analyze the following contract in three steps: 1. Identify risky clauses. 2. Rate each as low, medium, or high. 3. Suggest a rewording. Respond as a table. Contract: ⟨contract⟩…⟨/contract⟩"

Here role prompting, decomposition, structured output, and delimiters work together. But watch the limit: every additional instruction consumes the model's attention. Stack too many competing rules and the compliance rate drops. So after each addition, test whether the output truly improves — and remove anything that contributes nothing. Less, but precisely chosen technique almost always beats an overloaded mega-prompt.

What mistakes should you avoid?

The most common mistakes have less to do with missing technique than with unclear communication. Top of the list is the vague prompt: "Write me something about marketing" forces the model to guess your intent. The more open the input, the more average the output — because the model averages over everything it has learned about the topic.

The second major mistake is stacking contradictory instructions: "Be brief, but explain every detail." Such conflicts force the model into a compromise you don't control. State a clear priority instead.

This table summarizes the typical pitfalls:

One final, often overlooked point: models change. A prompt that ran perfectly on GPT-4o may behave differently on a newer model. So treat your important prompts as maintained assets that you re-check when switching models — not as write-once throwaways.

Which technique fits which task?

The right technique depends on the task type. This table maps the most common cases:

One final rule of thumb: always start with the simplest technique that could work, and only add complexity when the output demands it. A clear zero-shot prompt with a good role often beats an overloaded construct of five techniques. The best prompt engineers aren't the ones who stack the most technique, but the ones who pick the right tool with precision. Collect your proven prompts in one place so tested patterns stay reusable — which is exactly what Prompt2Love is built for.