AI Learning

A language model predicts a probability distribution over the next token and samples from it. Covers tokens, distributions, temperature, and why the same prompt can answer differently twice.

A prompt is the whole specification a model is given: instruction, context, examples and format. Covers what belongs in each part, and the failure modes of leaving one implicit.

The same input can produce a different output on every call. Covers which parts of a system that breaks, and the three ways teams respond: constrain, verify, or accept and measure.

A decision model returns a calibrated probability over options the caller supplied, and no text. Covers the three question types, what calibration means, and gating a tool call with one.

Calibration and accuracy are independent, and a threshold depends on calibration. Covers reading a reliability chart, what a threshold trades away, and the three cases where a good number is still not enough.

An agent is a loop around a model, not a cleverer model. Covers what decides whether the loop runs again, the five stopping conditions, and why only some of them mean the work was done.

A tool is a name, a description and an argument shape, and binding decides whether reaching a point runs it or the model chooses. Covers why a discretionary check is not a control, and how a skill differs from a tool.

Every run reaches exactly one typed terminal, and only one of the eleven is unambiguously success. Covers telling apart endings that look identical from outside, and what a closed vocabulary can say that an open one cannot.

Delegation sends work down and expects it back; a handoff gives a peer the conversation for good. Covers what each does to control, context and exits, and which reasons for splitting an agent actually hold.

An obligation written in a prompt is enforced by nothing. Covers the difference between a requirement and a control, the eight hook points a control can attach to, and when a check should block rather than watch.

A prompt is one flat string, so the zones your code assembled do not survive assembly. Covers the channels outside content arrives through, and the three properties that have to meet before a run can do real harm.

Changing what an agent is doing while it is still doing it, instead of stopping the run. Covers how forcefully each lever lands, which ones drift back, and who should be doing the steering.

The window is a shared budget, not a length limit, and when it runs short a policy somebody wrote decides what is dropped. Covers the usual policies, why the failure is silent, and why position inside the window matters.

A model has no memory, so remembering is something built around it. Covers the three scopes state can live at, holding session state as cards a person can correct, and deciding what is worth storing between sessions.

Structure for facts that span each other: entities, typed relations, and validity windows. Covers why deciding which mentions are the same thing is the hard part, and what putting dates on every fact buys.

Once output varies, a test asserting an exact answer stops working and a measured suite takes its place. Covers reading a scorecard, spotting a regression a headline number hides, and what a suite is not measuring.

Four sources of eval cases and the blind spot each one leaves, how to score a case as cheaply as the question allows, and what choosing a value of k commits you to.

Accept, retry or escalate, and the difference between the last two. Covers where a judge sharing the generator's blind spots fails confidently, and why cheap deterministic checks belong before it.

The whole course vocabulary on one design, built in the order the questions are worth asking. Covers what a closed notation reports back that nobody wrote into it, and why that is the reason to draw at all.

The room designs a system somebody actually owns, draws it, and reads the findings back. Facilitation notes, a worksheet drawn from every unit, and the failure modes of the exercise itself.