Most best-practice lists are platitudes you forget by lunch: "be clear," "be specific," "iterate." True, useless, gone. These are opinionated, hard-won practices with the reasoning behind each one spelled out, so you understand not just what to do but why it works and when to break the rule.
We have organized them by the order they pay off. The early ones produce the biggest quality jumps for the least effort. The later ones are refinements that matter once your fundamentals are solid. Apply the first three and you will already be ahead of most people who use AI daily.
A warning: best practices are defaults, not laws. The point is to understand the principle so you know when a situation calls for the exception. Cargo-culting rules without understanding them is how you end up with a bloated prompt full of incantations that do nothing.
Practice 1: Show, Don't Tell
The highest-leverage practice in prompting is including an example of what you want rather than describing it. Want a specific tone, format, or structure? Paste one good sample and say "produce another like this."
Why it works: models pattern-match against concrete examples far more faithfully than against abstract descriptions. "Write in a witty, conversational tone" is interpreted a hundred ways. One witty paragraph as a model removes the ambiguity entirely. When in doubt between explaining and demonstrating, demonstrate. Our examples guide is built around this principle.
Practice 2: Separate Instructions From Data
When your prompt includes both commands and content to operate on, wall them off with delimiters: tags, triple quotes, or headings. Tell the model which part is which.
Why it works: without separation, the model can mistake your pasted content for instructions, or your instructions for content to process. A 1,000-word document pasted next to "summarize this" sometimes gets treated as a wall of competing commands. Wrapping it in <document>...</document> eliminates the ambiguity. This single habit prevents a whole class of confusing failures.
Practice 3: Constrain Toward a Point of View
Generic prompts produce generic, hedge-everything output. The fix is constraints that force commitment: a specific audience, a length limit, a required stance, a forbidden cliché.
- "For a skeptical CFO" beats "for a general audience."
- "In under 100 words" forces prioritization.
- "Take a clear position; do not present both sides neutrally" produces actual argument.
Why it works: constraints narrow the model's enormous space of average responses toward a sharper region. The best content has a point of view, and you usually have to demand one explicitly. The common mistakes guide covers vagueness as the flip side of this practice.
Practice 4: Ask for Reasoning Before Conclusions
For any task involving analysis, logic, or judgment, instruct the model to work through its reasoning before stating a conclusion.
Why it works: generating the reasoning first gives the model intermediate steps to build on and lets it catch its own errors, which measurably improves accuracy on anything non-trivial. The trade-off is longer, slower output, so reserve this for tasks where correctness matters more than speed. For a simple lookup, skip it; for a recommendation you will act on, demand it.
A practical variant
Ask the model to "list the considerations, then weigh them, then give a recommendation." The forced structure produces a more defensible answer than asking for the recommendation alone.
Practice 5: Make the Model Admit Uncertainty
Add an explicit escape hatch: "If you are not sure, say so. Do not guess." Then provide source material and forbid outside information for any fact-dependent task.
Why it works: by default, models produce fluent, confident text even when fabricating. Giving permission to say "I don't know" and grounding the task in provided sources dramatically reduces invented facts. This is the difference between a tool you can trust and one you have to fact-check line by line. The how-to guide builds this guardrail into its step-by-step process.
Practice 6: Position Your Most Important Instruction at an Edge
Put the single instruction that matters most at the very start or very end of your prompt, and give critical constraints their own sentences rather than burying them in a paragraph.
Why it works: models weight the beginning and end of a prompt more heavily than the middle, and they follow standalone instructions more reliably than ones tangled into prose. If something absolutely must happen, do not make it compete for attention in the middle of a wall of text.
Practice 7: Build and Reuse Templates
Once a prompt works reliably, parameterize it. Replace the specifics with labeled slots and save it. Over time you build a small library of proven prompts for your recurring tasks.
Why it works: you do the careful design work once and reuse it indefinitely, which compounds. The alternative, re-improvising every prompt from scratch, wastes the effort you already invested and produces inconsistent quality. The checklist makes a good final review before you promote a prompt to a saved template.
How to Sequence These Practices
You do not adopt all seven at once. Layer them in the order they pay off. Start with show-don't-tell and separating instructions from data, because together they fix the majority of format and confusion failures for almost no effort. Add constraints next to escape generic output. Only once those defaults are second nature should you reach for reasoning prompts, uncertainty escape hatches, and edge-positioning, which are refinements rather than foundations.
The reason sequencing matters is that practices have diminishing returns when stacked carelessly. A prompt drowning in every guardrail and constraint becomes hard for the model to follow, which is its own failure mode. The goal is the minimum structure that reliably produces the output you want, then stop. When you find yourself adding a sixth constraint and quality is not improving, that is the signal you have passed the useful point. Our common mistakes guide covers the over-engineering trap from the opposite direction.
Frequently Asked Questions
If I can only adopt one practice, which should it be?
Show, don't tell. Including a single concrete example of your desired output controls format and style better than any amount of description. It is the practice with the highest ratio of quality gained to effort spent, and it works across virtually every task.
Do these practices apply to all AI models?
The principles transfer broadly because they reflect how language models work, not quirks of one product. Examples, structure, constraints, and reasoning prompts help everywhere. Minor details, like preferred delimiters or how strictly system prompts are followed, vary, so tune at the margins once your fundamentals are in place.
Won't adding all this structure make my prompts bloated?
It can if you apply every practice mechanically. The skill is matching practices to the task: a simple question needs almost none of this, while a high-stakes analysis needs most of it. Add structure where it earns its keep and stop when more structure stops improving output.
Why does asking for reasoning improve accuracy?
Generating intermediate steps gives the model room to build toward a conclusion and to catch contradictions along the way, rather than committing to an answer in a single leap. The cost is longer output, so reserve it for tasks where being right matters more than being fast.
How do I keep the model from sounding generic?
Force a point of view with constraints: a specific audience, a required stance, a length limit, a banned cliché. Generic output is the model defaulting to the average of everything it has seen. Constraints push it off that average toward something with an actual perspective.
Key Takeaways
- Show examples instead of describing; it is the single highest-leverage practice.
- Separate instructions from data with delimiters to prevent confusion.
- Use constraints to force a point of view and escape generic output.
- Ask for reasoning before conclusions on tasks where correctness matters.
- Position critical instructions at the edges and turn proven prompts into reusable templates.