I wrote this in June 2024, as my notes after reading The Prompt Report, a systematic survey that catalogued 33 vocabulary terms and 58 text prompting techniques across in-context learning, decomposition, ensembling and self-criticism. This is the 2026 update.
That survey was the most complete map of the field, and it was drawn before reasoning models and native tool calling existed. Those two changes, plus a run of 2025-2026 benchmarks, answered the question a taxonomy can’t: which of the 58 still earn their tokens.
The bigger change isn’t in the taxonomy at all. In 2024 prompting was a specialist skill. You wrote prompts if you were building an AI product. Everyone else shipped software without touching one. In 2026 every programmer writes prompts all day.
So this is a pass back through the research: what the newer studies measured, and where those numbers contradict advice that still gets repeated. Almost every claim is paper-backed or straight from provider documentation, linked inline.
What changed
Example count. Then: more exemplars improve performance, with diminishing returns past 20. Now: it depends on the task. Classification climbs past 250, reasoning saturates at 4-125 then degrades, and one example often scores below zero.
Zero-shot. Then: the fallback when you have no examples. Now: the default. On GSM8K, 8 exemplars bought nothing over zero-shot.
Example labels. Then: whether demonstrations must be strictly valid is unclear. Now: settled. Random labels cost 0-5%; format and label space do the work.
Example order. Then: order can swing accuracy from below 50% to over 90%. Now: unchanged and still unfixed. Demonstrations at the start are worth up to 6 points.
Chain-of-thought. Then: a core reasoning technique. Now: math and symbolic only. 95% of the MMLU gain came from questions containing “=”.
“Let’s think step by step”. Then: task-agnostic, works anywhere. Now: deprecated on reasoning models by all three vendors, at 20-80% more response time.
Role prompting. Then: can sometimes improve accuracy on benchmarks. Now: no reliable accuracy gain on current models, and irrelevant persona detail can cost 30 points.
Self-consistency. Then: improves arithmetic, commonsense and symbolic reasoning. Now: collapsed on frontier models, at +1.6 points for 15x the tokens.
Tree of Thoughts. Then: a decomposition technique. Now: still works, at 5-100x the tokens. Batch jobs only.
Temperature and top-p. Then: yours to tune. Now: reasoning models reject them outright.
Agents and tool use. Then: not covered. Now: the loop is an API contract, not a prompt pattern.
Writing the prompt. Then: by hand. Now: optimizers beat reinforcement learning on most tasks, if you have evals.
What prompt engineering is
The working definition is OpenAI’s: “the process of writing effective instructions for a model, such that it consistently generates content that meets your requirements.” The word doing the work is consistently. Getting one good answer out of a model is easy. Getting the same quality on the next thousand inputs is the job.
The smallest version of the whole discipline, from the Prompt Engineering Guide:
Classify the text into neutral, negative or positive.
Text: I think the vacation is okay.
Sentiment: neutral
Text: I think the food was okay.
Sentiment:Output: neutral. One line of instruction, one worked example, one input. The model already knows what sentiment is. The example is there to stop it answering in a paragraph.
Context engineering is the wider frame. Anthropic’s line is that prompt engineering covers “methods for writing and organizing LLM instructions for optimal outcomes,” while context engineering covers curating everything else that lands in the window at inference time: retrieved documents, tool definitions, memory, history. Karpathy’s version is “filling the context window with the right information for the next step.” For a single-turn feature the prompt is most of the game. Inside an agent it’s a subset.
Prompting is part of the development cycle now
A SKILL.md for Claude is a prompt. So is the CLAUDE.md at the root of a project, the description on every tool you hand an agent, every subagent definition in a Claude Agent SDK pipeline, the goal you hand a loop, and the .prompt files in Output. None of those are chat. They ship, they get reviewed, and they break on upgrade.
Which is the part people still underrate. A 2025 migration case study found prompts stabilized for GPT-4-32k passing at only 98% on GPT-4.1 and 97.3% on GPT-4.5-preview. Prompts rot like dependencies, and nothing in CI notices unless you wrote the eval.
Anatomy, and the one part that’s a trust boundary
Instruction with a definition of done, context, delimited input, output schema. That decomposition is old news, and OpenAI’s reasoning guidance still puts it well: “avoid vague instructions by defining what counts as done.” Here it is with all four parts labelled:
# Identity <- role, one sentence
You are a support triage assistant for a B2B billing product.
# Instructions <- instruction, with a definition of done
Assign exactly one category from the list. Output the category name only,
lowercase, no punctuation. If the ticket matches none, output "other".
# Categories <- context the model can't infer
billing_dispute | refund_request | plan_change | access_issue | other
# Ticket <- the input, delimited
<ticket>
Charged twice for the October invoice, need one reversed.
</ticket>Output: billing_dispute. Those delimiters around the ticket are doing real work. They tell the model where your instructions stop and a stranger’s text begins.
The part worth arguing about is where each piece goes. System and developer messages carry higher privilege in the instruction hierarchy OpenAI trains models to respect. Role, rules and output format go there. Untrusted content goes in user messages or tool results, never in a developer message: OpenAI’s agent safety guidance is explicit about not putting untrusted variables there. The message-role split is an access-control decision, not formatting.
Ordering is the part that stopped being portable. Anthropic says to put long documents at the top, above your query, and claims it “improves performance across all models.” Google says the same: all context first, question last. OpenAI’s general guide puts context near the end, but the GPT-4.1 guide recommends instructions both before and after a long document. Three vendors, three answers. Pick per model and measure.
Role prompting got quietly demoted
“You are an expert X” was sold as an accuracy technique. It isn’t one any more, and the vendors have moved without announcing it. OpenAI’s o3 guidance scopes role prompting to “setting the base behavior, tone and outlining the set of actions that are possible.” Anthropic’s Claude Opus 4.6 tutorial goes further: “Skip the role setting... It infers the appropriate level of expertise from the task and context you provide.”
The research is why. A Wharton study found no expert or low-knowledge persona that reliably improved GPQA Diamond across six models, and no significant gain on MMLU-Pro for five of six. Peer-reviewed work found expert personas usually neutral, and models “highly sensitive to irrelevant persona details, with performance drops of almost 30 percentage points.” A 2026 preprint measured a librarian persona dropping mean correctness on Claude Opus from 0.92 to 0.67.
Keep the role sentence for tone and scope. Don’t expect it to make the answers more correct.
The prompt-writing checklist
When a prompt underperforms, the cause is usually somewhere on this list and not in the technique.
State the task and what “done” looks like. Not “summarize this” but “three bullets, under 20 words each, no preamble.”
Say what to do, not only what to avoid. Negative instructions aren’t testable.
Delimit every piece of input with XML tags, Markdown headings, or
""". Pick one convention and hold it.Put the output format in the system or developer message, then enforce it at the API with structured outputs where the schema matters.
One role sentence, task-specific. No stacked adjectives.
Static content first, variable content last so prompt caching can hit the prefix.
Show it to a colleague with no context. Anthropic’s golden rule: if they’d be confused, so is the model.
The foundational techniques, re-scored
Zero-shot is the default, not the baseline
A peer-reviewed 2025 paper put Qwen2.5-72B-Instruct on GSM8K at 95.83 zero-shot with corrected answer extraction, against 95.75 with 8-shot exemplars. The examples bought nothing.
One example is the count most likely to make things worse. GPT-4o-mini on AG News scored 0.8446 F1 at zero-shot, dropped to 0.8248 at one shot, and only passed its own baseline at two (arXiv:2607.22969). GPT-5 on biomedical QA does the same thing: 0.762 zero-shot, 0.737 at one shot, 0.768 at five (arXiv:2509.04462). If you shipped a one-shot prompt without testing zero-shot, you may have paid tokens to lose accuracy.
Start zero-shot with an explicit output format. Add machinery when your evals show a gap, not in advance.
Few-shot examples are versioned config
Two to five labeled pairs, for patterns that are easier to show than to describe: a house style for summaries, an odd label taxonomy. Anthropic is the only vendor that publishes a number, and it’s “3-5 examples for best results.” OpenAI says “a handful.” Google says experiment, and to “always include few-shot examples.”
What examples teach is narrower than most people assume. Replace the gold labels in your demonstrations with random ones and accuracy falls 0-5% absolute. You can watch it happen:
This is awesome! // Negative
This is bad! // Positive
Wow that movie was rad! // Positive
What a horrible show! //Output: Negative. Correct, despite every label above it being wrong. The examples transmitted the label space and the // format, not the answers. Strip the format and you do worse than no examples at all.
The fragility is the story. The accuracy gap between demo-selection algorithms reached 45% on MRPC. Moving demonstrations from the front of a prompt to the back flipped over 30% of QA predictions in a 2025 study, without improving correctness. Google warns that too many examples cause overfitting, and examples buried mid-prompt hit the “lost in the middle” positional problem.
Three inputs that all look like cosmetics (which examples, how many, where) move accuracy more than most model swaps do. Formatting alone is in the same range: researchers who changed nothing else measured GPT-3.5-turbo differences of up to 40% on code translation. Version the examples, diff them, cover them with evals.
Two rules with numbers behind them. Put demonstrations at the start: best position across ten model families, worth up to 6 points, and it puts the stable text where the cache can reach it. And never sort examples by label: at 1,169 shots on Clinic-150 that cost 25.7 points.
Chain-of-thought is mostly a math-formatting effect
The technique arrived twice. The first version needed eight hand-written reasoning chains per task, which is real authoring work for one prompt. Four months later, most of that gain turned out to be free: five words appended to the question, Let’s think step by step. On text-davinci-002 that took MultiArith from 17.7% to 78.7% and GSM8K from 10.4% to 40.7%, with no examples at all.
Their Figure 1 is still the clearest before-and-after:
A juggler can juggle 16 balls. Half of the balls are golf balls, and half of the golf balls are blue. How many blue golf balls are there?
Without the trigger the model answers 8. It halves once and stops. With it: “There are 16 balls in total. Half of the balls are golf balls. That means that there are 8 golf balls. Half of the golf balls are blue. That means that there are 4 blue golf balls.”
CoT pays when the answer needs two or more steps that depend on each other, and answering directly collapses them into one.
A meta-analysis of more than 100 papers put it at +14.2 pp on symbolic reasoning, +12.3 pp on math, and no meaningful gain on commonsense tasks. 95% of CoT’s total MMLU gain came from questions containing “=” in the question or output.
Where it works, it’s decisive. +59.9 pp on GSM8K for Llama-3.1-8B-Instruct, and Qwen-2.5-7B-Instruct went from 23.1% to 91.1% on GSM8K in the same 2026 study.
Where it doesn’t, it costs you. The same Qwen model dropped 28.7 points on HumanEval code generation. Forcing explicit steps cut o1-preview accuracy by 36.3% absolute on implicit-learning tasks. On reasoning models, prompted CoT bought small GPQA gains for 20-80% more response time, and 35-600% longer responses on non-reasoning models.
Use it for math and symbolic work on non-reasoning models. On reasoning models, use the native control instead: Gemini 3 guidance says to replace CoT prompting with thinking_level: 'high' and simplified prompts.
One thing to know before you show a reasoning trace to anyone. Causal mediation across twelve models found GPT-4 changed its answer only 30% of the time when its reasoning chain was swapped for a perturbed one. CoT changes accuracy; it does not give you an audit trail.
The advanced techniques, and what they cost
Tree of Thoughts belongs in batch jobs
Tree of Thoughts branches several candidate thoughts per step, scores them, and searches with BFS or DFS. Game of 24 with GPT-4: 74% success against 4.0% for CoT.
The appendix prices it at 0.47 for best-of-100 CoT, and the authors say it “could require 5-100 times more generated tokens than CoT” depending on the search setup. My judgment, not a paper’s: batch jobs on search-like problems, planning and constrained generation. I’ve never found a user-facing path where the latency was acceptable, and I don’t have a controlled benchmark behind that.
ReAct survived as a loop, not as a parser
ReAct interleaves Thought → Action → Observation: 71% task success on ALFWorld against 45% for action-only prompting.
In 2026 the loop is an API contract. The assistant turn carries the thought as text and the action as a structured block:
{
"stop_reason": "tool_use",
"role": "assistant",
"content": [
{ "type": "text",
"text": "I'll check the current weather in San Francisco for you." },
{ "type": "tool_use",
"id": "toolu_01A09q90qw90lq917835lq9",
"name": "get_weather",
"input": { "location": "San Francisco, CA", "unit": "celsius" } }
]
}You run the tool and send the observation back as a user message, keyed to the call:
{ "role": "user",
"content": [{ "type": "tool_result",
"tool_use_id": "toolu_01A09q90qw90lq917835lq9",
"content": "15 degrees" }] }Failures go back the same way with "is_error": true rather than being swallowed; the model recovers better from a visible error than from a silent one. Loop while stop_reason is tool_use, exit on end_turn. Anthropic’s docs never say “ReAct”; the mapping is structural. If you are still regexing Action: out of free text, that’s a 2023 artifact.
The Thought half is the contested part. A peer-reviewed 2025 study found performance “is minimally influenced by the interleaved reasoning trace.” StateAct scored 27.80% on WebShop with the thought step removed against ReAct’s 17.80%. When2Tool is the alarming one: adding Reason-then-Act dropped Llama-3.1-8B tool accuracy from 79.5% to 31.2%.
It cuts the other way too. Anthropic’s think tool with tuned prompting hit 0.584 on τ-bench Airline against a 0.332 baseline, beating native extended thinking at 0.412. ToolGT found structured templates beat free-form CoT which beat no thought at all.
Both results can be true. Models trained for native tool calling already know what to call, so an extra verbal layer is at best neutral. Text-formatted agents still benefit. Test with the trace and without it rather than assuming.
Self-consistency has collapsed on frontier models
Self-consistency samples several CoT paths at nonzero temperature and takes the majority answer. On PaLM-540B and GSM8K that went from 56.5 to 74.4 at 40 paths, with 5-10 paths capturing most of it. Early-stopping variants matched 40-sample accuracy on GSM8K at an average of 14.65 samples.
Now run it on a frontier model. Gemini-2.5-Pro on MATH-500 goes from 98% at one path to 99.6% at 15. A 1.6-point gain for roughly 15× the tokens.
RAG is the cheap option, not just the grounded one
The grounding case is well known: in the XRAG benchmark, GPT-4o went from 6.30% accuracy without retrieval to 75.40% with oracle retrieval.
The cost case gets skipped. The Token Tax study priced long-context prompting at ~4.50 for semantic RAG on the same manufacturing benchmark. Roughly 26× for stuffing the window instead of retrieving into it.
One failure mode to measure for: a 2026 Springer benchmark found hybrid retrieval sometimes increased hallucination in smaller models even as retrieval recall improved. Score faithfulness, not just recall.
Let the optimizer write it
The newest option here is to stop writing the prompt yourself.
GEPA runs a candidate prompt on a minibatch, captures the traces and whatever the environment said back (compiler errors, judge notes), and shows a reflection model the whole tuple so it can propose a revision. It keeps a Pareto frontier of candidates that win on at least one example rather than one global best. On GPT-4.1 Mini across six benchmarks it beat MIPROv2 by more than double: +12.19 aggregate against +5.64. Against GRPO reinforcement learning it won five of six tasks, by up to 19 points, using up to 35× fewer rollouts.
Prompt evolution now beats reinforcement learning on most tasks at a fraction of the sample cost, which was not true in 2024.
The prerequisites are the catch, and they’re the same three things evals need: a metric that scores an example, a representative dataset, and a test set you haven’t touched. Without them it optimizes noise. Across 72 optimization runs on Claude Haiku 4.5, 49% scored below zero-shot: a coin flip, driven by eval sets too small to measure with.
Three more things worth knowing before you reach for it. More data is not better: Decagon found peak performance at 20 samples, with 500 costing 2% accuracy and 75% prompt bloat. The reflection model has to be strong, since a weak one returns your seed prompt nearly unchanged. And it optimizes around bugs rather than fixing them. GEPA drove a defective GSM8K seed from 23.81% down to 13.50% while the root cause sat there untouched.
We haven’t put this in production at GrowthX. Our prompts change faster than a compile cycle would pay for, which is a statement about our release cadence rather than about GEPA.
Sampling settings: mostly stop tuning them
OpenAI. Temperature 0-2, no stated default, no top_k support. Reasoning control is reasoning_effort.
Anthropic. Temperature 0.0-1.0, default 1.0, top_k documented for advanced use only. Reasoning control is effort, the adaptive-thinking parameter.
Google Gemini. Temperature 0.0-2.0, default 1.0, top_k supported and fixed at 64 on Gemini 2.5 Pro. Reasoning control is thinkingLevel or thinkingBudget.
On classic models the advice is unchanged: 0-0.3 for extraction, classification and function calling, 0.7-1.0 for creative generation, and alter temperature or top_p “but not both.” OpenAI’s cookbook uses temperature=0 for function calling and 0.2 for structured summarization.
On reasoning models, the knobs are being taken away. Anthropic’s Claude Opus 5 / Sonnet 5 generation returns a 400 error on non-default temperature, top_p, or top_k; you steer with the adaptive-thinking effort parameter. Google’s Gemini 3 guidance recommends keeping temperature “at its default value of 1.0” and warns that lowering it can cause looping and degraded reasoning. On reasoning models there is close to nothing left to tune.
The caveat that bites people writing tests: Anthropic documents that “even with temperature of 0.0, the results will not be fully deterministic,” and Google says the same. Exact-match assertions on model output will flake.
Prompting inside an agent loop
Single-turn prompting is one shot at getting the wording right. Agent prompting has to survive dozens of iterations, each one putting tool output back into the window.
Tool descriptions are prompt engineering. Anthropic calls them “by far the most important factor in tool performance” and asks for 3-4 sentences minimum. The evidence backs the emphasis: renaming functions to
func_Nsignificantly drops performance, and tools with edited descriptions get over ten times more usage. OpenAI’s version is the intern test: could a human use this function given only what you gave the model? Say when to use a tool and when not to; hedged instructions like"If in doubt, use [tool]"cause overtriggering.Make invalid states unrepresentable. Enums for finite sets,
user_idnotuser, documented ranges. Turn on strict mode, and note it disables parallel tool calls.Narrow the mandate per step. OpenAI’s Atlas hardening guidance says to “avoid overly broad prompts like ‘review my emails and take whatever action is needed.’” Broad mandates compound errors across steps and widen the injection surface.
Curate state, don’t accumulate it. Decide at each step what history and retrieval results enter the window, and filter tool output the same way.
Tool output is untrusted input. Anything a tool fetched from a third party is attacker-controlled text arriving inside your loop.
Frameworks are checklists, not engineering
Three have published provenance. CLEAR (Leo S. Lo, Journal of Academic Librarianship, 2023) is Concise, Logical, Explicit, Adaptive, Reflective, and works as a review rubric. PROMPT Design (Sarah Hartman-Caverly, Penn State, 2024) is a fill-in-the-blanks scaffold for non-engineers; the academic AI PROMPT framework covers similar ground with more emphasis on delimiting elements and token length. PASTAS (Lo again, portal: Libraries and the Academy, 2026) was written for the agentic era, and its Tools and Safeguards items map onto the two sections above.
They help a team remember requirements. They don’t replace measuring: a CLEAR-compliant prompt that fails your evals is still a failed prompt.
Fine-tuning is still the last resort
Every provider now documents the same sequence: evals, prompting, RAG for external knowledge, fine-tuning when prompting hits a measured ceiling. OpenAI’s model-optimization guide says “the prompt engineering process may be all you need,” and its fine-tuning platform is winding down, with existing users able to create training jobs only “for the coming months.”
The thresholds worth holding to:
Volatility. Microsoft’s split is dynamic content → RAG, stable content → fine-tuning. Hamel Husain’s version: “fine-tuning works best to learn syntax, style and rules whereas RAG works best to supply the model with context or up-to-date facts.”
Example count. OpenAI recommends 50 well-crafted demonstrations for SFT; a peer-reviewed 2025 study puts the classification break-even near 100 labeled examples. At 20-40, Jason Liu argues you are better off with prompt caching.
Good enough. The applied-llms.org rule: “if prompting gets you 90% of the way there, then finetuning may not be worth the investment.”
The bill nobody quotes. Husain estimates “99% of the labor involved with fine-tuning is assembling high-quality data.” The LIMA result cuts both ways: 1,000 curated examples fine-tuned a 65B model to outputs preferred over GPT-4’s in 43% of comparisons. Quality beats volume, and curating 1,000 excellent examples is still real work.
Prompt caching is the middle path in production. Anthropic prices cache reads at 0.1× base input and AWS says caching can cut costs up to 90%. At GrowthX our source material changes weekly, so we’ve stayed on prompting plus RAG. I haven’t hit a case where a fine-tune was worth the data-assembly cost, which is a statement about our volatility rather than about fine-tuning.
Security: assume the prompt leaks and the tools lie
The documented record includes 15+ named injection incidents between 2022 and 2026, and in 2026 alone five CVE identifiers across four agent-framework incident groups. Google measured a 32% relative increase in malicious prompt-injection categories on the web between November 2025 and February 2026.
Injection. Riley Goodside demonstrated it publicly against GPT-3 in September 2022. By 2025 it was zero-click: EchoLeak (CVE-2025-32711) exfiltrated data from Microsoft 365 Copilot with no user interaction. Researchers reported successful injections in 56% of 144 tests across 36 models. Wording will not save you; the mitigations are architectural. Anthropic’s guardrail guidance says to deliver third-party content inside tool_result blocks, keep it out of system prompts, and JSON-encode it so delimiters are unambiguous. OpenAI’s agent guidance adds that defense “cannot rely only on filtering inputs. It also requires designing the system so that the impact of manipulation is constrained.” Least privilege per tool, confirmation before irreversible actions.
Leaking. Kevin Liu pulled Bing Chat’s “Sydney” instructions in February 2023. OWASP’s guidance is that “the system prompt should not be considered a secret, nor should it be used as a security control.” Keep credentials and keys out of the prompt; assume it leaks.
Jailbreaking. From DAN to Best-of-N attacks at 89% success on GPT-4o with 10,000 augmented prompts. Layered classifiers are the answer that measures: Anthropic’s Constitutional Classifiers cut jailbreak success from 86% to 4.4%. Google Cloud’s Model Armor screens prompts and responses, OpenAI’s free Moderation API covers the basics.
OpenAI calls adversarial robustness “a hard, open problem,” and Anthropic notes that even a 1% attack success rate “still represents meaningful risk.” Budget for defense in depth from day one if your agent reads email or the open web, both channels the Gemini promptware research weaponized.
Where prompts usually break
Negative framing. “Be concise” is not testable. Anthropic recommends the positive form: instead of
"Do not use markdown", write"Your response should be composed of smoothly flowing prose paragraphs."No output schema. It breaks parsers, and per OpenAI’s safety docs structured outputs also “eliminate freeform channels that attackers can exploit.” One constraint, two problems.
Trusting the documented context window. Performance degrades 13.9%-85% within claimed windows, with relevant information missed in middle positions. We hit it ourselves: a vendor documented 128,000 tokens and our task started degrading well before that. Retrieve less, better.
Technique for technique’s sake. CoT cost o1-preview 36.3 points on implicit-learning tasks, and in a 2026 medical study it cut accuracy 5.7% while few-shot examples cut it 11.9%.
Not reading what your framework sends. Husain’s prompt inspection found LangChain’s SmartLLMChain shipping a typo (
'Let'w') in its critique prompt and Guidance making 7 API calls where 2 sufficed. Log the raw request once per integration, minimum.
Evals are the job
Draft, run against a fixed test set, score, change one variable, version like code. The loop exists because output varies: even temperature 0 isn’t deterministic, so one passing run proves nothing.
This is the reasoning behind Evals Driven Development: repeated runs scored against a rubric instead of exact-match assertions. After we rewrote the rubric, the measured pass rate on our 60-query test set went from 74% to 86%. That number is ours; the method transfers. Shreya Shankar’s guidance to review at least 100 traces before designing any rubric matches our experience: rubrics written before error analysis test failures that never happen.
The checklist:
Collect 50-100 real inputs before writing the prompt. Include the ugly ones.
Simplest zero-shot prompt with an explicit output format, run 3-5 times per input.
Error analysis first, rubric second, written from observed failures.
One variable at a time: wording, examples, format, technique.
Version every prompt, log every run. PromptLayer’s registry documents version diffs and release labels; LangSmith and Langfuse do the same job. Ours lives in Output, where prompts and evals sit next to traces and cost tracking in the repo. Disclosure: Output is my open-source project.
Gate merges on eval regressions. DeepEval runs in pytest with an
--officialbaseline; the pattern generalizes.Track tokens and cost per prompt version next to quality. A quality win that doubles spend is a decision, not a detail.
Calibrate LLM judges against human labels before trusting them, and score asynchronously where you can. Synchronous judging adds seconds per request.
FAQ
How do I pick a technique? Zero-shot with an output format. Few-shot when the pattern resists description. CoT for math and symbolic work on non-reasoning models, native thinking controls on reasoning models. Self-consistency or ToT only for batch work where an eval shows a gap worth 5-100× the tokens. RAG when the knowledge is external, changes often, or is cheaper to retrieve than to stuff.
How many examples should I use? Anthropic says 3-5 and is the only vendor publishing a number. The rule that matters more: measure zero-shot and 2-5 shots before you commit, because one example often scores below none.
What temperature should I use? 0-0.3 for extraction and function calling, 0.7-1.0 for creative work, one of temperature or top_p but not both. On reasoning models, leave it alone and use reasoning_effort, effort, or thinkingLevel.
Should I tell the model it’s an expert? For tone and scope, yes, one sentence. For accuracy, no. No vendor has published a controlled ablation showing it works on a current reasoning model, and irrelevant persona detail has measured costs.
When does fine-tuning beat prompting? When prompting has a measured ceiling, the target is a stable style or format, and you have 50-100+ curated examples plus appetite for the data work. Below that, caching and RAG are cheaper.
Should I use an automatic prompt optimizer? Only if you already have an eval suite, a few hundred representative examples, and a held-out test set. With those, GEPA is the strongest thing available. Without them, half the runs come out worse than zero-shot.
Minimum security posture for a prompted feature? Assume the system prompt leaks, so keep secrets out of it. JSON-encode untrusted input and keep it out of developer messages. Least privilege per tool, a classifier on inputs, confirmation before irreversible actions.
Is prompt engineering a viable career in 2026? No, and it never was. It was a job title minted by a hype cycle. The University of Oulu study found 72 exact-title postings out of 20,662, under 0.5%.
The skill went the other way. Lightcast counted mentions rising from ~1,400 in 2023 to ~6,300 in 2024, and O’Reilly measured 456% year-over-year growth in prompt engineering content usage. It became part of the job, like knowing how to write a migration.
“Loop engineering” is the 2026 reprise of the same bs. Real skill, fake title. Learn it as part of the stack.
The 2024 version of this post aged in two years. This one will too, and the part that ages first is always the benchmark numbers rather than the method. If you run these against your own eval set and get different numbers, I want to hear about it. Mine are one team’s.