Prompt Engineering Cheat Sheet

Table 1: Core Prompting Approaches

Foundational ways to shape an LLM's answer using the wording of a single prompt, before reaching for reasoning chains or tools. They differ mainly in how much you show the model (no examples, one, or several), how you frame the request (persona, situational context, explicit rules), and whether the model is asked to clarify the question for itself first.

Table 2: Reasoning and Decomposition Techniques

These prompts get a model to work through a problem instead of guessing an answer in one leap. Some show step-by-step reasoning, others split a task into smaller parts, branch and backtrack across options, or interleave reasoning with real tool calls. Their gains depend heavily on model scale, and a written reasoning trace is not a guaranteed account of what the model actually did.

Table 3: Output Control and Formatting

These techniques shape what the model returns and how it is structured, so downstream code can parse it and humans can read it. A key distinction runs through the table: prompt-only instructions (asking for JSON, a length, or "do not" rules) are soft requests the model can miss, while API-level features like structured outputs and max_tokens enforce hard constraints.

Table 4: Advanced Reasoning Patterns

These patterns push a model past a single answer by adding structure: writing its own prompts or examples, critiquing and verifying its work, offloading hard computation to code, or trading layout for speed. Knowing what each one actually changes (and where it quietly fails) is what separates a reliable pipeline from a fragile one.

Table 5: Message Roles and Context Structure

Chat models read a list of role-tagged messages rather than one block of text. The system (and newer developer) role sets standing behavior, user carries the live request, and assistant holds the model's prior replies. Because each request is stateless, your app resends the whole list every turn to maintain context, and higher-privilege roles outrank the user role when instructions conflict.

Table 6: Prompt Chaining and Workflow Orchestration

Once a task is too big for one prompt, you compose several model calls into a pipeline. These patterns range from simple sequential chains to retrieval, tool use, routing, and self-directing agents. A key theme: the model proposes structured steps, but your code executes tools, routes branches, and enforces stop conditions.

Table 7: Sample Selection and Example Design

Which examples you put in a few-shot prompt, and in what order, often moves accuracy more than how many you add. This table covers the main ways to choose demonstrations, from query-matched and balanced sets to contrastive pairs, plus the biases that make order and label balance matter.

Table 8: Generation Parameters and Sampling

These settings control how a model turns its next-token probabilities into actual text: how much randomness to allow, which low-probability tokens to discard, how long to keep going, and when to stop. Tuning them well is the difference between focused, parseable output and creative-but-unreliable rambling.

Table 9: Multimodal and Vision-Language Prompting

Multimodal prompting feeds a model more than text. You pass an image or audio clip alongside your question, and the model reasons over both. Keep in mind these models do not "see" or "hear" perfectly: they give approximate object counts, struggle with precise spatial detail, and can hallucinate text when reading documents, so verify anything high-stakes.

Table 10: Safety and Robustness

Securing an LLM application means assuming its prompts and the data it reads are adversarial. These techniques cover the layered defenses that matter most: keeping untrusted input from overriding your instructions, validating what the model emits, training models to refuse harmful requests, and testing your system the way an attacker would before it ships.

Table 11: Emotion and Persona Techniques

These techniques shape how a model speaks and reasons by giving it a role, an audience, or an emotional frame. They mostly steer tone, depth, and perspective, and their effect on factual accuracy is far weaker and less reliable than popular advice suggests.

Table 12: Optimization and Automation

These methods move prompt work from hand-tuning to measured, repeatable engineering: tools that auto-generate and score prompts (APE, DSPy), ways to compare and version prompts in production (A/B testing, prompt versioning), a parameter-efficient training alternative (soft prompts), and an inference trick that reuses a repeated prefix to cut cost and latency (prompt caching).

Table 13: Specialized Patterns and Emerging Techniques

These are newer or niche prompting patterns, several from single recent papers, that squeeze more reliability out of a model without touching its weights. They lean on tricks like self-reflection, voting across reasoning chains, picking complex examples, and even repeating the prompt, so treat the emerging ones as promising rather than settled and verify before production use.

Table 14: Prompting for Reasoning Models

Reasoning models such as OpenAI o1/o3, Claude with extended thinking, and DeepSeek-R1 think before they answer, so they reward concise goal statements over heavy step-by-step scaffolding. These techniques cover how to steer their hidden reasoning, tune its depth against cost and latency, and avoid instructions that older models needed but these models do not.

Table 15: Domain-Specific Applications

Prompt engineering plays out differently across common LLM tasks. Code and data work reward low temperature and strict structure, summarization and translation lean on dedicated techniques like Chain of Density and few-shot terminology, and grounded question answering depends on retrieval. Knowing the right tool and setting per task is what separates a reliable pipeline from a flaky one.

Table 16: Anti-Patterns and Common Pitfalls

These are the prompt habits that quietly wreck output quality, run up cost, or produce confidently wrong answers. For each one, the fix is usually the opposite move: be specific, decompose, show examples, set limits, mark boundaries, ground recent facts with retrieval, and match sampling to the task. The last row is an evolving guideline, heavy step-by-step scaffolding helps weaker models but can over-constrain frontier ones.