Prompt Engineering

Simple: Ordering “the usual” works with your regular barista and nowhere else. Anywhere else you have to say the whole thing out loud: size, milk, hot, to take away.

Technical: The prompt is the only mutable input at inference time — the weights are frozen, so behaviour is conditioned entirely by the tokens you supply. That is what makes the prompt text the program, and everything downstream a function of it.

Simple: A form, not a sentence. Five boxes: who you are talking to, what they need to know, one example of what good looks like, the actual ask, and the shape you want it back in.

Technical: The five toggles map to distinct roles in the assembled prompt — system message (persona and standing rules), pasted or retrieved context, few-shot exemplars, the user turn, and output-format constraints. They all become one token sequence in the end, but keeping them separate is what lets you change one without disturbing the others.

Simple: The pre-flight checklist a pilot reads out loud after ten thousand flights. Not because it is difficult — because the item you skip is always the one you assumed.

Technical: COSTAR (Context, Objective, Style, Tone, Audience, Response) is a mnemonic, not a parsed format: no tokeniser and no model gives these labels special handling. Its value is recall coverage — it forces the two habitually under-specified dimensions, audience and response schema, into the prompt.

Simple: You describe your job differently to a new colleague, to your manager, and to the team plugging into your system. Same job, three descriptions — and you have never once had to think about it.

Technical: Naming the audience conditions three things at once: lexical register, depth of exposition, and output length and shape. Leave it unstated and the model effectively averages over audiences and lands on the mode of its training distribution — the generic middle, which is wrong for both ends.

Simple: A desk, not a filing cabinet. Everything you are working from has to be laid out on it at once — and whatever comes back has to fit on the same desk.

Technical: The context window is a hard token limit covering prompt and completion together, imposed by the position encoding and by attention’s quadratic cost in sequence length. The figures shown are orders of magnitude, as the slide says: read the trend, not the numbers.

Simple: A taxi driver needs two different things from you. Where you are going and what the traffic is like — and separately, “no motorways, I get carsick”. Give only the second and they do not know the destination; give only the first and they take the road you cannot stand.

Technical: Context is conditioning information: it changes what counts as a relevant answer. Constraints are a filter on the output space, and because they are filters they are checkable after the fact — which is what makes them automatable. A violated constraint is a defect you can detect; missing context just yields a plausible answer about the wrong thing.

Simple: Nobody gives good directions on the first attempt either. “It’s near the shops” only becomes “third left after the roundabout, blue door” after the other person rings to say they are lost.

Technical: Each attempt removes ambiguity about the task: attempt 1 underspecifies the referent, attempt 2 fixes the location but not the content, attempt 3 supplies the artefact itself. The fourth removes you from the loop — the model acquires the same context by tool call, so context gathering stops being manual copy-paste.

Simple: You would not hand a builder the plans for the whole house and walk away. You watch the first wall go up, check it, then ask for the next one.

Technical: Incremental prompting keeps each turn’s output small enough to verify, and every previous turn stays in the context window, so the accumulated conversation is the running specification. Error-detection cost is paid per turn rather than deferred to the end, by which point a fault in step 1 has already propagated through everything after it.

Simple: The difference between “get milk” and a written list with the brand, the size and which shop. Both work if you are the one going; only the second works if you are sending somebody else.

Technical: Each stage adds one class of information: conditioning (context), output filters (constraints), a structural skeleton (template), and a demonstration (exemplar). The marginal value falls off sharply — for a single throwaway query the first two dominate, and all five only repay the effort on a prompt that will be reused, handed over, or run in a pipeline.

Simple: Rather than guessing what the doctor needs to know, you let them ask. Five questions later they have the picture — and you never had to work out which five mattered.

Technical: You are inverting the direction of specification: instead of supplying context you have to guess at, you ask the model to enumerate the missing variables and then you fill them in. The load-bearing clause is “do not answer yet” — without it you get the questions and a guessed answer underneath them.

Simple: The briefing you give a new hire on their first morning, before anybody has asked them anything. It applies to every conversation they will ever have here, so you say it once.

Technical: The system message is a separately-roled turn placed ahead of the conversation, and providers train models to weight it above user turns when the two conflict. It persists across every turn in the session, which is why standing rules belong there rather than being restated in each message.

Simple: Two filled-in forms teach the format faster than a page describing it. And putting each thing in its own labelled envelope means nobody has to guess where one thing ends and the next begins.

Technical: Few-shot exemplars condition the output distribution on a demonstrated input→output mapping with no weight update — this is in-context learning (Brown et al., 2020). Delimiters such as XML tags supply boundaries the model can see, which lets it tell instruction from data and reduces the chance that pasted content is read as a command.

