Prompt Engineering 2.0: The Complete Guide (2026)

On this page

1. What is prompt engineering 2.0?
2. Why prompt engineering matters more in 2026, not less
3. The thirteen techniques, one paragraph each
4. Zero-shot prompting
5. Few-shot prompting
6. Chain-of-thought (CoT)
7. Self-consistency
8. Tree-of-thoughts (ToT)
9. ReAct (reasoning + acting)
10. Role prompting
11. Context engineering (vs prompt engineering)
12. Structured output prompting
13. Long-context prompting
14. Multimodal prompting
15. Prompt chaining and workflows
16. Self-critique prompts
17. The complete comparison table
18. First-hand benchmark: zero-shot vs few-shot vs CoT
19. The one-page decision tree
20. How to combine techniques (real workflows)
21. Common mistakes in 2026
22. How to evaluate a prompt (not just eyeball it)
23. FAQ

What is prompt engineering 2.0?

Prompt engineering 2.0 is the discipline of choosing and combining named prompting techniques — each with published performance characteristics — to hit a specific accuracy, latency, and cost target on a specific task. It replaced the 2022–2023 "prompt whispering" era, where the craft was ineffable and the best practices were tweets. Today the field has thirteen well-studied techniques, three or four of which appear in almost every production LLM system.

The 1.0 version, roughly 2022 through mid-2023, was mostly about phrasing: "act as", "let's think step by step", triple-backticks, imperative voice, temperature knobs. It worked because early GPT-3.5 and GPT-4 rewarded verbal framing. It stopped being enough the moment three things happened in parallel: models became better at zero-shot, context windows grew to 100K–2M tokens, and users started building multi-step agents that call tools. Suddenly the question was not "how do I phrase this?" but "which of six techniques do I pick, and how do I chain them together?"

The 2.0 mental model has four layers. Layer 1 is choosing a technique (zero-shot, few-shot, CoT, ReAct, etc.). Layer 2 is engineering the context that ships to the model — retrieved documents, tool schemas, memory, system prompt. Layer 3 is orchestration: chaining prompts, retrying, self-critique, fan-out and aggregation. Layer 4 is evaluation — measuring accuracy, cost, latency across a held-out test set so you can tell if a change is real. Most of the "prompt engineering is dead" hot takes conflate layer 1 with the whole discipline. It's not dead; it just grew up.

Why prompt engineering matters more in 2026, not less

Better models did not kill prompt engineering. They raised the ceiling of what a good prompt can achieve while leaving the floor of a bad one exactly where it was. Here is what changed in the last twelve months that made the discipline harder to skip, not easier.

First, context windows exploded. Gemini 2.5 Pro serves 1M tokens as standard and 2M via API preview. Claude 4.7 Opus holds 200K by default. GPT-5 defaults to 400K. That does not mean "just paste everything in." It means the selection of what goes into the context is a first-class problem, and putting the right information in the right position (system prompt, top of user turn, retrieved chunks, examples) now has documented effects on accuracy — the well-known "lost in the middle" finding from Liu et al. 2023 still holds in mid-context on newer models.

Second, multimodal became table-stakes. GPT-5, Gemini 2.5, Claude 4.7 and Sora 2 all accept images, and Gemini and GPT-5 accept audio and video. This unlocks new prompting techniques (few-shot with image examples, chart-to-text extraction, visual chain-of-thought) but each has its own quirks — image order matters more than text order, negative prompts affect image generation differently from image understanding, and the base model does not know what your PDF layout means without hints.

Third, tool use and agent scaffolding went mainstream. Every serious API now supports structured tool calling. ReAct-style loops with function calls are how most production "AI features" actually work under the hood. The prompt is now three prompts glued together: system prompt, tool schema, and per-turn instructions with context. Getting any one of them wrong tanks the whole workflow.

Fourth, cost pressure is real. A 100K-token call with GPT-5 output costs enough that "throw a bigger prompt at it" is not a free move. Prompt engineering 2.0 is partly about hitting quality targets at a token budget. Choosing few-shot over CoT when few-shot alone is enough can cut costs by 60% with no quality loss. This is a first-order engineering decision, not a "nice to have."

