What the model actually does.

What an LLM actually is.

Large Language Models are pattern-matchers trained to predict the next word. That framing is almost everything you need.

A model like Claude takes the text you give it and produces the most plausible next text, one token at a time. The model itself keeps no memory between conversations (apps like Claude can add a memory feature on top), has no live access to the internet unless given tools, and has no preferences of its own.

Watch a single sentence get assembled below. Each highlighted token was chosen from a small set of plausible candidates.

Each yellow token is the one chosen. The faint ones beside it are runner-ups the model considered and rejected. Multiply this decision by every word in every response and you have the model.

Why this matters in your work

• The model has only what you put in front of it. If you want it to know your style, your project, your constraints. You have to tell it.
• It can sound certain about things it has no way to know. Pattern-plausible isn’t the same as true. Your judgment is the check.
• The model does not remember. Each conversation starts fresh unless the product carries context over (memory, a Project, files you attach) or you paste it back in.

The context window.

Everything the model can “see” right now is in its context window. Think of it as working memory for this conversation.

From the last unit: Now that you know the model is doing next-token prediction, here’s its biggest constraint. And how to design around it.

The context window holds your prompt, prior turns, any files Claude has read, and the response being generated. Once a conversation grows past the cap, something has to give: depending on the product, older content is dropped or compacted into a summary. Either way, detail from it is no longer in front of the model.

Drag the slider below. Watch what falls out the back.

Validation: this interaction is based on Claude’s context-window docs: platform.claude.com/docs/en/build-with-claude/context-windows.

Practical moves

1. Put long reference material first, then place the immediate task and its constraints close to the end where the model answers.
2. Re-state constraints when the task changes or a long exchange shows drift. Three turns alone is not evidence of context loss.
3. When you sense drift. Wrong tone, lost requirement. start fresh. A new conversation is cheaper than fighting an old one.

Hallucinations.

The model sometimes produces confident, plausible-sounding text that is wrong. Not a bug. A consequence of how prediction works.

From the last unit: The model can only attend to what is in its window. When you ask about something outside that window, the next-token machine still produces plausible text. That is what hallucination is.

Why they happen

The model is predicting plausible text. When you ask for a fact it does not reliably know, the most plausible-sounding text is often almost-right text. A real citation that doesn’t exist, a quote attributed to the wrong author, a statistic close to but not the published number. Current models say “I don’t know” far more often than earlier ones, but sometimes they still fill the gap rather than admit not knowing.

The three defenses

1. Ground the model. Want a summary of a paper? Give it the paper. Want analysis of your contract? Paste the contract. Don’t ask the model to recall facts; give it the facts and ask it to think.
2. Ask for sources, then check. If you cannot verify a claim, treat it as a hypothesis, not a fact.
3. Reduce confident framing. Tell the model: “If you’re not sure, say so.” Models obey instructions to express uncertainty.

Tokens and temperature.

Two technical knobs you don’t need to obsess over, but should understand once.

From the last unit: You’ve seen what the model does (U01), what limits it (U02), and how it fails (U03). Two technical knobs change how all three of those behave.

Tokens

The model reads and writes in chunks called tokens. Roughly 4 characters or about three-quarters of a word in English. A 500-word email is around 700 tokens. The context window and the model’s price are both measured in tokens.

750 words ≈ 1,000 tokens.
Claude Opus 5.5, Sonnet 5.5 & Haiku 5.5 (and the Opus 4.6+ / Sonnet 4.6+ models behind them): 1,000,000 tokens. Roughly a 2,500-page book in working memory at once.
Claude Haiku 4.5 (older, still served): 200,000 tokens.

Temperature

Controls how creative versus deterministic the model is. Low = consistent and predictable. High = varied and surprising.

One caveat for when you reach the API (§01.07): current Claude models manage sampling internally and the API rejects an explicit temperature — since API version 2026-10-21 (the Python SDK 2.x default) sending one returns a 400 error on every model (as of Oct 2026). You steer with prompting, structured outputs, and effort instead, and the chat at claude.ai has no temperature dial at all. The table above still describes how the knob works on models that expose it.

Models vs products.

“Claude” is a family of models. The Claude app, Code, Cowork, and Design are products built on top of those models.

From the last unit: You now have the mental model of how the model works. The next question is which Claude product to point it at.

By the end of Day 04 you will have used Claude in chat to shape a task, a terminal to run Python, and the API to power an agent loop. Claude Code is a separate follow-on practice. Different surfaces, related models, different jobs.

Anatomy of a prompt.

Almost every prompt that disappoints is missing one of three ingredients: context, goal, or constraint.

From the last unit: Whichever product you reach for, the input is a prompt. The same three ingredients make a prompt useful in any of them.

1. Context. Who you are, what you’re working on.
2. Goal. What you want the response to do.
3. Constraint. What NOT to do, or the shape of the answer.

Missing all three

The model has to guess who the team is, what news to deliver, what tone you want. So it returns the most generic possible email. And you blame the model.

All three present

Now the model has a real job. Same model, same minute, twenty times the value.

Your first API call.

Every concept above becomes real when you call the model from your own code. Fifteen minutes. No frameworks.

From the last unit: Everything from Units 01–06 becomes real when you call the model from your own code. Here is the smallest possible program that does it.

Step 1. Set up

Install the Anthropic Python SDK and set your API key as an environment variable. Get a key at console.anthropic.com and add prepaid credit; API usage is billed separately and the total depends on the models, prompts, and retries you run. Windows learner? Use the PowerShell commands in the setup guide.

Copy# macOS / Linux
python3 -m venv .venv
source .venv/bin/activate
pip install anthropic
export ANTHROPIC_API_KEY="sk-ant-..."

Step 2. Make the call

Save this as hello_claude.py. Then run python hello_claude.py.

Copyfrom anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from your env

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=4000,  # headroom: thinking counts toward max_tokens; you pay only for tokens used
    messages=[
        {
            "role": "user",
            "content": (
                "You are a senior product reviewer at a hard-news "
                "publication. You care about clarity and the absence "
                "of marketing language.\n\n"
                "Critique this sentence: \"We leverage AI to unlock "
                "transformative outcomes for our customers.\""
            ),
        }
    ],
)

# the reply is a list of blocks (it can include "thinking" blocks); print the text ones
for block in response.content:
    if block.type == "text":
        print(block.text)

What just happened

• You used Role + Goal + Constraint in a single message. The model knew who to be, what to do, and what to look for.
• The model received exactly your text and nothing else. No memory of past conversations. No web. Just your prompt and its training.
• You got back text. Assembled token-by-token, like the animation at the top of this page, only faster.