The internet is overflowing with “powerful AI prompt” articles that promise banned or restricted techniques. Here’s what those articles never tell you: there are no banned prompts. There’s no secret list. What actually separates outputs that are genuinely useful from outputs that are generic is something far less glamorous — structural clarity and constraint.

When you give a large language model a vague task, it completes a vague task. When you give it a specific task with context, examples, a defined output format, and a named role, it’s working from a smaller, better-defined search space. The quality difference isn’t magic. It’s information geometry.

The ten frameworks below are research-backed structural techniques. Each one works for a documented mechanical reason. Each one also has documented failure modes — which most prompt guides never mention, but which will save you hours of frustration.

One honest caveat up front: The research landscape on prompting is messy. Many studies test specific models at specific moments; results don’t always generalize across model families or even across versions. Where a technique’s effectiveness is contested or model-dependent, this guide says so.

In This Guide
  1. Chain-of-Thought (CoT) — and when it stops helping
  2. Few-Shot Prompting
  3. Role Constraint Prompting
  4. Output Scaffolding
  5. Step-Back Prompting
  6. Tree-of-Thoughts
  7. Meta Prompting
  8. Assumption Surfacing
  9. Scenario Branching
  10. Prompt Chaining

We’re at an inflection point in how people interact with language models. In 2023, most users were learning that specificity mattered. By 2025, the research community had catalogued 58 distinct LLM prompting techniques, and a Wharton School study complicated the conventional wisdom around the most popular one. Prompt engineering has matured from an informal art into a field with enough research to have genuine debates about which techniques work and under what conditions.

The practical consequence: knowing when not to apply a technique is now as valuable as knowing how to apply it.

The 10 Frameworks

01

Chain-of-Thought (CoT) Prompting

Reasoning tasks

You ask the model to show its work — to produce a sequence of intermediate reasoning steps before arriving at an answer. The classic trigger phrase is “Let’s think step by step,” but structured CoT provides full worked examples as demonstration.

Why it works A 2022 Google Brain study showed that CoT prompting significantly boosts performance on arithmetic, commonsense, and symbolic reasoning tasks — but only in models above roughly 100 billion parameters. Smaller models that generate illogical intermediate steps actually perform worse with CoT than without it. The mechanism: breaking a problem into steps forces the model to allocate representational capacity to sub-problems rather than jumping directly to an output.
Example prompt
A store sells apples for $0.60 each and oranges for $0.85 each. A customer buys 4 apples and 3 oranges. How much do they spend?Work through this step by step before giving the final total.
Research caveat — important

A June 2025 Wharton study tested CoT prompting against 198 PhD-level questions and found that for dedicated reasoning models (which already perform internal step-by-step reasoning), explicitly requesting CoT added only marginal accuracy gains while increasing response time by 35–600%. The study’s recommendation: use CoT for non-reasoning models or complex multi-step problems. Skip it for reasoning-native models (like OpenAI’s o-series or Claude’s extended thinking mode) — you’re paying the cost without the benefit.

Best for: Multi-step math, logical deductions, structured analysis with sequential dependencies.
Skip when: Using a reasoning-native model, or when response speed and cost are critical constraints.

02

Few-Shot Prompting

Format & tone

You provide 2–8 worked examples of input → output pairs before presenting the actual task. The model uses in-context learning to recognize the pattern and apply it to your query.

Why it works Research consistently shows that the first eight examples provide the largest accuracy gains — accuracy improvements diminish rapidly beyond that point. What matters most is that examples demonstrate the desired format and reasoning pattern, not just the desired answer. Notably, a Google Research study found that even demonstrations with invalid reasoning steps retained 80–90% of the performance gain of valid examples — suggesting that what examples teach is structure and format, not correct reasoning logic.
Example prompt structure
Extract the key action and responsible party from each sentence.Input: "The CFO approved the revised budget on Thursday."Output: Action: approved budget | Party: CFO | Timing: ThursdayInput: "Engineering will deploy the fix by end of week."Output: Action: deploy fix | Party: Engineering | Timing: end of weekInput: "Legal reviewed the contract and flagged three clauses."Output:

Best for: Classification tasks, format extraction, tone matching, domain-specific output structure.
Skip when: You don’t have representative examples, or the task is genuinely open-ended with no target format.

