Prompt Engineering Cheat Sheet: Techniques, Tables, and Templates
This prompt engineering cheat sheet collects the core techniques, when each one helps, and the common mistakes to avoid, all in reference tables you can scan quickly. Use it as a quick lookup while writing prompts rather than a fixed rulebook — models change, so test what works on the one you are using.
Techniques at a glance
| Technique | When to use it | What it does |
|---|---|---|
| Role or persona | A task needs a specific expertise level | Sets the context and vocabulary the model uses |
| Clear, specific instruction | Most prompts, as a baseline | Removes ambiguity about the goal and format |
| Few-shot examples | The output format keeps coming out wrong | Shows the desired pattern through examples |
| Chain of thought | Multi-step reasoning, math, or logic | Asks the model to work through steps before answering |
| Structured output | You need JSON, a table, or fixed fields | Makes the response predictable and easier to parse |
| Constraints | Output is too long, short, or off-topic | Adds explicit limits and rules |
| Step-by-step | Tasks with several parts | Breaks the job into ordered actions |
| System prompt | Consistent behavior across conversations | Holds standing instructions in one place |
| Temperature control | Output is too random or too flat | Adjusts how varied the response is |
The building blocks of a prompt
A reliable prompt often combines a few standard pieces. You do not need every block each time, but each does a specific job.
- Role — who the model should act as.
- Context — the background information it needs.
- Action — one clear verb describing the output.
- Format — the exact shape of the result, such as a list or table.
- Tone — the voice and level of formality.
- Constraints — what to include, avoid, or limit.
Anti-patterns and fixes
| Anti-pattern | Why it hurts | Fix |
|---|---|---|
| Vague request | Gives the model too much room to guess | Add the goal, format, context, and limits |
| No examples for a tricky format | The model invents its own structure | Provide one or two examples of correct output |
| Instructions buried in long text | Key points get overlooked | Put important instructions clearly, often at the start or end |
| Asking for many things at once | The model may drop part of the task | Split complex jobs into separate steps |
| No edge-case handling | Unusual inputs produce inconsistent results | State how to handle unknowns or missing information |
| Never testing changes | A tweak can quietly break other cases | Re-run a small set of test prompts after edits |
A copy-ready template
Role: You are a [expertise] assistant.
Context: [background the model needs].
Task: [one clear action].
Format: [list, table, JSON, or length].
Tone: [voice and formality].
Constraints: [what to include or avoid].
Replace each bracket with concrete details. If the result is still off, add a short example of the output you want before changing anything else.
A simple self-check before you send
- Does the first line make the goal obvious?
- Is the output format stated explicitly?
- Did I include the context the model cannot know?
- Have I named what to avoid, not just what to do?
- For complex tasks, did I ask for steps rather than a single leap?
- If I changed the prompt, did I re-test it on a few cases?
How to use this with structured work
For repeatable tasks, keep a short library of tested prompts rather than rewriting from memory. When a prompt fails, group the failures — formatting, missing facts, broken rules, edge cases — and fix the largest group with one change, then re-run the whole set. That keeps improvements measurable instead of trial and error.
Frequently asked questions
Do I need to use every technique? No. Start with a clear instruction and add techniques only when a specific problem appears. More complexity is not automatically better.
Which technique helps most with formatting? Few-shot examples and an explicit structured-output request are usually the first things to try when the shape of the answer is wrong.
What is the difference between a system prompt and a normal prompt? A system prompt holds standing instructions that apply across a conversation, while a normal prompt carries the specific task for one turn.
Should I memorize these tables? Treat them as a reference. The goal is to recognize which problem a prompt has and pick the matching technique, then verify it on your model.
Key takeaways
- Match each technique to a specific problem rather than stacking them all.
- Clear instructions, examples, and a stated format resolve a large share of prompt failures.
- Anti-pattern tables help diagnose why a prompt is underperforming.
- Test prompts on a small set of cases and re-run them after every change.
Read next: how to write AI prompts, advanced prompt techniques, and how AI prompt templates work.
Sources
Learn by doing
Read a guide, then practice with bite-sized AI lessons you can take offline.
Start learning free