Prompt Engineering Glossary (60 Terms, Plain English)

TL;DR: This glossary defines 60 prompt-engineering terms in plain English, grouped by what they do: prompting techniques, message roles, sampling parameters, training methods, retrieval, safety, structured output, and image and video generation. Thirty terms link to this site's own glossary; the other thirty are new, each checked against the vendor or the paper that defines it.

Sixty is a real count, not a headline. Thirty of these terms already have a definition on this site (the dotted-underline links); this page matches those rather than restating them differently. The other thirty show up constantly in vendor docs with no page here yet, each checked against a primary source.

What Is Prompt Engineering, and Why Does It Need Its Own Glossary?

Prompt engineering is the practice of designing an AI input so its output comes out reliable and structured, instead of vague and hit-or-miss. That one idea produces a lot of vocabulary: which technique shows the model what you want, which message role you say it in, which sampling parameters the API exposes, how the model was trained, and, for image or video, a separate set of version-specific parameters. Everything below builds out from that one definition.

Which Terms Describe How You Show the Model What You Want?

These are techniques for shaping an answer through the prompt itself, not training or an API parameter.

• Few-shot prompting: giving the model two to five worked examples so it copies the pattern instead of guessing your format.
• Zero-shot prompting: asking for a task with instructions alone, no examples; the default for most requests to a modern model.
• Chain-of-thought (CoT): asking the model to reason step by step before answering, which measurably helps math and code, and does little for simple lookups.
• Self-consistency: running the same chain-of-thought prompt several times and taking the majority answer, smoothing out any one run's reasoning slip.
• Tree-of-thought (ToT): exploring several reasoning paths in parallel and picking the best, instead of committing to a single chain up front.
• In-context learning: the model adapting to a new pattern purely from examples in the prompt, no retraining; the mechanism behind few-shot prompting.
• Persona prompting: assigning the model a detailed character (experience, voice, what it would never say), not just a role label, for a more consistent voice.
• CRAFT: a five-part framework, Context, Role, Action, Format, Tone, so nothing load-bearing gets left to the model's guess.
• Meta-prompting: using the model itself to draft, critique or rewrite a prompt, rather than to do the actual task; different from a fixed prompt template, since the model does the writing.
• Prompt chaining: feeding one prompt's output into the next as input, by hand or in a script. Simpler than an agent, since a script decides what runs next, not the model.

System, User or Developer: Who's Actually Talking to the Model?

• System prompt: the standing instructions (role, tone, rules) for the whole conversation, separate from whatever the user asks in any one turn.
• User prompt: the specific task sent inside the rules the system prompt already set.
• Developer message: OpenAI's newer message role. Its own SDK describes it as carrying "instructions that the model should follow, regardless of messages sent by the user," and on o1 models and newer it takes over the job the system role used to do in that API. A rename inside one vendor's message roles, not a demotion of the system prompt as a concept. See our full precedence comparison for how OpenAI, Anthropic and Google each handle the hierarchy.

What Do the Sampling and Decoding Parameters Actually Control?

These decide how the model picks its next word, not what it's allowed to talk about.

• Temperature: the randomness knob, near 0 for the same answer every time, higher for more varied phrasing.
• Top-p (nucleus sampling): limits next-token choices to the smallest set that together holds P of the probability.
• Top-k: limits next-token choices to the K most likely options regardless of probability mass; less commonly exposed than top-p, and OpenAI's own API doesn't have it at all.
• Greedy decoding: picking the single most likely token at every step, no randomness. Hugging Face's own docs call it the default decoding strategy, and note that on longer output "it begins to repeat itself."
• Seed: a number meant to make output reproducible across runs. Every vendor hedges it the same way; OpenAI's own field description marks its seed parameter Beta and states plainly: "Determinism is not guaranteed."
• Stop sequence: exact strings that end generation the moment the model produces them, with the stop text left out of the reply.
• Max tokens: the cap on tokens a response can contain. The name has splintered across vendors: OpenAI deprecates max_tokens for max_completion_tokens, Anthropic requires max_tokens, and its own newer Responses API uses a third name, max_output_tokens. Our cross-vendor parameter reference tracks the current name for each.
• Streaming: getting the response token by token as it generates, instead of waiting for the whole answer.
• Logprobs: the model's own log-probability for each output token, and, if asked, the runner-up tokens too; a debugging window into how confident it actually was.
• Logit bias: a map from token IDs to a bias value, applied before sampling. OpenAI's own docs describe it plainly: "Modify the likelihood of specified tokens appearing in the completion." Strong enough at the extremes to ban or force a token.