03

Role Constraint Prompting

Expertise depth

You assign the model a specific persona with defined expertise, audience, and constraints before presenting the task. “Act as a skeptical senior product manager reviewing this PRD for a B2B SaaS company” produces a different output than “review this document.”

Why it works Role assignment narrows the model’s active vocabulary, citation patterns, and epistemic stance. A tax attorney role activates different token probability distributions than a general assistant role — the model is statistically more likely to produce domain-appropriate language, caveats, and reasoning patterns. The effect is strongest when the role includes: (1) a specific domain, (2) a defined relationship to the user, and (3) an explicit goal or constraint.
Weak vs. strong role constraint
WEAK:"Act as an expert and review my marketing strategy."STRONG:"You are a growth marketing director at a Series B SaaS company with $2M ARR. Your job is to find assumptions in this go-to-market strategy that would cause it to fail in a market with 3 established competitors. Be specific about which assumptions are unvalidated."

Best for: Domain-specific analysis, critical review, document drafting in a specialized voice.
Skip when: The role you’d assign is generic enough to be meaningless (“expert,” “professional”).

04

Output Scaffolding

Structure & format

You define the exact structure of the desired output — headers, sections, JSON schema, table format, or even partial output that the model must complete. This is especially powerful for structured data extraction and consistent multi-output pipelines.

Why it works By specifying the output format, you eliminate one entire class of decision the model must make. Every token spent deciding how to structure the response is a token not spent on the quality of the content. Scaffolding also makes outputs machine-parseable — critical if you’re using the model in a workflow rather than reading responses manually.
Output scaffolding example
Analyze the following customer review. Return your analysis as JSON only.Schema:{  "sentiment": "positive" | "negative" | "mixed",  "primary_complaint": string | null,  "product_mentioned": string | null,  "urgency": "high" | "medium" | "low",  "suggested_action": string}Review: "[paste review here]"

Best for: Data pipelines, multi-step workflows, any output that needs to be consistent across many runs.
Skip when: The task genuinely requires creative latitude — scaffolding constrains that latitude.

05

Step-Back Prompting

Analysis depth

Rather than asking your specific question directly, you first ask the model for a high-level analysis or overview of the relevant domain, then use that broader framing to ask your specific question. Two prompts, not one.

Why it works Direct questions can trigger pattern-matching to the most common answer rather than genuine reasoning. Step-back forces the model to surface the relevant factors first — making those factors explicit in the context window before the specific question is posed. The second query then benefits from that scaffolded context. As Patronus AI’s research summary notes, this is particularly effective when the user isn’t entirely certain what factors are relevant to their question.
Step-back in practice
STEP 1:"What are the main factors that typically cause a SaaS product's trial-to-paid conversion rate to decline?"[Get response. Then:]STEP 2:"Given those factors, which ones are most likely responsible for our conversion dropping from 18% to 11% over the past quarter, given that our pricing didn't change but we launched a new onboarding flow?"

Best for: Diagnostic problems, situations where you don’t know what you don’t know, complex multi-factor analysis.
Skip when: You already have a clear, well-scoped question — adding Step-Back just adds latency.

“The most useful prompting techniques are the ones that give the model less to decide — not more. Precision isn’t restriction. It’s signal.”

06

Tree-of-Thoughts (ToT)

Complex problem-solving

You instruct the model to explicitly consider multiple solution paths simultaneously, evaluate them, and select the most promising branch. Unlike linear CoT, ToT treats problem-solving as a search across a branching decision tree.

Why it works Standard prompting commits the model to a single solution path. ToT forces the model to hold alternative hypotheses in parallel — better approximating how human experts actually approach novel problems. Research indicates ToT is most effective for problems with many possible solution paths, like strategic planning, design decisions, or creative ideation — tasks where the first answer isn’t necessarily the best answer.
Tree-of-Thoughts prompt structure
Consider this problem: [your problem].Generate three distinct approaches to solving it. For each approach:1. Describe the approach in 2-3 sentences2. List its two strongest advantages3. Identify its most critical weaknessThen evaluate which approach is most promising given [your specific constraints], and explain the selection logic.

