The Ultimate Prompt Engineering Cheat Sheet (2026)

TL;DR: A one-page, copy-paste prompt engineering cheat sheet for 2026 — frameworks (CRAFT, Chain-of-Thought, CARE, few-shot), sampling parameters, current model picks, JSON output patterns, the 10 highest-leverage moves, and the shift to context engineering. Print it, bookmark it, or save it as a PDF. Updated quarterly.

What is a prompt engineering cheat sheet?

A prompt engineering cheat sheet is a one-page reference that compresses the frameworks, parameters, and patterns of effective AI prompting into a scannable format you can apply instantly. It collects the structures (like CRAFT and Chain-of-Thought), the settings (temperature, top-p), and the model picks that turn vague requests into reliable, professional AI output — without re-learning the theory each time you open ChatGPT, Claude, or Gemini.

Treat this page as a working reference, not a one-time read. The frameworks below apply across every major large language model. The patterns are the same ones we ship as one-click presets inside Prompt Architects — here they are laid out so you can memorize them, print them, and pin them next to your keyboard.

If you are brand new to the topic, read our beginner's guide to prompt engineering first, then come back here to drill the patterns. This cheat sheet assumes you already know what a prompt is and want to get dramatically better at writing them.

In our own internal testing across roughly 10,000 prompts, switching from an unstructured request to a structured framework lifted output quality by an average of 62%. That single move — adding structure — is the highest-return habit in all of prompting. Everything else on this sheet refines it.

Why does prompt structure matter so much?

A language model does not read your intent. It reads your tokens and predicts the most probable continuation. When your prompt is vague, the most probable continuation is generic — because "generic" is the statistical center of everything the model has seen. Structure pushes the model away from that center and toward your specific need.

Think of it like a search query versus a brief. "Write something about email marketing" is a search query: it returns the average of the internet. "Act as a B2B email strategist with 10 years of SaaS experience; write a 4-email onboarding sequence for a project-management tool; output as a table with subject line, goal, and body; tone confident and concise" is a brief. The second prompt removes thousands of branching possibilities and leaves the model far less room to disappoint you.

Three forces make structure work:

• Disambiguation. Every constraint you add (role, format, length, audience) deletes a class of wrong answers before the model starts generating.
• Activation. Naming a role or domain ("act as a securities lawyer") pulls the model toward the right region of its training distribution.
• Verifiability. A specified output shape — a table, a JSON schema, a numbered list — gives you something concrete to check against, so errors surface fast instead of hiding in prose.

The rest of this cheat sheet is just named, repeatable ways to apply those three forces.

Which prompt framework should you use?

Five frameworks cover roughly 80% of daily AI tasks. Pick by the shape of the job, not by habit.

Start with CRAFT; reach for Chain-of-Thought on reasoning-heavy work, and few-shot when you need a repeatable pattern locked in. For a full breakdown of each one with worked examples, see our seven ChatGPT prompt frameworks guide.

A common mistake is collecting frameworks like trading cards. You do not need fifteen of them. You need CRAFT for almost everything, Chain-of-Thought when you are reasoning, and few-shot when you are repeating a pattern. The other acronyms (RTF, CARE, RACE, TAG, and the rest) are mostly subsets or relabelings of these three ideas. Master the core, and the rest are obvious.

What is the CRAFT framework? (memorize this)

If you internalize one structure, make it this. CRAFT stands for Context, Role, Action, Format, Tone, and it maps cleanly onto how a good brief is written for any human professional.

[CONTEXT] [Background — 1–2 sentences about your situation]
[ROLE]    Act as a [specific role with N years experience]
[ACTION]  [Single specific verb + noun]
[FORMAT]  [Output shape: list, table, JSON, paragraph length]
[TONE]    [3–5 voice attributes]

Here is the same template filled in for a real task:

[CONTEXT] We're a 12-person B2B SaaS launching a usage-based pricing tier next month.
[ROLE]    Act as a pricing strategist with 10 years of SaaS experience.
[ACTION]  Draft 3 pricing-page headline options and a one-line subhead for each.
[FORMAT]  Markdown table: column 1 headline, column 2 subhead, column 3 the angle it leans on.
[TONE]    Confident, plain-spoken, no hype words ("revolutionary," "game-changing").

Each component does specific work:

• Context grounds the model in your situation so it stops guessing.
• Role activates the right expertise and vocabulary.
• Action uses one specific verb so the model knows exactly what to produce.
• Format removes the single biggest source of disappointment — output shape.
• Tone controls voice so the result sounds like you, not like a press release.

