12 Reusable Patterns for Better AI Outputs
TL;DR:
This guide covers 12 prompt patterns organized by difficulty — from Zero-Shot and Few-Shot (beginner) through Structured Reasoning and System Prompts (intermediate) to Self-Critique and Meta-Prompting (advanced). Each pattern includes a copyable template, a real-world example, and clear guidance on when to use it and when to skip it. The goal is to give you a reusable toolkit, not a list of tricks.
Academy review: October 5, 2026
Model names and capabilities change frequently. We use provider families (GPT, Claude, Gemini) in Academy copy — verify current tiers on provider sites or our LLM Model Family Guide.
For live model picks, cross-check with our LLM Comparison guide.
This course: Prompt pattern reference
Copyable templates and a quick picker — not a full narrative course.
Learn first (we do not repeat this here)
Go deeper after this course
Patterns are stable; placeholders are not. Replace {company}, {audience}, and {tone} every time — and add verification steps for factual tasks.
What we updated for 2026
Still true in 2026
Compare live tools anytime in our tool explorer.
This course: Prompt patterns
Copy-ready templates with notes — vendor-neutral.
Learn first (we do not repeat this here)
Go deeper after this course
October 2026 update: prompt for outcomes, checks, and constraints
Modern reasoning models often work best when you define the desired outcome, evidence, constraints, and verification checks. Instead of always asking for a full chain of thought, ask for a concise rationale, assumptions, citations when needed, and a final answer you can audit.
Current references: OpenAI prompt engineering, OpenAI reasoning best practices, and Claude extended thinking.
Bookmark this table. When you're stuck on a prompt, scan the “When to use” column to find the right pattern.
| # | Pattern | Level | When to use |
|---|---|---|---|
| 1 | Zero-Shot Instruction | Beginner | Simple, well-defined tasks where the model already knows the format (summarize, translate, classify). |
| 2 | Few-Shot Examples | Beginner | You need a specific output format, tone, or classification scheme that is hard to describe in words. |
| 3 | Structured Reasoning | Intermediate | Math, logic, multi-step analysis, debugging, or any task where the answer needs verification. |
| 4 | Persona / Role Assignment | Beginner | You want domain-specific language, a particular communication style, or expert-level depth. |
| 5 | System Prompt Framing | Intermediate | Building chatbots, assistants, or any multi-turn application where behavior must stay consistent. |
| 6 | Output Format Control | Beginner | You need JSON, markdown tables, bullet points, or any structured format for downstream processing. |
| 7 | Iterative Refinement | Intermediate | Complex creative tasks, long documents, or when you don't know exactly what you want until you see a draft. |
| 8 | Constraint Stacking | Intermediate | You need precise control over length, tone, audience, format, and content simultaneously. |
| 9 | Self-Critique / Reflection | Advanced | High-stakes content where quality matters — proposals, code, analysis, or anything going to a client. |
| 10 | Task Decomposition | Advanced | Multi-step workflows, research tasks, or anything where a single prompt would produce shallow results. |
| 11 | Negative Prompting | Beginner | The model keeps producing unwanted patterns — filler phrases, clichés, disclaimers, or wrong formats. |
| 12 | Meta-Prompting | Advanced | You're stuck on how to phrase a complex request, or you want to optimize an existing prompt. |
Each pattern has a copyable template. Paste it, fill in the blanks, and adjust to your task.
The best prompts use 2–4 patterns together. Persona + Output Format + Constraints is a common combo.
Save your best prompts. Over time, you'll build a personal library of proven templates for your domain.
Patterns outlast models and products
Zero-shot — 2026 depth note
No examples — just instructions. Works when the task is common and format is flexible.
Give a clear instruction with no examples. The model relies entirely on its training.
When to use
When to avoid
[Task verb] the following [input type].
[Your input here]Summarize the following customer review in one sentence. "I've been using this project management tool for 6 months. The Kanban board is excellent, but the reporting dashboard is slow and the mobile app crashes frequently. Customer support responded within 2 hours though."
Few-shot — 2026 depth note
Examples teach format and tone faster than adjectives.
Show 2–5 input→output examples before your actual request. The model learns the pattern.
When to use
When to avoid
[Task description]
Example 1:
Input: [example input]
Output: [example output]
Example 2:
Input: [example input]
Output: [example output]
Now do the same for:
Input: [your actual input]
Output:Classify the sentiment of product reviews as Positive, Negative, or Mixed. Example 1: Input: "Love the interface, hate the price." Output: Mixed Example 2: Input: "Best purchase I made this year!" Output: Positive Now do the same for: Input: "The AI features are impressive but it keeps crashing on my phone." Output:
Chain-of-thought — 2026 depth note
Ask for reasoning steps on multi-hop logic — then verify the conclusion separately.
Give the model a reasoning scaffold and ask for a concise rationale, checks, and final answer.
When to use
When to avoid
[Your question or task]
Use this structure:
1. State the key assumptions.
2. Do the necessary calculation or checks.
3. Give the final answer.
4. Mention one risk or uncertainty.
Keep the rationale concise; do not include unnecessary private scratchwork.A SaaS company has 1,200 customers paying $49/month. They want to raise prices to $59/month but expect 15% churn. Should they do it? Use this structure: 1. State the current MRR. 2. Calculate new MRR after price increase and churn. 3. Compare the two outcomes. 4. Give a recommendation and one caveat. Keep the rationale concise.
Persona — 2026 depth note
Role prompts shape tone; they do not add facts.
Tell the model who it is. A persona shapes tone, vocabulary, depth, and perspective.
When to use
When to avoid
You are a [role] with [years] of experience in [domain].
Your communication style is [style description].
Your audience is [audience description].
[Your actual task or question]You are a senior product manager with 10 years of experience in B2B SaaS. Your communication style is direct, data-driven, and concise. Your audience is engineering leadership. Write a one-page brief explaining why we should prioritize the API rate-limiting feature over the dashboard redesign this quarter.
System prompt — 2026 depth note
System layer = persistent rules; user layer = task instance.
Use the system message to set persistent rules, constraints, and behavior for the entire conversation.
When to use
When to avoid
[System message]
You are [role]. You follow these rules:
1. [Rule 1 — e.g., always respond in JSON]
2. [Rule 2 — e.g., never make up information]
3. [Rule 3 — e.g., ask clarifying questions before answering]
4. [Tone/style constraint]
[User message]
[The actual user query][System message] You are a customer support agent for a SaaS analytics platform. You follow these rules: 1. Always be empathetic and professional. 2. Never promise features that don't exist — say "I'll pass this to our product team." 3. If the user describes a bug, ask for their browser, OS, and steps to reproduce. 4. Keep responses under 150 words. [User message] The dashboard has been loading for 5 minutes and I have a client presentation in 30 minutes. Help!
Output format — 2026 depth note
JSON, tables, and schemas reduce parsing pain — especially with tool calling.
Explicitly specify the structure, format, and constraints of the output you want.
When to use
When to avoid
[Your task description]
Output format:
- Format: [JSON / Markdown table / Bullet list / etc.]
- Length: [word count or number of items]
- Include: [required fields]
- Exclude: [things to leave out]
- Tone: [formal / casual / technical]Analyze these 3 competitor products and compare them. Output format: - Format: Markdown table - Columns: Product Name | Pricing | Key Strength | Key Weakness | Best For - Length: One row per product, max 15 words per cell - Tone: Neutral and factual
Iterative refinement — 2026 depth note
Explicit “v2” instructions beat vague “try again.”
Start broad, then refine with follow-up prompts. Each turn narrows the output closer to what you want.
When to use
When to avoid
Turn 1: [Broad initial request]
Turn 2: "Good, but [specific feedback]. Revise to [direction]."
Turn 3: "Almost. Change [specific element] and [specific element]."
Turn 4: "Final version. Polish for [audience/context]."Turn 1: "Write a landing page headline for an AI writing tool aimed at marketers." Turn 2: "Good, but too generic. Make it more specific about saving time on blog posts." Turn 3: "Almost. Remove the exclamation mark, make it sound confident not excited." Turn 4: "Final version. Polish for a SaaS landing page — professional, benefit-driven."
Constraint stacking — 2026 depth note
Multiple constraints work when they don’t conflict — order from hardest to softest.
Layer multiple constraints to narrow the output space. More constraints = more predictable results.
When to use
When to avoid
[Task description]
Constraints:
- Audience: [who]
- Tone: [how]
- Length: [how much]
- Must include: [required elements]
- Must avoid: [forbidden elements]
- Format: [structure]Write a product announcement for our new AI-powered search feature. Constraints: - Audience: Existing enterprise customers (technical decision-makers) - Tone: Professional, confident, not hypey - Length: 150–200 words - Must include: One concrete use case, a link placeholder [CTA_LINK] - Must avoid: Words "revolutionary", "game-changing", "cutting-edge" - Format: Short paragraph + 3 bullet points + CTA
Self-critique — 2026 depth note
Second pass for quality — doubles cost; use on high-stakes drafts only.
Ask the model to evaluate its own output, find weaknesses, and improve.
When to use
When to avoid
[Generate initial output]
Now review your response:
1. What are the 3 weakest points?
2. What assumptions did you make that might be wrong?
3. What would a skeptical expert criticize?
Rewrite an improved version addressing these issues.Write a technical proposal for migrating our monolith to microservices. Now review your proposal: 1. What are the 3 weakest points in your argument? 2. What assumptions did you make about our team's capabilities? 3. What would a skeptical CTO criticize? Rewrite an improved version addressing these issues.
Decomposition — 2026 depth note
Break complex deliverables into sub-prompts with clear handoffs.
Break a complex task into subtasks, solve each one, then combine. Reduces errors on hard problems.
When to use
When to avoid
I need to [complex goal]. Let's break this into steps:
Step 1: [First subtask]
Step 2: [Second subtask, building on Step 1]
Step 3: [Third subtask, building on Step 2]
Step 4: [Synthesis / final output]
Start with Step 1.I need to write a competitive analysis of the top 5 project management tools. Let's break this into steps: Step 1: List the top 5 tools by market share and briefly describe each. Step 2: For each tool, identify 3 strengths and 3 weaknesses. Step 3: Create a comparison matrix across pricing, features, integrations, and user ratings. Step 4: Write a 200-word executive summary with a recommendation. Start with Step 1.
Negative prompting — 2026 depth note
“Don’t” lists help image and style tasks; in text, prefer positive constraints.
Tell the model what NOT to do. Negative constraints are often more effective than positive ones.
When to use
When to avoid
[Your task]
Important: Do NOT:
- [Unwanted behavior 1]
- [Unwanted behavior 2]
- [Unwanted behavior 3]Write a LinkedIn post about our Series A funding round. Important: Do NOT: - Start with "I'm thrilled to announce" or "Excited to share" - Use the word "journey" - Include more than 3 hashtags - Exceed 200 words - Use emojis in the first sentence
Meta-prompting — 2026 depth note
Ask the model to draft or improve the prompt itself — then you edit and run.
Ask the model to write a better prompt for your task. Use AI to improve your AI instructions.
When to use
When to avoid
I want to [describe your goal in plain language].
Write me an optimized prompt that I can use with an LLM to achieve this goal. The prompt should:
- Be specific and unambiguous
- Include relevant constraints
- Specify the output format
- Anticipate edge casesI want to turn customer support tickets into structured bug reports that my engineering team can act on. Write me an optimized prompt that I can use with an LLM to achieve this goal. The prompt should: - Be specific and unambiguous - Include relevant constraints (what fields to extract) - Specify the output format (JSON) - Anticipate edge cases (vague tickets, feature requests disguised as bugs)
Real-world prompts rarely use a single pattern. Here are five proven combinations for common tasks.
Persona + Output Format + Constraint Stacking
Set a role (CMO), specify format (email), add constraints (200 words, no jargon).
System Prompt + Few-Shot + Output Format
Set coding rules in system prompt, show 2 examples, specify language and style.
Task Decomposition + Structured Reasoning + Self-Critique
Break into subtasks, ask for assumptions and checks, then review for gaps.
Persona + Few-Shot + Negative Prompting
Set brand voice, show tone examples, ban clichés and filler.
Meta-Prompting + Iterative Refinement
Ask AI to write the prompt, test it, refine based on output quality.
Test your understanding of prompt patterns and when to use them.
Loading quiz...
Prompt patterns are reusable structures — not magic phrases. The 12 patterns in this guide cover the spectrum from simple instructions (Zero-Shot) to advanced techniques (Meta-Prompting, Self-Critique).
The best prompts combine 2–4 patterns. Persona + Output Format + Constraints is the most common production combination. Structured Reasoning + Self-Critique is strong when quality and auditability matter.
Build a personal prompt library. Save your best prompts, tag them by task type, and refine them over time. A good library of 20 prompts will serve you better than memorizing 200 techniques.
Know these before you go further.
Copying a CoT or few-shot template without adapting context often yields verbose or wrong outputs.
What this means for you
Change one variable at a time; keep a small eval set for your domain before calling a pattern “production-ready.”
Few-shot examples frequently contain real customer snippets pasted from tickets or docs.
What this means for you
Sanitize examples; use synthetic data in shared prompt libraries.
Stuffing every pattern into one mega-prompt burns context and confuses smaller models.
What this means for you
Chain prompts or use retrieval for reference material instead of inline walls of text.
Structured output can be syntactically valid but semantically wrong — especially for numbers and dates.
What this means for you
Validate with schemas plus business rules; never trust JSON alone for financial or medical fields.