Prompt

Every article in this glossary about tokens, sequences, and next-token prediction has quietly assumed something arrives first, to kick the whole process off. That something is the prompt.

How this phase connects

flowchart LR
    P[Prompt: what enters the model] --> Z[Zero-shot or few-shot examples]
    P --> C[Instructions and reasoning strategy]
    Z --> M[Model produces logits]
    C --> M
    M --> S[Temperature, top-k, and top-p shape sampling]
    C --> T[Test-time compute and thinking]
    T --> O[Final output]
    S --> O

This phase separates two controls that are often mixed together: what you tell the model and how the model generates or reasons after receiving it. A detailed prompt cannot guarantee truth, while a high reasoning budget cannot repair missing facts that were never supplied.

The simple definition

A prompt is the text a user provides to an AI system to elicit a response. Recall from the Sequence article that a model’s entire job is processing an ordered run of tokens.

A prompt is simply the initial portion of that sequence — the part a person actually typed — before the model generates anything of its own. Everything downstream, from tokenization to next-token prediction, starts from whatever text the prompt provides.

Why the prompt matters more than it might seem

Recall from the Prediction article that a model’s output is a calculated, probability-based estimate — not a fixed lookup, but a genuine response to whatever input it’s given.

This means the exact same model, with identical weights and identical training, can produce meaningfully different, better or worse responses purely based on how the prompt is phrased.

A vague prompt gives the model less to work with — the probability distribution it calculates, as covered in the Probability Distribution article, tends to be flatter and less confident. A clear, specific prompt narrows that distribution, giving the model a much sharper sense of what a good response actually looks like.

flowchart LR
    A[Prompt: the starting sequence] --> B[Tokenization]
    B --> C[Model processes the sequence]
    C --> D[Autoregressive Generation: response built one token at a time]

ANALOGY vs. TECHNICAL REALITY

Analogy: Think of asking a reference librarian a question. “Do you have any books?” gets a shrug and a gesture toward the whole library. “Do you have any books on 19th-century French painting techniques?” gets a specific, useful pointer to exactly the right shelf.

The librarian’s knowledge didn’t change between the two questions — only the question itself did, and that alone determined how useful the answer could be.

Where this breaks down: A librarian has genuine, flexible comprehension and can ask a clarifying question back.

A model has no such initiative — it simply calculates the most statistically fitting continuation of whatever sequence it’s given, exactly as covered in the Next-Token Prediction article, with no independent ability to seek clarification unless the surrounding application is specifically built to prompt for it.

What actually makes up a prompt in a real conversation

It’s worth being precise here, since a “prompt” in a real chatbot interaction is often more than just the single line a user just typed.

Recall from the Sequence article’s discussion of context windows: an ongoing conversation’s entire history — every earlier message from both the user and the model — typically becomes part of the sequence fed into the model at each new turn, all of it functioning as the effective prompt for generating the next response.

This is exactly why earlier parts of a long conversation can shape a much later response, even if the user’s latest message doesn’t repeat that earlier context directly.

A concrete example, layered

For a simple beginner example: prompting “Write a poem” gives a model almost no direction — subject, tone, length, and style are all left to chance, producing a generic result.

Prompting “Write a four-line poem about autumn leaves, in a wistful tone” gives the model specific, usable constraints, producing a far more predictable and useful result.

For a production example: developers building AI products routinely test dozens of prompt variations for the exact same underlying task — a customer-support bot’s opening instructions might be revised repeatedly to reduce unhelpful or overly cautious responses, entirely by changing the prompt, without retraining or fine-tuning the underlying model at all.

Why the prompt is such a uniquely accessible lever

This is worth stating directly, since it’s part of why prompting has become such a widely discussed skill. Recall from the Training Mechanics phase that changing a model’s actual behavior through training requires enormous compute, data, and expertise.

Changing a prompt requires none of that — it’s available to literally anyone with access to the model, adjustable instantly, with no retraining involved. This is precisely why prompting became such an accessible, immediately practical skill the moment large language models became widely available — it’s the one lever every single user can pull directly.

Build one complete prompt

Role: You are a patient science tutor for a 12-year-old.
Task: Explain why seasons happen.
Context: The learner already knows Earth travels around the Sun.
Constraints: Use fewer than 180 words. Do not say seasons are caused by distance.
Format: Analogy → simple explanation → three-bullet recap.
Success check: Mention Earth's axial tilt and opposite seasons in both hemispheres.

Each line removes a different ambiguity. The role shapes teaching style; the task says what to do; context says what can be assumed; constraints define boundaries; format makes the answer usable; and the success check makes evaluation possible.

Images, audio, documents, tool results, and earlier messages can also be parts of a modern multimodal prompt. The model ultimately receives model-specific token or media representations inside its context window.

How your prompt actually enters GPT or Gemini

Imagine you type “Explain rainbows using a glass prism example.” The application does not place those words directly inside a giant brain. It builds a request and the model processes it in stages:

flowchart TD
    U[You type a prompt] --> A[App adds system instructions and chat history]
    A --> R[API request is sent to a selected model]
    R --> T[Tokenizer converts content into model tokens and token IDs]
    T --> E[Embedding layer turns IDs into vectors]
    E --> P[Position information records token order]
    P --> X[Transformer layers use attention]
    X --> L[Final layer produces next-token logits]
    L --> S[Sampling selects one token]
    S --> K[KV cache stores reusable attention data]
    K --> X
    S --> O[Token IDs are decoded into visible text]

The loop repeats one output token at a time. If the selected tokens are A, rainbow, forms, and so on, the tokenizer finally converts those token IDs back into text you can read.

What the model may actually receive

SYSTEM: You are a science tutor. Use language suitable for age 12.
CHAT HISTORY: The learner already understands that light travels.
USER: Explain rainbows using a glass prism example.
RETRIEVED CONTENT: A trusted note about refraction and dispersion.
TOOL RESULT: None for this request.

Providers use their own internal message formatting and tokenizers, so this is a readable representation rather than an exact hidden token sequence. The important point is that system instructions, history, retrieved material, tool results, and the current user prompt can all enter the same context before generation.

Real-world example: a homework tutor

A learning application can combine a child’s question with a stable teaching instruction and the child’s current lesson level. GPT or Gemini then generates an explanation appropriate to that supplied context. The application should still check safety, protect student data, and avoid treating the model as an unquestionable source.

Common misconception

A frequent beginner assumption: that a prompt is just a “question,” the way you’d type into a search engine.

As this article has shown, a prompt is better understood as the starting sequence for the entire generation process — it can be a question, an instruction, a partial sentence to complete, a full document to analyze, or even just a single word, and its role is always the same: providing the initial tokens everything else gets built from.

Where this fits in what comes next

You now understand the prompt as the starting point of every AI interaction. The next article, System Prompt, covers a special, separate kind of prompt — one that shapes a model’s overall behavior across an entire conversation, rather than being part of what the user directly types.

In one sentence

A prompt is the text that starts the sequence a model generates from, and because it’s the one part of the interaction any user can control directly, without touching the model’s training at all, it’s the most immediate, accessible lever for shaping the quality of an AI system’s response.

Related Terms

• Sequence
• Next-Token Prediction
• System Prompt
• Prompt Engineering
• Context Window