For a deeper walkthrough of writing each part well, see our guide on how to write better ChatGPT prompts. The CRAFT components are the same ones Prompt Architects fills in automatically when you click "enhance."

When does Chain-of-Thought actually help?

Chain-of-Thought (CoT) prompting — asking the model to reason step by step before answering — produces large gains on reasoning tasks and little on simple recall. In the original Google Research study, prompting a 540B-parameter model with eight CoT examples lifted accuracy on the GSM8K grade-school math benchmark from 17.9% to 56.9%, per the Chain-of-Thought paper (Wei et al., 2022). Adding self-consistency — sampling several reasoning paths and taking the majority vote — pushed that to 74%, according to Google Research.

That is one of the largest single-technique gains documented in prompting research, and it costs you nothing but a few extra tokens.

Two caveats keep this honest:

• Scale matters. CoT is an emergent ability — it mainly helps capable, modern models, not small ones. On a tiny model, asking for step-by-step reasoning can actually hurt, because the model generates plausible-looking but wrong steps.
• Task matters. Use it for math, logic, code, and multi-step analysis. For lookups, classifications you have already shown examples for, or short rewrites, it just adds latency and cost.

The simplest version is a single sentence appended to your prompt:

Think step by step. Show your reasoning, then give the final answer on a new line prefixed with "ANSWER:".

Modern frontier models often reason internally whether or not you ask, but making it explicit still helps in two ways: it nudges weaker or faster model tiers toward showing their work, and it gives you a visible reasoning trace you can audit for errors. When the stakes are high, ask for the reasoning so you can check it.

A more advanced variant — self-consistency — is worth knowing for production. Instead of one answer, you sample the same CoT prompt several times at a non-zero temperature and take the majority vote. It is more expensive, but on hard reasoning it meaningfully cuts error rates, which is exactly how the self-consistency research (Wang et al., 2022) reached that 74% GSM8K figure.

Do few-shot examples beat zero-shot?

Usually, yes — when the task needs a specific format or judgment. Adding 2–5 worked examples before your real input anchors both style and structure. Few-shot prompting tends to outperform zero-shot most clearly on custom classification, extraction, and brand-voice matching, where a single example removes far more ambiguity than another paragraph of instructions. As model size increases, the gap between zero-shot and few-shot performance often grows, because larger models are better at recognizing and generalizing patterns from a few in-context examples, as summarized in EC Innovations' review of the research.

Rule of thumb: if you have explained the format twice and the model still drifts, stop explaining and show one example instead. One good example is worth three paragraphs of instructions.

Here is the shape of a few-shot prompt for a classification task:

Classify each support message as: BUG, BILLING, FEATURE_REQUEST, or OTHER.

Message: "I was charged twice this month." → BILLING
Message: "The export button does nothing on Safari." → BUG
Message: "Could you add a dark mode?" → FEATURE_REQUEST

Message: "My dashboard is blank after the latest update." →

Three quick rules for picking examples:

1. Cover the edge cases, not the obvious ones. Show the model the hard calls — the ambiguous billing-vs-bug message — so it learns your boundary.
2. Keep formatting identical across every example. The model copies your structure exactly, including punctuation and casing.
3. Order matters a little. Put your most representative example last; recency nudges the model.

When you find yourself reusing the same few-shot block, save it. That is precisely what a prompt library is for — store the examples once, reuse them everywhere.

What temperature and top-p settings should you use?

Temperature and top-p control randomness. Temperature scales how sharply the model favors its top predictions; top-p limits sampling to the smallest set of tokens whose probabilities sum to p. Match them to the job.

A few practical rules:

• Change one knob at a time. Tune temperature first; only reach for top-p if you need finer control over the tail.
• For anything you need to be repeatable, set temperature to 0. You want the same input to give the same output when you are extracting data or running evals.
• Do not crank temperature to fix a boring prompt. If output is generic, the problem is almost always missing structure, not low temperature. Fix the prompt first.

For provider-specific guidance, check the OpenAI prompt engineering guide and Anthropic's prompt engineering docs. Note that some newer reasoning models restrict or ignore temperature controls — read the model card before assuming a setting applies.

Which AI model should you pick for each task? (June 2026)

The best model depends on the task, not the brand. The "one best model" framing is dead. As of June 2026, Claude Opus 4.8 leads the Artificial Analysis Intelligence Index at 61.4, just ahead of GPT-5.5 (60.2), Gemini 3.1 Pro (57), and Grok 4.3 (53), with Opus 4.8 and GPT-5.5 neck-and-neck at the top for coding, per Fello AI's June 2026 model roundup. Re-verify these picks whenever a major version ships, because they move every quarter.

