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. It has no memory between conversations, no live access to the internet unless given tools, and 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.
• It does not remember. Each conversation is a fresh sheet unless you save it, name it, or paste it back in next time.

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, older content falls outside the window — and the model loses track of it.

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 the most important context at the top of long prompts — it stays visible longest.
2. Re-state constraints if you’re three or more turns deep. The model hasn’t “forgotten”; it can no longer see them.
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. It fills 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 4.7 & Sonnet 4.6: 1,000,000 tokens — roughly a 2,500-page book in working memory at once.
Claude Haiku 4.5: 200,000 tokens.

Temperature

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

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 (chat) to think through a problem, Claude Code to scaffold an agent, and the API to make the agent run autonomously. Different products, same model.

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 — first $5 of usage is free.

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-4-6",
    max_tokens=400,
    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.\""
            ),
        }
    ],
)

print(response.content[0].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.