Here is what several of these look like wired together in one request body:

{
  "model": "your-model-id",
  "temperature": 0.4,
  "top_p": 1,
  "frequency_penalty": 0.3,
  "presence_penalty": 0,
  "stop": ["\n\nEND"],
  "seed": 42,
  "max_completion_tokens": 600
}

Frequency Penalty vs Presence Penalty vs Repetition Penalty: What's Actually Different?

This is the single most-confused trio in the whole vocabulary, and getting it wrong means porting a number between two systems that don't mean the same thing.

OpenAI's own field descriptions distinguish the first two this way: frequency_penalty targets a token the model keeps reusing verbatim, while presence_penalty targets a token merely for having shown up once, pushing toward new topics rather than away from repeated phrasing. Repetition penalty is a different mechanism from a different ecosystem: Hugging Face's transformers documentation states it plainly: "The parameter for repetition penalty. 1.0 means no penalty." It's multiplicative rather than additive, with no equivalent to OpenAI's negative range that actively encourages repetition. A repetition_penalty of 1.2 and a frequency_penalty of 1.2 are not comparable settings.

Fine-Tuning, RLHF or Instruction Tuning: Which Training Term Do You Mean?

• Fine-tuning: retraining a base model on your own examples so a style or behavior gets baked in, instead of re-explained every prompt.
• RLHF (Reinforcement Learning from Human Feedback): training a model to prefer outputs human raters rank higher, on top of ordinary fine-tuning. The technique behind InstructGPT: OpenAI's paper describes collecting rankings of model outputs and using them to fine-tune further "using reinforcement learning from human feedback."
• Instruction tuning: fine-tuning a model on many tasks each phrased as a plain-language instruction, so it generalizes to instructions never seen in training. Google's FLAN paper: "finetuning language models on a collection of tasks described via instructions." Distinct from RLHF, which optimizes for preference rankings, not instruction-following.

How Does a Model Get Facts and Memory It Wasn't Given at Training Time?

• RAG (Retrieval-Augmented Generation): fetching relevant documents and pasting them into the prompt before the model answers, grounding it in current facts instead of only training data.
• Embeddings: numeric vectors that place similar meaning close together in space, which is what makes semantic search possible.
• Vector search: finding documents by embedding similarity instead of keyword overlap; the retrieval half of most RAG systems.
• Context window: the most tokens a model can hold in one request, prompt and answer combined. Recall from the middle of a very long window is measurably worse than from the ends.
• Tokens: the sub-word chunks a model reads and is billed on, roughly 0.75 words per token in English.
• Context stuffing: loading a prompt with far more background than the task needs. It doesn't help: the same "lost in the middle" effect means a cluttered context recalls worse, not better.

What Keeps an AI System Safe, and What Actually Breaks It?

• Prompt injection: untrusted text inside a prompt (a webpage, a user message) containing instructions trying to override the app's real instructions.
• Prompt leakage: getting a model to reveal its own hidden system instructions, rather than override them. OWASP's LLM security top ten lists this as its own category, System Prompt Leakage, distinct from injection: leakage exposes instructions, injection overrides them.
• Jailbreak: the colloquial term for a prompt crafted to get a model to ignore its own safety training, usually attempted by the user themselves, unlike injection, where the override typically arrives inside untrusted third-party content the user never wrote.
• Red-teaming: deliberately trying to break a model before real users do, then feeding what you find back into guardrails. A practice, not an attack.
• Guardrails: the defensive layers (topic filters, output checks, injection detectors) wrapped around a model in production, layered rather than relied on singly.
• Hallucination: fluent, confident output that's simply wrong (an invented citation, a fabricated method name), because the model optimizes for plausible text, not verified fact.

