Prompt Engineering

The foundational practice of establishing the model's role, task, and constraints at the start of the prompt. Effective priming sets the behavioral boundary and output schema before any task-specific data is introduced.

• Role assignment: "You are a senior software architect..."
• Task framing: Explicitly state the goal and success criteria
• Constraint declaration: Define what the model must NOT do
• Output formatting: Specify JSON, markdown, or tabular structures

Priming reduces ambiguity and prevents the model from defaulting to generic, unhelpful response patterns.

A technique where input-output exemplars are embedded directly in the prompt to condition the model's behavior without weight updates. The model infers the pattern from 2-5 demonstrations.

• Static few-shot: Fixed examples curated by the engineer
• Dynamic few-shot: Examples retrieved from a vector store based on input similarity
• Chain-of-thought exemplars: Examples that include intermediate reasoning steps

This approach is critical when zero-shot performance is inconsistent and fine-tuning is impractical.

The deliberate structuring of prompts to force the model to externalize intermediate reasoning steps before producing a final answer. This transforms implicit computation into explicit, auditable logic.

• Zero-shot CoT: Simply appending "Let's think step by step"
• Few-shot CoT: Providing examples with reasoning traces
• Self-consistency: Sampling multiple reasoning paths and selecting the majority conclusion

Chain-of-thought prompting significantly improves performance on arithmetic, logical, and multi-hop reasoning tasks.

The practice of constraining model output to conform to a predefined formal grammar or data structure. This is essential for programmatic consumption of generated content.

• JSON mode: Forcing valid, parseable JSON output
• Regex constraints: Limiting token generation to patterns matching a regular expression
• Grammar-guided decoding: Using context-free grammars to restrict valid token sequences
• Schema validation loops: Re-prompting the model when output fails structural validation

Schema enforcement bridges the gap between stochastic generation and deterministic software integration.

The explicit specification of undesired behaviors, topics, or patterns that the model must avoid. This defensive technique complements positive instruction by defining the boundary of acceptable output.

• Content exclusions: "Do not mention competitors or pricing"
• Stylistic prohibitions: "Avoid passive voice and marketing jargon"
• Structural constraints: "Never output raw HTML tags"
• Safety guardrails: "Refuse to generate personally identifiable information"

Negative prompting is a critical layer in production prompt architecture for brand safety and compliance.

The systematic, data-driven process of refining prompts through versioning, A/B testing, and quantitative evaluation. Prompt engineering is an empirical discipline, not a one-shot creative exercise.

• Prompt version control: Tracking changes in git alongside code
• Evaluation harnesses: Automated scoring of outputs against ground truth
• Regression testing: Ensuring prompt changes don't degrade known edge cases
• Human preference scoring: Using annotator feedback to rank prompt variants

Mature prompt engineering pipelines treat prompts as configurable artifacts subject to the same rigor as software modules.

Instructing a model to perform a task without providing any examples in the prompt. The model relies entirely on its pre-trained knowledge and the clarity of the instruction.

• Mechanism: The prompt contains only the task description and the input data
• Use case: Tasks where the desired format is obvious or can be fully described in a single instruction
• Example: "Classify the sentiment of this review as positive, negative, or neutral: 'The shipping was fast but the product broke after two days.'"
• Risk: Higher variance in output format and quality compared to few-shot approaches

Providing a small number of input-output examples within the prompt to condition the model's response pattern before presenting the actual query.

• Mechanism: The examples establish a pattern that the model continues via in-context learning
• Optimal count: Typically 2-5 examples; more can hit context window limits with diminishing returns
• Example format: "Input: 'Great product' → Output: Positive\nInput: 'Terrible service' → Output: Negative\nInput: 'It's okay I guess' → Output:"
• Key insight: Example quality and consistency matter more than quantity

A technique that instructs the model to articulate intermediate reasoning steps before delivering a final answer, significantly improving performance on complex reasoning tasks.

• Mechanism: The prompt includes a directive like "Let's think step by step" or provides examples with explicit reasoning traces
• Effectiveness: Dramatically improves accuracy on arithmetic, logic, and multi-hop reasoning benchmarks
• Zero-shot CoT: Simply appending "Let's think step by step" to a prompt without reasoning examples
• Few-shot CoT: Providing examples that include the reasoning chain alongside the final answer

Assigning a specific persona or professional identity to the model within the system prompt to frame its knowledge domain, tone, and behavioral constraints.

• Mechanism: The model conditions its output distribution on the assigned role, activating relevant knowledge clusters
• Example: "You are a senior patent attorney specializing in software intellectual property. Review the following claim language for 35 USC 101 eligibility issues."
• Effect: Constrains vocabulary, reasoning style, and the types of sources the model implicitly references
• Advanced variant: Multi-role prompting where the model adopts different personas for different stages of a task

Explicitly defining the exact schema, format, or grammar the model must follow in its response, enabling reliable programmatic parsing of generated content.

• Mechanism: The prompt specifies output constraints like JSON schema, XML tags, or markdown templates
• Example: "Return your analysis as a JSON object with keys: 'sentiment' (string), 'confidence' (float 0-1), and 'key_phrases' (array of strings). Do not include any text outside the JSON."
• Constrained decoding: When combined with logit masking, guarantees valid syntax at every generation step
• Critical for: Building reliable AI pipelines where downstream systems consume model output

Explicitly specifying what the model should NOT do or include in its output, used to suppress unwanted behaviors, topics, or stylistic patterns.

• Mechanism: The negative instruction shifts probability mass away from specified tokens or patterns
• Example: "Summarize this article in 3 sentences. Do NOT include any information not present in the source text. Do NOT use the phrases 'in conclusion' or 'this article discusses.'"
• Use cases: Preventing hallucinations, enforcing style guides, avoiding sensitive topics
• Limitation: Models can sometimes paradoxically increase attention on negated concepts; pair with positive alternatives for best results