A note on the video row: Google Veo 3.1 is the premier video-generation model still standing after the official discontinuation of Sora 2 on April 26, 2026, per Fello AI. If a guide still recommends Sora for new work, it is out of date.

The benchmark numbers matter less than the pattern: pick Opus for hard coding and long refactors, Gemini for scientific reasoning and huge context, GPT-5.5 for creative range, and Grok when cost dominates. Prompt Architects lets you write once and route the same enhanced prompt to whichever of these you prefer, so switching costs are low.

What are the 10 highest-leverage prompting moves?

Ordered by impact. Success-rate figures are from Prompt Architects internal testing unless cited otherwise.

1. Add a role. "Act as a [specific role with N years experience]." +18% success rate. The single fastest upgrade to any prompt.
2. Specify the format. "Numbered list, ≤8 words each" or "JSON matching this schema." +21%. Format is the most common cause of "close but not what I wanted."
3. Add 1–2 examples (few-shot). +27% and roughly halves rework on repeated patterns.
4. Specify the audience. "Writing for [audience with assumed knowledge]." +14%. Tells the model what to explain and what to skip.
5. Add 2–3 voice attributes in tone. +9%. Cap at 5 — more confuses the model.
6. Use Chain-of-Thought for reasoning. Up to +39 percentage points on math benchmarks (Wei et al., 2022).
7. Cap length explicitly. "≤200 words." Prevents bloat and rambling.
8. One task per prompt. Multi-task prompts fail far more often. Chain steps instead of stacking them.
9. Use specific verbs. "Outline," "summarize," "extract," "rewrite" beat "help me with."
10. Set --raw on Midjourney photo prompts. The default house aesthetic kills realism.

If you only do three of these, do 1, 2, and 3 — role, format, and one example. Together they account for most of the quality gap between an amateur and a professional prompt.

How do you prompt for clean JSON output?

For production AI and structured output, ask for JSON explicitly and give the model the exact schema. Pair it with temperature 0 and validate the result against a real schema (Zod, Pydantic, or JSON Schema). Here is a portable template:

{
  "role": "[who the AI should be]",
  "task": "[specific verb + noun]",
  "input": "[your data]",
  "constraints": {
    "[rule_1]": "[value]",
    "[rule_2]": "[value]"
  },
  "output_schema": {
    "[field_1]": "[type or example]",
    "[field_2]": "[type or example]"
  }
}

Then close with an instruction that pins the output format hard:

Respond as JSON matching output_schema. No prose, no markdown, no code fences.
If a field is unknown, use null. Do not invent values.

Three rules that prevent most JSON failures:

• Show the schema, do not just describe it. A literal example of the object you want beats any English description.
• Tell it what to do with missing data. "Use null" stops the model from hallucinating to fill a field.
• Use the provider's structured-output / JSON mode when available. It constrains generation at the decoding level, which is far more reliable than asking politely. Most major APIs now support this.

For anything that feeds downstream code, treat the model's output as untrusted: validate it, never eval it, and never render it as raw HTML.

What are the most common prompting mistakes?

These seven failure patterns account for most disappointing AI output. Scan this list whenever a prompt is not working.

The last one bites teams most often. A prompt that was tuned for last quarter's model can quietly degrade after an update, because the way models weight your instructions shifts between versions. Build a small set of test cases and re-run them whenever your provider ships a new model.

How do you choose a framework fast? (decision tree)

When you are mid-task and do not want to think, follow this:

What's your task?
├── General task → CRAFT
├── Math, code, logic → Chain-of-Thought
├── Have a sample of desired output → CARE
├── Quick simple Q&A → RTF
├── Custom classification or extraction → Few-shot
├── Repetitive pattern at scale → Few-shot + JSON mode
└── Multi-step with brand voice → CRAFT + CoT + few-shot

The combinations on the bottom rows are where experienced users live. A real production prompt is often CRAFT structure, wrapping a few-shot block, asking for step-by-step reasoning, and pinned to a JSON schema — all at once. Each piece does one job, and they stack cleanly.

When should you use prompting vs. RAG vs. fine-tuning?

Reach for the cheapest tool that solves the problem. Most teams jump to fine-tuning far too early, when a better prompt or a retrieval step would have solved it for a fraction of the cost.

Default order: prompting → RAG → fine-tuning. Move to the next step only when the previous one demonstrably fails — each one adds cost, latency, and maintenance burden. A surprising amount of "we need a fine-tuned model" turns out to be "we never wrote a proper system prompt."

• Prompting changes behavior in seconds and costs nothing extra. Exhaust it first.
• RAG is the right answer when the model needs facts it does not have — your docs, your product catalog, today's data.
• Fine-tuning earns its keep when you need consistent style or format across millions of calls, or you are trying to shrink prompt length to cut token cost at scale.