And fifth, the field finally has real benchmarks. HELM, BigBench, GSM8K, MMLU-Pro, HumanEval, SWE-Bench Verified, ARC-AGI-2 all provide reproducible ways to compare techniques on the same task. When someone claims "CoT does not help my task" you can actually ask which benchmark they measured on. In 2023 the answer was "I ran a few tests." In 2026 there is homework you can do.

The thirteen techniques, one paragraph each

These are the named techniques you should recognize on sight and know when to reach for. Each has a dedicated deep-dive linked from the section below — this is the map. If you know all thirteen by end of this article, you are already ahead of about 95% of "prompt engineers" on LinkedIn.

1. Zero-shot prompting

Direct answer: zero-shot means asking the model to do a task without giving it any examples of the task performed correctly — just the instruction and the input. It is the default for well-known tasks on capable models. GPT-5, Claude 4.7, and Gemini 2.5 Pro handle most zero-shot requests well on tasks in their training distribution: summarization, translation, sentiment, extraction from clean text. Where zero-shot breaks is on rare formats, domain jargon, or tasks where "correct output" is a specific structure the model has not seen a thousand times. When it works it is the fastest, cheapest option and you should stop optimizing. When it fails silently — a subtly wrong format, hallucinated citations, boilerplate that ignores half the instruction — you move to few-shot or CoT. See the beginner's guide for the fundamentals.

2. Few-shot prompting

Direct answer: few-shot means putting 2–5 completed examples of the task inside the prompt before the actual input, so the model can imitate the pattern. Brown et al.'s 2020 GPT-3 paper (Language Models are Few-Shot Learners) established this as the paradigm for teaching new tasks without fine-tuning. In 2026 few-shot remains the single most reliable technique for classification, format matching, information extraction into a specific schema, and any task where "the right answer looks like this" is easier to demonstrate than to describe. The tradeoffs are token cost (each example eats context) and example curation — badly chosen examples poison the pattern. Rule of thumb: three diverse examples with clean formatting beats seven repetitive ones. Prefer few-shot when you find yourself writing more than a paragraph of instructions.

3. Chain-of-thought (CoT)

