What Is a Prompt? The Parts That Matter
August 31, 2026
A prompt is the input you give an AI model — the text, image, or file you hand it, plus any instructions about what to do with it. That's the whole definition. The interesting part is that a prompt is not a command, and treating it like one is where most frustration comes from.
Three things worth knowing immediately:
- A prompt is context, not a button. The model predicts a plausible continuation of what you gave it. Give it more of the right context and the continuation gets closer to what you wanted
- The same prompt can produce different answers. These systems are probabilistic by design, so identical input does not guarantee identical output
- Most bad results are missing context, not bad wording. People rewrite the instruction when the fix is including the material the model needed
The Five Parts of a Prompt
Not every prompt needs all five, but naming them tells you which one you left out when the answer disappoints.
| Part | What it does | What happens without it |
|---|---|---|
| Instruction | The actual task — summarize, classify, draft, compare | The model guesses at the task |
| Context | The material to work on, plus relevant background | It invents plausible-sounding specifics |
| Role or audience | Who it's writing as, or who's reading | Generic register that fits nobody |
| Format | Length, structure, the shape of the output | Prose when you needed a list |
| Constraints | What to avoid, what to include, what to do when unsure | Confident answers where you wanted "I don't know" |
Context is the one that matters most and gets skipped most. "Write a project update" produces a template. "Write a project update from these notes, for a client who is worried about the timeline" produces something usable, because you supplied the two facts that determine every sentence.
Prompt versus question
A question is one kind of prompt. Plenty of good prompts contain no question at all — they contain a document and an instruction, or an example of the output you want followed by a new input.
That reframing helps: you're not asking, you're setting up. The model continues from what you've established, so the job is establishing enough.
Why the Same Prompt Gives Different Answers
This surprises people who expect software to be deterministic, and it isn't a bug.
Language models generate one token at a time, each sampled from a probability distribution over what could come next. That sampling has deliberate randomness in it — which is why the same prompt run twice can differ, sometimes noticeably. Wikipedia's overview of prompt engineering covers the mechanics.
The practical consequences:
- Don't tune a prompt on one run. If a change looks like an improvement, try both versions a few times before believing it
- Ask for structure when you need consistency. A prompt requesting specific named fields varies far less than one requesting "a summary"
- Variation is useful when you want options — running the same creative prompt several times is a feature, not a failure
What Actually Improves a Prompt
Ranked by how much difference it makes, which is roughly the reverse of how much attention each gets.
1. Add the missing material. Paste the document, the data, the previous email, the style example. Nearly every disappointing answer improves more from this than from any rewording.
2. Show an example of what you want. One example of the output format does more than three sentences describing it. This is the single most reliable technique in prompting, and it's been documented since the GPT-3 paper established that models learn a task from examples in the prompt itself.
3. Say what to do when it doesn't know. "If the answer isn't in the document, say so" measurably reduces invented answers. Without that instruction, the model's default is to produce something.
4. Ask for the reasoning on hard tasks. For multi-step problems, asking the model to work through it step by step improves accuracy — the chain-of-thought result is one of the more robust findings in the area. For simple tasks it just adds length.
5. Then worry about wording. Politeness, threats, and elaborate persona instructions are where beginners spend their effort and where the least return is. Both Anthropic and OpenAI publish practical guidance, and both lead with clarity and examples rather than magic phrasing.
The pattern: supply information, then structure, then wording. Most people do it backwards.
Prompts Beyond Text
The word now covers more than a text box.
Image prompts describe a picture you want generated, and they reward different things — subject, style, composition, and lighting rather than instructions and constraints. If that's what you're after, our guide on writing prompts for AI images covers the specifics, and you can also work backwards from an existing image to recover a description.
System prompts sit above the conversation and set persistent behaviour — the tone, the rules, what the assistant is for. When a tool "already knows" how to behave, a system prompt is usually why.
Prompts inside applications are the invisible majority. Most AI features you use are a template with your input dropped into a slot. That's why results can feel inconsistent across tools using the same underlying model: the template differs.
Where This Goes Next
Once prompts stop being one-off typing, two things follow.
You start reusing them. The prompt that worked becomes something you keep rather than retype, which is the beginning of a prompt library — and the point where the effort compounds rather than evaporating each session.
You start combining them. Output from one prompt becomes input to the next. That's a workflow, and it's where AI stops being a chat and becomes something that does a job.
If the second part is where you get stuck — you can write a decent prompt but can't turn it into something that runs — Taku mirrors working AI setups into a desktop workspace and runs them without the environment work, so you start from a configuration someone already proved out. Taku is in Beta, and the Mac app is available now.
Key Points
- A prompt is the input you give a model, instructions plus context — not a command
- Five parts: instruction, context, role, format, constraints. Context is the one most often missing
- Identical prompts can give different answers because generation samples probabilistically — test changes across several runs
- Adding the missing material beats rewording, every time
- One example of the output format outperforms paragraphs describing it
- Tell it what to do when it doesn't know, or its default is to produce something anyway
- Wording is the last lever, not the first — the published guidance from model providers says the same
FAQ
What is a prompt in AI?
The input you give an AI model — the instruction, plus whatever context, examples, and constraints you include. It can be a question, but it's just as often a document with an instruction attached, or an example of the output you want followed by new input.
What makes a good prompt?
Enough context to make the task specific, an example of the output shape you want, a clear format, and an instruction about what to do when the answer isn't available. Clarity beats cleverness; the published guidance from both Anthropic and OpenAI leads with the same point.
Why does the same prompt give me different answers?
Because text generation samples from a probability distribution rather than looking up a fixed answer. Some variation is inherent and often desirable. If you need consistency, ask for a specific structure with named fields — structured output varies much less than open-ended prose.
What is the difference between a prompt and a system prompt?
A regular prompt is your message in the conversation. A system prompt sits above the conversation and sets persistent behaviour — role, tone, rules, and what the assistant is for. It applies to every turn rather than one message.
Do I need to learn prompt engineering?
Not as a discipline before you start. The basics — supply the context, show an example, state the format — cover most everyday use. Advanced technique matters when you're building something repeatable, at which point structured methods start earning their keep.