OpenAI Prompt Engineering Guide

Teaches developers to construct prompts by explicitly defining system roles, task context, and output constraints through a hierarchical structure. The approach uses role-based prefixing (e.g., 'You are a...') combined with clear task boundaries and example-driven formatting to reduce ambiguity and improve model adherence to intended behavior. This is implemented as a mental model and template pattern rather than code, enabling consistent prompt design across different LLM providers.

Demonstrates how to embed concrete input-output examples directly in prompts to teach models task behavior through demonstration rather than explicit instruction. The technique works by placing 2-5 representative examples before the actual task, leveraging the model's in-context learning to infer patterns and apply them to new inputs. This is a zero-cost alternative to fine-tuning that exploits the model's ability to recognize and generalize from patterns in the prompt context window.

Teaches developers to explicitly request step-by-step reasoning in prompts using phrases like 'think step by step' or 'explain your reasoning', which triggers the model to generate intermediate reasoning tokens before producing final answers. This approach leverages the model's ability to use its own generated text as context for refinement, effectively creating a multi-step reasoning process within a single forward pass. The technique is implemented as a prompt template pattern that can be combined with other strategies like role-framing and examples.

Provides patterns for explicitly specifying desired output formats (JSON, XML, markdown, code) and constraints (length limits, field requirements, value ranges) directly in prompts. The approach uses natural language constraints combined with format examples to guide model generation toward structured outputs that can be reliably parsed downstream. This is implemented as a template pattern that combines role-framing, examples, and explicit format instructions to reduce parsing failures and validation errors.

Teaches a methodology for evaluating and improving prompts through systematic testing against representative examples, measuring performance metrics, and iterating on prompt components. The approach involves defining success criteria, testing prompts against a small evaluation set, analyzing failure modes, and adjusting prompt elements (role, examples, constraints) based on results. This is implemented as a mental model and workflow pattern rather than automated tooling, requiring manual evaluation and iteration.

Provides guidance on selecting appropriate models for specific tasks based on capability profiles (reasoning, coding, language understanding, etc.) and understanding when to use simpler vs. more capable models. The approach involves analyzing task requirements, understanding model strengths and weaknesses, and making cost-performance tradeoffs. This is implemented as a knowledge base and decision framework rather than automated tooling, requiring human judgment to apply.

Teaches developers to recognize and avoid common prompt engineering mistakes (e.g., unclear instructions, contradictory constraints, over-specification) that degrade model performance. The approach involves documenting failure modes, explaining why they occur, and providing corrected examples. This is implemented as a knowledge base of anti-patterns with explanations and fixes, enabling developers to self-correct during prompt design.

Provides guidance on selecting and combining multiple prompt engineering techniques (role-framing, few-shot examples, chain-of-thought, constraints) based on task characteristics and constraints. The approach involves analyzing task complexity, available resources (tokens, latency), and model capabilities to recommend a composition strategy. This is implemented as a decision framework and set of templates that show how to combine techniques effectively.