Best for: Strategy decisions, design trade-offs, creative problems with no obvious right answer.
Skip when: The problem has a clear correct solution — ToT adds overhead without benefit for well-defined tasks.

07

Meta Prompting

Iteration

You ask the model to help you write a better prompt for the task you actually want to accomplish, before asking it to execute that task. The model generates the prompt; you then use that prompt in a second call.

Why it works Models have been trained on enormous corpora that include effective prompting patterns. They often have implicit knowledge of what constraints and context would improve their own output — knowledge that a user may not possess. Meta prompting surfaces that knowledge explicitly. As Patronus AI describes it: first the model is prompted to generate or refine the prompt, then that generated prompt is used to get the final answer.
Meta prompting flow
STEP 1 — Generate the prompt:"I want to use you to analyze competitive pricing strategies for a B2B SaaS tool. Write the best possible prompt for this task that I should use — include the right context, constraints, output format, and any role you think would improve the analysis."STEP 2 — Use the generated prompt:[Paste model's prompt back in and execute it]

Best for: Novel task types you haven’t done before, situations where you’re unsure what context matters.
Skip when: You already have a well-tested prompt template for this task type.

08

Assumption Surfacing

Critical review

You explicitly ask the model to identify and list the hidden assumptions embedded in a plan, argument, or document — before asking for any recommendations. The surfacing step is separate from the analysis step.

Why it works When you ask “review this plan,” the model tends to evaluate the plan on its own terms — accepting its premises as given. Explicitly asking for assumption extraction first activates a different evaluation mode, producing critique that challenges the frame rather than working within it. This is analogous to the difference between checking math and checking whether you set up the right equation.
Assumption surfacing prompt
[Paste your plan, strategy, or argument]Before evaluating this, identify every assumption it makes — stated or unstated. For each assumption, classify it as:- Validated (evidence exists)- Plausible but unvalidated (reasonable but untested)- Questionable (should be challenged before proceeding)Then, for the three most critical unvalidated assumptions, describe what would need to be true for the plan to succeed if each one is wrong.

Best for: Strategy reviews, investment theses, go-to-market plans, any document where hidden premises drive conclusions.
Skip when: You want a surface-level review and don’t have time to engage with deeper critique.

09

Scenario Branching

Planning

Instead of asking for a single forecast, you ask the model to construct multiple discrete future scenarios — each internally consistent — and then identify the specific decision forks and early-warning signals for each.

Why it works Single-path forecasts are vulnerable to overconfidence: the model produces one plausible narrative and you have no frame for evaluating it. Multi-scenario prompting forces the model to construct scenarios that differ on specific structural variables, surfacing the underlying uncertainty rather than hiding it inside a single point estimate. The output is more honest about what’s actually unknown.
Scenario branching prompt
Construct three scenarios for [situation] over the next 18 months:OPTIMISTIC: Core assumption is [X] holds and acceleratesBASELINE: [X] holds roughly as expected  PESSIMISTIC: [X] fails or reversesFor each scenario:- Describe the causal chain that produces this outcome- Name two early-warning indicators I can monitor starting now- Identify the single decision I should make differently under this scenario

Best for: Career decisions, investment theses, product pivots, any planning with genuine uncertainty about key variables.
Skip when: The situation has low uncertainty and a clear dominant path — forced scenario plurality adds noise.

10

Prompt Chaining

Complex workflows

You break a complex task into discrete sequential sub-tasks, each with its own focused prompt. The output of each step becomes part of the input for the next. No single prompt tries to do everything.

Why it works Context window limitations aside, cognitive load matters in LLMs just as in humans. A prompt asking for research, synthesis, critique, and formatted output simultaneously will tend to underperform on at least one dimension. Chaining isolates each cognitive operation. It also makes failure modes easier to identify — when output quality degrades, you can see exactly which step in the chain is the weak link.
Chaining example — competitive analysis
PROMPT 1: "Describe the core value proposition and target customer of each of these three competitors: [A, B, C]. Return only the positioning summaries."PROMPT 2: "Based on these three positioning summaries [paste output], identify the market segment none of them are explicitly targeting."PROMPT 3: "Given that unclaimed segment, what is the smallest viable product we could build to own it — one that a 4-person team could ship in 8 weeks?"

Best for: Research pipelines, content production workflows, any task requiring sequential reasoning where each step depends on the last.
Skip when: The task is genuinely atomic — chaining a simple task adds complexity without benefit.

Which Technique for Which Task?

The table below is a decision framework, not a ranking. No technique is universally better than another. The right choice depends on task type, model type, and whether you’re optimizing for quality, cost, or speed.

Task Type Best Technique Avoid Note
Multi-step math or logic Chain-of-Thought Direct answer Skip CoT if using a reasoning-native model
Format or tone matching Few-Shot Zero-shot only First 8 examples carry most of the gain
Domain-specific analysis Role Constraint Generic “expert” role Specificity of role drives specificity of output
Data pipelines / structured output Output Scaffolding Open-ended format JSON schema makes output machine-parseable
Diagnostic / “what factors matter?” Step-Back Direct question Use two prompts; not one
Strategy / design decisions Tree-of-Thoughts Single-path answer Multiple paths reveal trade-offs
Unknown what context matters Meta Prompting — Model often knows what it needs
Plan / argument critique Assumption Surfacing General “review” Surface first, then evaluate
Planning under uncertainty Scenario Branching Single forecast Forces honest uncertainty accounting
Complex multi-part workflows Prompt Chaining One mega-prompt Isolates failure points; each step can be verified

Where Prompting Is Heading

Two patterns are reshaping which techniques matter most. First, the models themselves are increasingly handling what prompting used to handle. As the Wharton research found, many modern models already perform some form of chain-of-thought reasoning by default — making explicit CoT prompts redundant for those models. The implication: techniques that structure output format (scaffolding, chaining) are becoming more durable than techniques that try to influence internal reasoning (CoT, step-back) as models internalize better reasoning natively.

Second, prompting is moving from individual interaction toward system design. The IBM guide on context engineering frames it well: as organizations deploy AI in products, the prompt isn’t written once — it’s engineered into a system that handles retrieval, summarization, and structured inputs as a coordinated pipeline. For practitioners building with AI rather than chatting with it, prompt chaining and output scaffolding are already table stakes. The interesting frontier is evaluating which prompts in a pipeline are actually load-bearing versus decorative.

The practitioner who does nothing here faces a specific consequence: as model capability increases, the productivity gap between users who think structurally about prompt design and users who don’t will widen rather than shrink. Better models amplify good inputs; they don’t compensate for vague ones.

The One Thing That Carries Across All of These

Every technique in this list works by reducing the model’s degrees of freedom. Role constraint removes vocabulary ambiguity. Few-shot removes format ambiguity. Output scaffolding removes structural ambiguity. Chain-of-thought removes procedural ambiguity. Step-back removes scope ambiguity.

The failure mode of every bad prompt is that it asks the model to make decisions it doesn’t have enough information to make well. The solution is never to find the magic phrase — it’s to identify which dimension of ambiguity is most likely to cause output drift, and eliminate it before you submit.

The practical upshot: Pick one technique from this list, apply it to the prompt you use most frequently this week, and compare the outputs. The difference won’t be mysterious. It’ll be structural.

“Better models amplify good inputs. They don’t compensate for vague ones. The productivity gap between structured and unstructured prompting widens as capability increases — not narrows.”

Sources

  1. Wei, J. et al. “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models.” arXiv:2201.11903, Google Brain, 2022.
  2. Meincke, L., Mollick, E.R., Mollick, L., Shapiro, D. “The Decreasing Value of Chain of Thought in Prompting.” Wharton Generative AI Labs, June 2025.
  3. Google Research. “Towards Understanding Chain-of-Thought Prompting: An Empirical Study of What Matters.”
  4. Patronus AI. “Advanced Prompt Engineering Techniques: Examples & Best Practices.”
  5. Maxim AI. “Advanced Prompt Engineering Techniques in 2025.” February 2026.
  6. IBM Think. “The 2026 Guide to Prompt Engineering.”
  7. Analytics Vidhya. “Harness the Power of LLMs: Zero-Shot and Few-Shot Prompting.”
  8. Stechly, K. et al. “Chain of Thoughtlessness? An Analysis of CoT in Planning.” NeurIPS 2024.