What a Prompt Is (and Is Not)

Why this matters

Omar ships the first version of Draft, the Shelf feature that writes a reply to a customer email for a store manager to approve. Its system prompt is one line: "You are a helpful assistant for Bramble Books. Reply to the customer's email." Tessa, who manages the Elm Street store and reads every draft before it goes out, reviews the first ten. Three promise refunds Bramble does not give. Two apologize for delays that did not happen. One addresses the customer by the wrong name, because the email was signed by a spouse. Tessa sends them back with one note: "Which of these did you want?" Omar has no answer. Nothing in the prompt said what a good reply was.

1. The model predicts

A language model is a program that writes text by predicting the next piece of text, given everything that came before it. It reads the request, picks the most likely next fragment, appends it, and repeats until it decides to stop. That is the whole mechanism. There is no lookup into Bramble's database, no memory of the email it answered yesterday, and no goal beyond continuing the text well.

A prompt is the text you put in front of the model to steer that continuation. It is not a command the model obeys. It is the start of a document the model finishes.

2. Three kinds of material

Every request is made of three kinds of material. An instruction tells the model what to do. Context is a fact the model needs and would not otherwise have. Data is the thing the model is working on. Each has a different job, and each goes in a different place.

Why separate them? Because the model cannot tell them apart on its own. A data block is a labeled region of the request that holds data. Wrapping the email in <email> and </email> tags makes a data block, and the model treats the inside as something to work on rather than something to obey.

3. System prompt and user turn

A request has two parts you control. The system prompt is a block of standing instructions that applies to every call: who the model is writing as, what it may and may not do, what the output looks like. The user turn is the message for this call: the context and data for this one email, and the question you want answered.

The system prompt changes when Bramble's policy changes, which is rare. The user turn changes on every call. One file, prompts/draft.system.md, holds the rules, and the code in src/llm/draft.ts fills the user turn from the database.

In code, the two parts are two fields of the same call:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // reads ANTHROPIC_API_KEY

const response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 1024,
  system: [
    { type: "text", text: DRAFT_SYSTEM_PROMPT, cache_control: { type: "ephemeral" } },
  ],
  messages: [
    { role: "user", content: `<order>\n${orderJson}\n</order>\n<email>\n${emailText}\n</email>\n\nDraft the reply.` },
  ],
});

const reply = response.content
  .filter((b) => b.type === "text")
  .map((b) => b.text)
  .join("");

The system field carries the standing instructions. The messages array carries this call's user turn. Other providers and gateways have equivalents; the split is the same everywhere.

4. Why "be helpful" does nothing

Omar's first prompt said "helpful." Every reply was, in the model's terms, helpful. Promising a refund is helpful. The word did not fail; it carried no information. The model was already producing the most helpful-looking continuation it could.

An instruction carries information when it would change the output. That is the test. Read each line of a prompt and ask: if I deleted this line, would some reply come out differently? If the answer is no, the line is decoration.

The pattern holds for "be professional," "be concise," and every other wish. L1 is about turning wishes into instructions, and this test is the tool.

5. Tokens and the window

The model does not read words. It reads tokens, short fragments of text, often a word or part of one. "Bramble" might be one token or two; "#4471" is probably three. Every token in the request costs money and time, and every token the model writes costs more.

The context window is the maximum number of tokens the model can hold at once, request and reply together. Everything in the request competes for that space and for the model's attention inside it. More text is not more guidance. It is more to attend to, and the line that matters gets a smaller share.

The fix is selection, not size. Put in the facts this task needs and leave out the rest. L2 covers how to choose.

6. Temperature and variation

Run the same prompt twice and you may get two different replies. Temperature is a setting that controls how much randomness the model uses when choosing the next token. Low temperature takes the most likely fragment nearly every time; higher temperature samples among the likely ones. Even at low temperature, small differences appear from run to run. A prompt does not have one output. It has a distribution of outputs, and the question is whether every output in it is acceptable.

So you cannot check a prompt by comparing its output to one expected string. You check whether each output meets criteria: names the exchange policy, quotes no refund amount, uses the first name. L5 builds that test. For now: one good run proves little, and one bad run proves a lot.

7. A prompt is code

The course's one-liner: a prompt is code; treat it like code. The Draft system prompt determines what Bramble says to its customers. A change to it is a change to product behavior, so it belongs where product behavior lives: in the repository, in a named file, in a pull request someone reads, with a test that runs before it merges. The course maps that onto three verbs.

Summary

• A language model writes the most likely next token given everything before it; a prompt steers that continuation, it is not a command the model obeys.
• Every request holds instructions (what to do), context (facts it needs), and data (the thing to work on), and each must be labeled so the model can tell them apart.
• The system prompt holds standing instructions for every call; the user turn holds this call's context and data, with the question last.
• An instruction earns its place only if deleting it would change some reply; "be helpful" and "be accurate" change nothing.
• Tokens cost money and compete for a finite window, temperature means one prompt yields many outputs, and both are reasons to treat a prompt as code: versioned, reviewed, and tested.