Simple: A parcel label, not a note to the postman. Fixed boxes for name, street and postcode, filled in the same order every time — so a machine can sort it without reading a word of English.

Technical: A declared schema constrains the output to a fixed key set with typed values, which makes the response machine-parseable and programmatically validatable. The critical clause is the null policy: absent an explicit instruction for missing fields, a blank is filled by generation rather than left empty.

Simple: Teaching somebody to fold a shirt. You can write a page of instructions, or fold two in front of them. The second is shorter and it covers the shirt with the odd collar — the one you would never have thought to mention.

Technical: A rule list encodes only the boundary you explicitly enumerated. Exemplars let the model interpolate a boundary from the demonstrated mapping, which generalises to cases you did not enumerate. One exemplar sets the format, two establish a pattern, three or four pin the awkward cases; returns fall off quickly after that.

Simple: A locksmith arrives at a door your key will not open. Do you want them to force it, or to telephone you first? The right answer depends entirely on what is behind the door.

Technical: This is a policy decision about behaviour on out-of-distribution inputs, and it has to be stated in the prompt because the default is to generate something. Choose guessing when the error is cheap to detect and reverse; choose escalation when the action has side effects — a database write, an outbound email, a config change.

Simple: A confident wrong answer and a confident right answer look exactly the same on the page. That is the whole danger — you cannot tell which one you got by reading it.

Technical: The model has no calibrated abstention behaviour by default: a low-confidence continuation is emitted with exactly the fluency of a high-confidence one. An explicit abstention clause shifts the output distribution towards refusal on unanswerable inputs. As the slide says, it lowers the rate of confident invention; it does not eliminate it.

Simple: However clearly you word the question, you cannot ask somebody about a letter they never received. Better wording does not create information that was never in the room.

Technical: Three failures sit outside the prompt’s reach: a training cut-off and private data the model never saw (no wording retrieves an absent fact), no retrieval path with which to verify a claim, and no execution capability. All three are answered by giving the model tools — which is Module 4, not better phrasing.

Simple: Doing a sum in your head against doing it on paper. On paper you get the same answer — but if it is wrong you can point at the line where it went wrong instead of starting over.

Technical: Chain-of-thought prompting elicits intermediate tokens, which give the later tokens something to condition on and improve accuracy on multi-step arithmetic and logic (Wei et al., 2022; the zero-shot form is Kojima et al., 2022). The chain is generated output, not a proof — as the slide warns, it can be fluent and still wrong.

Simple: Before asking a mechanic what is wrong with your car, ask what usually causes that noise. Now their answer about your car has to line up with what they just told you.

Technical: The first turn places a stated framework into the context window; the second turn’s answer is then conditioned on it and stays consistent across follow-ups instead of being reconstructed ad hoc each time. Documented as step-back prompting (Zheng et al., 2023).

Simple: An assembly line only helps if somebody checks each station. Without the checks it is one long job with pauses in it, and a fault at the first station gets built into everything after.

Technical: Decomposition on its own does not improve reliability — the validation gate does. Each stage’s output is checked against a stated condition before it enters the next stage’s context, which bounds error propagation instead of letting a bad stage 1 silently condition stages 2 through 4.

Simple: Handing somebody a form with the first line already filled in. They carry on from where you stopped — they are not going to cross it out and start again with “Dear Sir”.

Technical: Prefill writes the opening tokens of the assistant turn, and because generation is autoregressive continuation those tokens become an unrevisable commitment. Opening with { or [ forces a parseable shape from the first character. As the slide notes, not every interface exposes a writable assistant turn.

Simple: Reading a quote before agreeing to the work. It costs you five minutes, and it is the cheapest possible moment to discover that the two of you were talking about different jobs.

Technical: Plan mode separates proposal from execution: the model states its intended approach and the file set it would touch, with no writes performed, so the review happens before any state changes. The supervision cost is front-loaded once instead of paid per edit, and the disagreements it surfaces are about the goal rather than the syntax.

Simple: “Make it look nice” buys you a conversation every ten minutes. “Under two pages, no red, my name at the top” buys you the thing itself.

Technical: Delegation requires a checkable termination condition. Three moves, in order: criteria expressible as a measurement rather than an adjective, an instruction to iterate rather than to answer once, and a stated verbosity for the working. Drop any one and the loop comes back to you for adjudication — and this is the same structure an autonomous agent runs on.

Simple: Every one of these six is the same instinct wearing a different coat: say exactly what you want, show it rather than describe it, and check what comes back instead of trusting it.

Technical: The six reduce to two levers. One constrains the output distribution — specificity, exemplars, format constraints, elicited reasoning. The other closes the loop outside the model — tools for retrieval, tests and validators for verification. No amount of the first is a substitute for the second.