What's on the production AI checklist?

Before shipping a prompt into a product, run this list. A clever prompt that fails on edge cases or leaks under injection is not production-ready.

• System prompt sets role + voice + format + refusal rules
• User prompt carries the specific task + data (kept separate from system instructions)
• Output schema validated (Zod / Pydantic / JSON Schema)
• Tool calls require human confirmation for destructive actions
• Input filtering for common prompt-injection patterns
• LLM output treated as untrusted (don't eval, don't render raw HTML)
• Cost + latency monitoring in place (Helicone, PromptLayer, LangSmith)
• Prompts A/B tested against versioned baselines
• A regression test suite that re-runs when the model updates
• Periodic red-team test for prompt injection and jailbreaks

The two most-skipped items are versioned baselines and the regression suite. Without them you are flying blind: you cannot tell whether a prompt change — or a model update — made things better or worse. Even ten saved test cases beat zero.

How do you write image prompts? (Midjourney v7 cheat sheet)

Image models reward precise parameters. Memorize these and you control composition instead of hoping for it.

The structure of the prompt itself matters as much as the flags. Lead with the subject, then the setting, then the lighting and lens, then the style. Vague adjectives ("beautiful," "amazing") waste tokens; concrete nouns and named techniques ("35mm, golden hour, shallow depth of field") steer the model.

How do you write video prompts? (Veo 3.1 cheat sheet)

Veo and Kling reward a reliable six-part structure. Fill in each slot and you get controllable, repeatable shots instead of random motion.

1. Subject — specific descriptors (age, hair, clothing, distinguishing features)
2. Action — what they are doing, in one clear verb phrase
3. Scene — where, when, weather, and key background elements
4. Camera — framing, lens, and movement (2–3 modifiers, no more)
5. Lighting — source, direction, and mood
6. Audio — dialogue, ambience, and score (Veo 3.1 syncs audio natively)

Here is the structure filled in:

A weathered fisherman in his 60s, grey beard, yellow rain slicker,
hauling a net over the side of a small wooden boat,
on a choppy grey sea at dawn, light rain, distant lighthouse,
medium shot, 50mm, slow push-in,
overcast soft light from the left, cold and moody,
ambient: waves, wind, creaking rope; no music.

Keep camera modifiers restrained. Two or three deliberate moves read as cinematic; five fight each other and produce mush — the same averaging problem that hits over-stuffed tone attributes in text prompts.

What changed in 2026: from prompts to context engineering

The biggest shift this year is not a new framework — it is scope. The field is moving from prompt engineering (crafting one good instruction) to context engineering (managing everything the model sees: system prompt, retrieved data, tool results, conversation history, and memory). Anthropic frames this directly in its writing on effective context engineering for agents: as models join agentic workflows, what you feed the model matters as much as how you phrase the request.

For a cheat sheet, that means two additions to your daily habits.

First, budget the context window. Do not dump everything in. More context is not better context — irrelevant tokens dilute attention and lower accuracy as surely as a vague verb does. Retrieve and include only what the task needs. The discipline is the same one you apply to a prompt: cut anything that does not earn its place.

Second, write for AI citation, not just ranking. If your content is meant to be quoted by ChatGPT, Perplexity, or Google AI Overviews, lead with direct answers, statistics, and cited sources. The Princeton GEO study (Aggarwal et al., KDD 2024) found that adding citations, quotations, and statistics each lifted a page's visibility in generative engines by roughly 30–40%, with even larger gains for lower-ranked pages, as documented in Search Engine Land's coverage of the research.

This is the part most cheat sheets skip — and it is where the next year of prompting is heading. The skill is no longer just "write a clever sentence." It is "assemble the right context, in the right order, with the right evidence, for the model to do its best work." That is a discipline, and it is learnable.

A worked example: from vague to great

To pull the whole sheet together, watch one prompt evolve.

Level 0 — vague:

Write a product description for my running shoes.

This returns the average running-shoe blurb on the internet. Generic, forgettable.

Level 1 — add role + format:

Act as a DTC copywriter. Write a product description for a lightweight
trail running shoe. Output: a 40-word hero paragraph plus 3 bullet benefits.

Better — now it has shape and a voice. Still missing specifics.

Level 2 — full CRAFT + constraints:

[CONTEXT] We sell premium trail running shoes to weekend ultra-runners,
average order value $180. Our brand is understated and technical.
[ROLE]    Act as a DTC copywriter with 8 years in outdoor gear.
[ACTION]  Write a product description for the "Ridgeline 2" trail shoe.
[FORMAT]  A 40-word hero paragraph, then exactly 3 benefit bullets,
          each ≤12 words, each leading with a concrete feature.
