System Prompt Engineering

A technique where a small number of input-output examples are embedded directly into the system prompt to condition the model's behavior for a specific task without fine-tuning. Examples demonstrate the desired format, tone, and reasoning pattern.

• Static few-shot: Hardcoded examples that never change
• Dynamic few-shot: Examples retrieved from a vector store based on query similarity
• Key principle: Examples must be representative of edge cases, not just happy paths

The system prompt typically houses the few-shot examples in a dedicated <examples> block, separated from behavioral instructions by XML-style delimiters to prevent the model from conflating instructions with demonstrations.

A prompting strategy that instructs the model to generate intermediate reasoning steps before arriving at a final answer, dramatically improving performance on complex logic, math, and multi-hop reasoning tasks. The system prompt typically includes a directive like 'Think step by step.'

• Zero-shot CoT: Simply appending 'Let's think step by step' to the prompt
• Manual CoT: Providing worked examples with explicit reasoning traces
• Auto-CoT: Automatically generating diverse reasoning demonstrations

In system prompt design, CoT instructions are often scoped to specific tool-calling scenarios where the agent must decompose a user request into a sequence of API calls with dependencies.

A generation technique that forces the model's output to strictly adhere to a predefined schema, grammar, or regular expression, ensuring structural validity before the token is emitted. This is often paired with system prompts that declare the expected output format.

• JSON mode: Restricts generation to valid JSON tokens only
• Grammar-constrained decoding: Uses a formal grammar (e.g., GBNF) to define valid token sequences
• Regex filtering: Masks invalid tokens at each generation step

The system prompt declares the schema, but constrained decoding enforces it at the token level—preventing the model from breaking format even under adversarial or edge-case inputs.

A training methodology that aligns a language model with human preferences by using a reward model trained on comparative ranking data. The system prompt serves as the primary interface for activating these aligned behaviors at inference time.

• Preference data: Human labelers rank multiple model outputs for the same prompt
• Reward model: A separate model trained to predict human preference scores
• PPO fine-tuning: Proximal Policy Optimization updates the base model to maximize reward

The system prompt often contains explicit safety and refusal instructions that leverage the RLHF-trained policy, such as 'Decline requests for harmful content' or 'Prioritize factual accuracy over creativity.'

A set of techniques designed to prevent language models from generating factually incorrect or nonsensical information. The system prompt is the first line of defense, establishing ground rules for uncertainty expression and source attribution.

• Explicit uncertainty directives: 'If you don't know, say you don't know'
• Citation requirements: 'Always cite the specific document and paragraph'
• Verification gates: 'Before answering, verify the claim against provided sources'
• Temperature control: Lower temperature settings reduce creative confabulation

Advanced system prompts implement a 'chain-of-verification' pattern where the model generates a response, then self-critiques it for factual consistency before presenting the final answer to the user.

A prompting paradigm that interleaves Reasoning traces and Action steps, enabling an LLM to dynamically interact with external tools to solve multi-step tasks. The system prompt defines the action space and the reasoning format.

• Thought: The model's internal reasoning about what to do next
• Action: A structured command to invoke an external tool or API
• Observation: The result returned from the tool, fed back into context

The system prompt for ReAct agents typically includes a detailed action schema, tool descriptions with parameter specifications, and explicit rules for when to stop acting and formulate a final answer. This pattern is foundational to modern function-calling architectures.