Direct answer: CoT prompts the model to write out its intermediate reasoning steps before committing to a final answer. Introduced by Wei et al. 2022 (Chain-of-Thought Prompting Elicits Reasoning in Large Language Models, arXiv:2201.11903), CoT lifts GSM8K accuracy from 18% to 57% on the original PaLM 540B, with even larger relative gains on other multi-step reasoning benchmarks. The prompt is often as simple as adding "let's think step by step" (Kojima et al.'s "zero-shot CoT" 2022) or providing a worked example that shows reasoning explicitly. In 2026 the newer "reasoning models" like o1, o3, and DeepSeek-R1 do CoT internally by default and expose the trace as a separate field — but explicit CoT still helps standard chat models on multi-step arithmetic, symbolic manipulation, and planning tasks. Cost: 2–5× more output tokens than direct answers. Worth it whenever the task genuinely needs multiple reasoning steps.

4. Self-consistency

Direct answer: self-consistency runs the same CoT prompt N times at higher temperature (typically N = 5–20, temperature 0.7), then picks the most common final answer via majority vote. Wang et al. 2022 showed this pushes GSM8K accuracy another 15+ percentage points beyond vanilla CoT on the same model. It works because reasoning has multiple valid paths but usually one correct destination, so a majority vote across independent chains is more reliable than any single chain. The obvious cost is N times the tokens, which makes self-consistency practical mostly for high-stakes tasks — legal reasoning, medical triage, competition math — where accuracy matters more than budget.

5. Tree-of-thoughts (ToT)

Direct answer: tree-of-thoughts generalizes CoT by exploring multiple reasoning branches, evaluating them at each step, and pruning bad paths. Yao et al. 2023 (arXiv:2305.10601) showed ToT solves Game-of-24 puzzles at 74% accuracy vs 4% for CoT on GPT-4. The mechanism is essentially DFS or BFS through partial reasoning states, with the model itself acting as both generator and evaluator. In practice ToT requires an orchestrator (you cannot do it in one prompt — it is multi-step), so it lives in the workflow layer, not the prompt layer. Reserve it for genuinely hard planning problems: complex logic puzzles, multi-constraint scheduling, code refactor plans across many files.

6. ReAct (reasoning + acting)

Direct answer: ReAct interleaves reasoning steps ("Thought:") with tool calls ("Action:") and observations ("Observation:"), letting the model plan, act, observe, and re-plan in a single loop. Yao et al. 2022 (arXiv:2210.03629) demonstrated ReAct outperforming CoT on question-answering tasks requiring external knowledge and beating imitation-learning baselines on interactive decision tasks. In 2026 every mainstream tool-calling API (OpenAI's function calling, Anthropic's tool use, Gemini's function API) is essentially a ReAct implementation. The technique is not optional if you are building agents — it is the default paradigm for anything involving retrieval, code execution, or web search.

7. Role prompting

Direct answer: role prompting assigns the model a persona ("You are an expert corporate lawyer specializing in SaaS contracts") to bias the response style, expertise level, and evaluation criteria. It works most reliably when the role encodes a specific set of priorities — a "senior code reviewer" produces different output from a "junior developer" not because of magical persona but because the underlying token distributions for the two roles differ measurably. In 2026 the honest research finding is that role prompting has moderate, task-dependent effects (Shanahan et al. 2023, Kong et al. 2024) — it is not a universal cheat code. Use it to set tone and rigor level; do not expect it to unlock capabilities the base model does not have.

8. Context engineering (vs prompt engineering)

Direct answer: context engineering is the practice of curating, retrieving, and positioning the information that ships with your prompt — not just what you write, but what you attach. In a 100K-token context window with retrieved documents, tool schemas, conversation history, and few-shot examples all fighting for slots, the decisions about what to include, in what order, and at what compression rate arguably matter more than the phrasing of your instruction. RAG (retrieval-augmented generation) is the best-known context-engineering technique. Long-context prompting is another. The full discipline is a topic of its own — the practical version is: audit what actually enters your context and cut anything the model does not need for this specific turn.

9. Structured output prompting

Direct answer: structured output prompting forces the model to produce JSON, YAML, or a specific schema that downstream code can parse without a regex hack. In 2026 the reliable path is native structured-output support: OpenAI's response_format: json_schema, Anthropic's tool-use schema, Gemini's response_mime_type. These grammar-constrain the decoder so malformed output is impossible. If you are still doing "output valid JSON" as a plain instruction and hoping — you are on the 2023 stack. Migrate. Even with native support you still specify the schema, name the fields explicitly, and give one example of correctly-shaped output for anything non-trivial.

10. Long-context prompting

Direct answer: long-context prompting is the set of techniques for reliably retrieving information from a 100K+ token prompt without the model losing track. The core finding — Liu et al. 2023's "lost in the middle" paper — is that models attend more strongly to the start and end of long inputs than the middle, so critical information buried at position 50K in a 100K prompt gets missed. Techniques that help: place the question at the end (repeat it if the input is long), use structured markers ("[DOCUMENT 3 OF 20]"), summarize each chunk before the main task, and for retrieval-heavy tasks, prefer RAG over stuffing the whole corpus into context. Every major 2026 model has improved on this vs 2023 baselines but none has eliminated the effect.

11. Multimodal prompting

Direct answer: multimodal prompting extends the techniques above to prompts that include images, audio, or video. Image few-shot works — passing three labeled image examples before an unlabeled one, on GPT-5 or Gemini 2.5, lifts classification accuracy noticeably over zero-shot. Visual CoT works — asking the model to describe what it sees step by step before answering a question about an image improves reasoning on chart understanding. Image order matters more than text order (recent research suggests attention over image tokens is more spatially than sequentially biased). See RAG vs fine-tuning vs prompt engineering for how multimodal fits into the wider ecosystem.

12. Prompt chaining and workflows

Direct answer: prompt chaining breaks a complex task into a sequence of smaller prompts, where each stage's output becomes the next stage's input. Classic pattern: prompt 1 extracts a plan, prompt 2 executes step one, prompt 3 executes step two with prompt 2's output as context, and so on. Chaining is the workhorse of production LLM systems in 2026 because it lets you (a) use different techniques or even different models per stage, (b) log and re-run individual stages, (c) evaluate each stage independently, (d) recover from failure mid-chain instead of re-running the whole thing. The obvious cost is orchestration complexity — you now need retry logic, error boundaries, and state management. Most agent frameworks are essentially prompt-chaining libraries.

13. Self-critique prompts

Direct answer: self-critique prompts ask the model to grade its own output, then revise it based on the critique. Two-stage pattern: prompt 1 generates a draft, prompt 2 shows the draft and asks the model to identify errors and produce a corrected version. Reflexion (Shinn et al. 2023) and constitutional AI (Bai et al. 2022) both build on this. Effectiveness depends heavily on task type — self-critique helps a lot on code review, tone-and-style critiques, and factual auditing when the model has access to grounding. It helps almost nothing on hard reasoning tasks where the model was wrong the first time because it does not know the correct answer. Use self-critique to polish outputs; do not use it to fix knowledge failures.

The complete comparison table

This is the reference. Bookmark this section. Numbers are drawn from the original papers where available, with the model each was originally measured on noted in parentheses. Reproducibility of the exact deltas on a 2026 frontier model varies — the ordering and relative magnitudes hold; the absolute numbers on GPT-5 or Claude 4.7 will differ.

pp = percentage points. Absolute lift numbers were measured on the models named in parentheses — expect qualitative agreement, not exact reproduction, on 2026 frontier models.

First-hand benchmark: zero-shot vs few-shot vs CoT on GSM8K-style math

The 15-problem mini-experiment. The published numbers in the table above are correct but they were measured on 2022-era models. To make this article useful in 2026, we designed a small reproducible benchmark to compare zero-shot, few-shot, and chain-of-thought on the same set of grade-school math word problems, run through GPT-4.1-mini via the standard OpenAI Chat Completions endpoint at temperature 0.

The full test set is embedded below so any reader can reproduce this on their own model of choice, and we will publish the run results as a separate follow-up post the moment our current quota window unblocks (this cron hit an upstream rate limit during authoring and we prefer not to inflate a small sample). This is disclosed so no reader mistakes an unrun experiment for measured numbers.

Test set (15 problems, gold answers)

The three prompts (verbatim)

Zero-shot:

Q: {problem}
A:

Few-shot (3 examples):

Answer the math question with just the number.

Q: A dog eats 2 cups of food per day. How many cups in 5 days? A: 10

Q: A car goes 60 km/h. How far in 3 hours? A: 180

Q: If 3 pencils cost $6, what does 1 pencil cost? A: 2

Q: {problem} A:

Chain-of-thought:

Solve step by step, then give the final numeric answer on its own line prefixed with 'ANSWER: '.

Q: {problem} A: Let me think step by step.

Expected findings, based on published research

Based on the CoT and few-shot literature (Wei et al. 2022; Brown et al. 2020; Kojima et al. 2022) applied to GSM8K-adjacent problems, we expect the following ordering on a 2026 mid-tier model like GPT-4.1-mini:

• Zero-shot: 40–60% accuracy on the 15-problem set. Correct on the direct arithmetic (problems 1, 6, 8, 12, 13) but likely to fail on multi-step (problems 5, 7, 9, 14) where a single-shot answer doesn't leave room for intermediate calculation.
• Few-shot: 50–70%. The three examples give the model a "just the number" convention which helps parsing, but the examples themselves are single-step, so multi-step problems still get shortcut-ted.
• Chain-of-thought: 80–95%. Every problem here has a clean step-by-step solution and CoT lets the model actually execute the arithmetic. This is the case CoT was designed for.

The point is not the exact numbers — it is the ordering. On multi-step arithmetic, CoT dominates. This is the reason the technique won and stuck. When the follow-up post publishes the measured numbers on GPT-4.1-mini, GPT-5, Gemini 2.5 Pro, and Claude 4.7, this section gets updated in place with the deltas. Until then, use the 2022 numbers as your default expectation and treat any 2026 result more than 15 pp different as noteworthy.

Reproduce this yourself. Copy the three prompt templates and the 15-problem list, run each combination in your model of choice, count how many finals match the gold answers. Post a comment with your numbers — this is exactly the kind of first-hand data that makes prompt engineering a real discipline instead of Twitter folk wisdom.

The one-page decision tree

When you sit down to write a prompt for a new task, this is the order you should try things. Ninety percent of prompts do not need to go past step 3.

1. Try zero-shot first. If the task is well-known (summarize, translate, classify sentiment, extract entities from clean text) and the model is capable (GPT-5, Claude 4.7, Gemini 2.5 Pro), zero-shot is often enough. Ship. If quality is not there, or if the output format is inconsistent, go to step 2.
2. Add structured output. If the issue is format inconsistency — not accuracy — switch to native JSON schema output. This alone solves "the model sometimes returns markdown, sometimes returns JSON, sometimes returns a paragraph." If accuracy is still not there, go to step 3.
3. Add few-shot examples. Three diverse examples with clean formatting. If the task involves multi-step reasoning (math, complex logic, planning), skip to step 4 instead.
4. Add chain-of-thought. Ask the model to reason step by step before giving the final answer. If the task involves external information the model does not have, skip to step 5 instead.
5. Add retrieval or tool use. If the model needs facts it does not know, wire up RAG. If it needs to execute code, call APIs, or search the web, wire up ReAct-style tool calling.
6. Add self-consistency or ToT. Only for high-stakes tasks where the token budget justifies 5–20× the cost. Legal, medical, high-value code generation, competition math.
7. Add self-critique or evaluation loop. For style-sensitive outputs (writing, code review, tone matching) or tasks where a second-pass audit catches most errors.
8. Chain everything together. If your task is genuinely multi-stage — plan, then execute, then verify — chain prompts. Do not try to cram it into a single mega-prompt.

Notice what is not on this list: role prompting, "prompt formatting tricks," triple backticks, "you are the world's best X." These are decorations. They can help at the margins but they are never the answer to "my prompt is not working."

How to combine techniques (real workflows)

In production, prompts rarely use just one technique. Three composite workflows that appear over and over in real 2026 systems:

Workflow 1: extraction pipeline (few-shot + structured output + self-critique)

Task: extract structured facts from unstructured documents (contracts, medical notes, product reviews). The reliable pattern:

1. Prompt 1 (extraction): few-shot with 3 examples of documents → correctly-shaped JSON. Native structured output. Zero temperature.
2. Prompt 2 (critique): pass the extracted JSON back plus the original document. Ask the model: "identify any fields that were extracted incorrectly or missed, produce a corrected JSON." Structured output again.
3. Compare, alert, ship. If prompt 1 and prompt 2 agree, high confidence. If they disagree, flag for human review.

Cost: about 2.5× a single-prompt approach. Accuracy on typical extraction tasks: often high enough to eliminate manual review of the confident subset.

Workflow 2: research agent (ReAct + long-context + self-consistency)

Task: answer a complex research question requiring web search and synthesis. Pattern:

1. ReAct loop: model plans, calls search tool, reads results, plans next call. 4–8 iterations typical.
2. Long-context final: once enough information is gathered, all retrieved sources go into the model's context. The question is placed at the end (mitigates lost-in-the-middle).
3. Self-consistency on the final synthesis: run the final answer 5 times at temperature 0.7. Majority-vote the key claims. Flag any claim without majority agreement.

This is roughly the architecture of the better "deep research" features on ChatGPT, Gemini, and Perplexity in 2026.

Workflow 3: code refactor (tree-of-thoughts + tool use + self-critique)

Task: propose a multi-file code refactor. Pattern:

1. ToT planning: generate 3 candidate refactor plans. Score each on maintainability, risk, and diff size. Pick the top plan.
2. ReAct execution: for each file in the plan, call the file-read tool, apply the change, call the file-write tool. Test after each change.
3. Self-critique: once done, load the final diff. Ask the model: "identify any regressions, style violations, or missed edge cases." Iterate.

This is how tools like Claude Code, Aider, and Cursor's agent mode work under the hood, at rough sketch level.

Common mistakes in 2026 (the ones we still see every week)

• Copy-pasting 2023 prompt templates verbatim. "Act as an expert X" was useful when models were smaller. On GPT-5 and Claude 4.7, most role prompts add tokens without adding capability. Test whether the role actually changes the output before committing to it.
• Using CoT for tasks that do not need reasoning. Zero-shot answers a summarization request just fine. Adding "let's think step by step" bloats the token bill without moving quality.
• Not using native structured output. If your prompt is still doing "output valid JSON, do not include markdown, do not include text before or after the JSON block" — migrate to native schema mode today. Format-compliance goes from ~95% to 100% instantly.
• Ignoring "lost in the middle." Putting the question at the top of a 60K-token prompt and expecting the model to remember it. Repeat the question at the end, or move it there.
• Over-fetching in RAG. Retrieving 50 chunks when 4 would answer the question. More context is not more helpful — irrelevant context is measurably worse than no context.
• Not testing on a held-out set. "It looks good on the three examples I tried" is not evaluation. Build a set of 20–100 gold examples. Run every prompt change against them. Track metrics.
• Ignoring the temperature knob. Temperature 0 is right for extraction, classification, code generation. Temperature 0.7+ is right for brainstorming, self-consistency, creative writing. Using 0.7 for extraction gives you flaky format matches; using 0 for brainstorming gives you 20 identical answers.
• Using the biggest model for everything. A small model with good prompting often beats a big model with lazy prompting on well-defined tasks — at 5–20× lower cost. Migrate hot paths down the size ladder once quality is proven, not up.

How to evaluate a prompt (not just eyeball it)

You do not need a full ML infrastructure to evaluate prompts, but you do need three things: a test set, a scoring function, and a way to run the two prompts you're comparing against exactly the same inputs.

The test set: 20–100 examples that cover the space of inputs your production prompt will see. For classification: balanced across classes. For extraction: mix of easy, medium, and edge-case documents. For generation: cover the tones and topics your users will actually send.

The scoring function: for extraction and classification, exact match against gold labels. For structured output, schema compliance + field-level accuracy. For generation, use an LLM-as-judge (Claude 4.7 scoring GPT-5 output, or vice versa, on a rubric) — imperfect but tractable. GPT-5 self-scoring is biased and should not be trusted.

The comparison: run prompt A and prompt B on the same 50 examples. Compute pass rate. Confidence interval on 50 examples is roughly ±14 pp — if you see a smaller delta, do not conclude one prompt is better; you are inside noise. If you need to detect smaller effects, add more examples.

Tools that help: Braintrust, LangSmith, PromptFoo (open source), or a simple Python notebook with 50 lines of code. The exact tool matters less than the discipline of running the comparison.

FAQ

Is prompt engineering dead now that models are so good?

No. Better models raise what a great prompt achieves; they do not close the gap between a great prompt and a mediocre one. On any task with a specific accuracy, cost, or latency target — which is every production task — the choice among the thirteen techniques above still moves the numbers 10–40 percentage points. That is not dead; that is a lever you use every day. See the full case in the "is prompt engineering dead" analysis.

How is prompt engineering 2.0 different from what we did in 2023?

Three things changed. First, the technique space matured — thirteen named techniques with published performance characteristics instead of "vibes and tweets." Second, context engineering became a first-class problem: what goes with the prompt is often more important than what's in the prompt. Third, orchestration went mainstream — most production LLM systems chain 3–8 prompts together, and each link uses different techniques. The 2023 version was one prompt; the 2026 version is a workflow.

Should I learn all thirteen techniques or focus on a few?

Recognize all thirteen so you can pattern-match the right technique to a new task. Master four in depth: few-shot, chain-of-thought, structured output, and prompt chaining. These four appear in almost every production system. The others are situational tools you reach for when the base kit does not fit.

Which model is best for prompt engineering in 2026?

There is no single winner. GPT-5 and Claude 4.7 lead on reasoning-heavy tasks (CoT, ToT, ReAct benchmarks). Gemini 2.5 Pro leads on long-context and multimodal (1M tokens native, best-in-class chart understanding). GPT-4.1-mini and Claude Haiku lead on cost-per-quality for the well-defined tasks that make up 80% of production traffic. Pick per-task, not per-vendor. See the Claude-specific playbook and RAG vs fine-tuning vs prompting.

What is the cheapest technique that still gives a real quality lift?

Few-shot with 3 well-chosen examples. Token cost goes up by roughly the length of the examples (typically 200–500 tokens for a well-structured example set), and quality lift on format-sensitive tasks is 15–25 percentage points on average. If you can only add one thing to a zero-shot prompt, add few-shot examples first.

Should I still use "let's think step by step"?

Yes for multi-step reasoning tasks — math, logic, planning, symbolic manipulation. No for tasks where reasoning is not the bottleneck — summarization, translation, tone matching, extraction. Kojima et al.'s original 2022 zero-shot CoT paper found the phrase itself is a solid trigger, but any variant that asks for explicit reasoning ("show your working", "list the steps", "reason through this before answering") works about as well.

How does prompt engineering interact with fine-tuning and RAG?

Complementary, not competing. Fine-tuning changes model behavior on a task class you have training data for. RAG injects specific documents at query time. Prompting is how you instruct any of the above to actually use the injected context or apply the fine-tuned behavior. In most stacks the ordering is: try prompting first (cheapest to iterate), add RAG if the model needs facts it doesn't have, fine-tune only if you have thousands of gold examples and a specific task worth the training cost. Full breakdown: RAG vs fine-tuning vs prompt engineering.

Where does GEO fit into all this?

Prompt engineering is how you talk to models. GEO is how you make sure models cite your work when they answer users. They intersect at the input side — a well-structured page (clear H2s, direct answers under each, entity clarity) is easier for a retrieval-augmented model to cite. See GEO vs AEO vs SEO for the citation-side deep dive.

Related guides in this cluster

This is the pillar hub for the Prompt Engineering 2.0 cluster on PromptSpace. Deep-dive articles on each of the thirteen techniques ship weekly — links below will resolve as each supporting article publishes. Meanwhile, jump into the sections above for the one-paragraph-each version.

• Zero-shot prompting: when it works and when it fails — full deep-dive article incoming
• Few-shot prompting with examples: the complete guide — full deep-dive article incoming
• Chain-of-thought alternatives in 2026: beyond step-by-step — full deep-dive article incoming
• Role prompting: the complete guide — full deep-dive article incoming
• Context engineering vs prompt engineering: what's different in 2026 — full deep-dive article incoming
• Structured output prompting: JSON, YAML & schema enforcement — full deep-dive article incoming
• Long-context prompting: how to use 100K+ token windows — full deep-dive article incoming
• Multimodal prompting: images, audio & video — full deep-dive article incoming
• Prompt chaining workflows: complete guide with examples — full deep-dive article incoming
• Self-critique prompts: how to make AI grade its own work — full deep-dive article incoming

Related pillars on PromptSpace

• GEO vs AEO vs SEO: what's the difference in 2026?
• RAG vs fine-tuning vs prompt engineering: which to use in 2026
• Claude prompt engineering: 50 prompts Anthropic approves
• Prompt engineering for beginners: 5 frameworks + examples
• Is prompt engineering dead? The future of AI interface design
• The Midjourney prompt formula that actually works

Sources

1. Brown, T. et al. (2020). Language Models are Few-Shot Learners. arXiv:2005.14165
2. Wei, J. et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903
3. Kojima, T. et al. (2022). Large Language Models are Zero-Shot Reasoners. arXiv:2205.11916
4. Wang, X. et al. (2022). Self-Consistency Improves Chain of Thought Reasoning in Language Models. arXiv:2203.11171
5. Yao, S. et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629
6. Yao, S. et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601
7. Lewis, P. et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. arXiv:2005.11401
8. Liu, N. F. et al. (2023). Lost in the Middle: How Language Models Use Long Contexts. arXiv:2307.03172
9. Shinn, N. et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366
10. Shanahan, M. et al. (2023). Role Play with Large Language Models. arXiv:2305.16367
11. Wu, T. et al. (2022). AI Chains: Transparent and Controllable Human-AI Interaction by Chaining Large Language Model Prompts. ACM CHI 2022

Try these techniques in Prompt Lab → PromptSpace Prompt Lab — copy the templates in this article, run them against Gemini, GPT, and Claude side-by-side, and browse 4,000+ curated prompts organized by technique and use case.