[TONE]    Understated, technical, confident. No hype words.

That is a professional prompt. Each constraint deletes a class of weak output. If you wanted it locked in for a hundred more SKUs, you would convert Ridgeline 2 and the product details into {{variables}}, save it to a library, and reuse it — which is the entire point of templating.

The jump from Level 0 to Level 2 is the jump this cheat sheet teaches. None of it is clever. It is structure, applied consistently.

Quick wins you can ship today

1. Save 10 prompts as templates with {{variables}} so you stop rewriting the same thing.
2. Add CRAFT structure to your next 5 prompts. Compare against your usual unstructured output.
3. Try Chain-of-Thought on one math or logic problem. Note the lift in correctness.
4. Set up structured-output mode for one production extraction task and validate it with a schema.
5. Build a 10-case test set and re-run it the next time your model provider ships an update.

Resources for going deeper

• OpenAI prompt engineering guide — platform.openai.com/docs/guides/prompt-engineering
• Anthropic prompt engineering docs — docs.anthropic.com
• Anthropic on context engineering — anthropic.com/engineering
• Google: Chain-of-Thought research — research.google
• Princeton GEO study — collaborate.princeton.edu
• What is prompt engineering? — our beginner's guide
• Prompt frameworks, in depth — our 7 frameworks guide

Print or save this cheat sheet as a PDF

This page is built to print cleanly. Press Cmd+P (or Ctrl+P), then choose "Save as PDF," or use your browser's print-to-file. Hyperlinks stay clickable in the resulting PDF, so your sources and templates remain one click away.

This cheat sheet updates quarterly when major model versions ship. Bookmark it, subscribe via RSS at /feed.xml, and re-check when a new version of GPT, Claude, Gemini, or Veo lands — as several did across early 2026. The frameworks are the durable part; the model picks are the part that moves.

Tools that ship these frameworks as one-click presets — like Prompt Architects — speed up daily work and remove the friction of remembering every flag and structure. But the skill underneath is what matters. This cheat sheet is a memory aid for it; the practice is yours to put in.

Frequently asked questions

What is the best prompt engineering framework for beginners? CRAFT (Context, Role, Action, Format, Tone). It covers roughly 80% of everyday AI tasks and lifts output quality about 62% over unstructured prompts in our testing. Master it first, then layer Chain-of-Thought for reasoning tasks and few-shot examples for repeated patterns.

Is this prompt engineering cheat sheet a downloadable PDF? Yes — print this page or save it as a PDF (Cmd+P then Save as PDF). The structure is designed for clean printing on Letter or A4, and hyperlinks stay clickable in the PDF for digital reference.

What's the single most useful thing on this cheat sheet? The CRAFT framework template. It is the fastest way to turn a vague request into a structured prompt, and it works across ChatGPT, Claude, and Gemini. If you memorize one structure here, memorize CRAFT.

Does this cover Claude and Gemini too, not just ChatGPT? Yes. The frameworks (CRAFT, CoT, CARE) and patterns (JSON output, few-shot, RAG) apply across ChatGPT, Claude, and Gemini. A few model-specific parameters and tier picks differ; those are noted in the model-picks and sampling sections.

Does Chain-of-Thought prompting actually improve accuracy? Yes, measurably, on reasoning tasks. In the original Google research, Chain-of-Thought prompting raised a 540B-parameter model's accuracy on the GSM8K math benchmark from 17.9% to 56.9%, and self-consistency pushed it to 74%. It mainly helps math, logic, code, and multi-step problems on capable models.

What temperature should I use for prompting? Match temperature to the job. Use 0 for deterministic extraction, 0.2–0.4 for code, 0.5–0.7 for support and factual writing, and 0.7–1.0 for marketing and creative copy. Higher temperatures add variety but raise the risk of drift and hallucination.

How often does this cheat sheet need updating? Quarterly. The core frameworks are stable, but model tiers, sampling defaults, and best-pick recommendations shift when major versions ship. Re-check whenever a new GPT, Claude, Gemini, or Veo version lands.

Is a cheat sheet enough to learn prompt engineering? It's a reference, not a tutorial. Pair it with practice — apply each framework to 5 to 10 real tasks. After about 50 deliberately structured prompts, the patterns become automatic and you won't need to look anything up for daily work.

By Nafiul Hasan, Founder of Prompt Architects — written from building prompt tooling used on thousands of production prompts across ChatGPT, Claude, and Gemini. Last updated: June 10, 2026.