What Do JSON Prompting, Structured Output and Tool Use Actually Mean?

• JSON prompt: writing the instruction, the output shape, or both, as literal JSON, so a downstream system can parse the result without guessing.
• Structured output: an API mode that guarantees valid JSON matching a schema you supply, instead of hoping free-text JSON happens to parse.
• Tool use (function calling): letting the model call a function or API mid-answer to fetch information or take an action, rather than guessing.
• Agents: a system that lets the model plan, call tools, look at results, and keep going until a goal is met or a budget runs out.
• Schema validation: checking a model's structured output against a defined shape (types, required fields) before your code trusts it.

Which Terms Only Apply to Image and Video Prompting?

These describe how you shape a generated image or video rather than a text answer, and the syntax varies more between vendors here than anywhere else on this page.

• Aspect ratio: the width-to-height shape you request (Midjourney's --ar, and equivalent flags elsewhere). Allowed values and defaults differ by model and change between versions.
• Negative prompt: a field or phrase telling an image or video model what to exclude. Support is genuinely inconsistent: some tools expose a dedicated field, others fold exclusions into the main prompt, and a few document one but silently drop it depending on which model a request routes to.
• Style reference: a parameter (Midjourney's --sref is the best-known) that points generation at a reference image or style code so new output shares its visual style, not its subject matter.
• Character reference: a parameter for keeping one character's face and appearance consistent across generations. Midjourney has shipped this under more than one name and version gate, so check what your tool currently supports.
• Quality parameter: a flag trading render speed against detail or compute cost (Midjourney's --q, and turbo, relax and fast-style toggles elsewhere), with supported values shifting across recent versions even within one vendor.
• Prompt weight: marking that one part of a prompt should matter more than another, with a number setting relative weight (Midjourney's historic :: divider is the reference example, defaulting each segment to 1).
• Denoising strength: in image-to-image generation, how much of the original image a model may change: low values stay close to the source, high values approach a fresh generation.
• Guidance scale (CFG): classifier-free guidance strength, how hard a diffusion model is pushed toward your prompt versus its own unconditioned sense of a plausible image. Hugging Face's docs describe a higher setting as producing samples "more closely linked to the input prompt, usually at the expense of poorer quality."

What Should You Actually Know About Chats, Rate Limits and Templates?

• Prompt template: a reusable prompt with placeholder fields you fill in per use, so a proven structure isn't rewritten from scratch every time. For translation specifically, our guide to getting better AI translations builds one worth stealing.
• Google AI Overviews: Google's AI-generated answer synthesized from several top-ranking pages, sitting above the normal results; increasingly what your content needs to be extractable enough to get cited inside.
• Multi-turn conversation: a back-and-forth exchange where later turns can reference earlier ones, versus a single-shot prompt with no memory of anything before it. Most of what breaks in a long chat, drift, repetition, contradicting an earlier answer, is a multi-turn problem, not something one message can fix.
• Rate limit: the cap a provider puts on requests or tokens in a given window, returned as an HTTP 429 once you cross it.
• Batch API: an asynchronous submission mode for many requests at once instead of one blocking call per request. OpenAI's version is documented as completing "within 24 hours" at a "50% cost discount compared to synchronous APIs," a real trade of latency for a meaningful price cut.

Sixty terms, one page. Bookmark it for the next time a vendor changelog or a colleague uses one of these without stopping to explain it. Doing any of this in a language other than English: our guide to non-English prompting covers output-language control and register.