How Claude Thinks

An LLM is trained on an enormous amount of text, and from all of it, it learns one skill with uncanny depth: given a run of words, predict the word most likely to come next. Ask it to continue 'The minimum clear width of a corridor should be...' and it weighs every plausible continuation it has ever seen - '1.2 m', '1200 mm', 'wide enough', and, far down the list, nonsense like 'aubergine' - and picks from the front of that ranked field. Then it appends that word and does the whole thing again, and again, until the answer is complete. There is no separate step where it looks up a fact, consults a rulebook, or checks whether what it is about to say is true. There is only the next word, and the next.

This sounds far too simple to produce what you actually experience - and yet it is the engine under every summary, rationale and script Claude writes. The reason it works is that producing genuinely plausible text at this scale requires a working grasp of grammar, facts, tone, structure and even reasoning patterns, because those are what make one continuation more likely than another. To reliably predict the next word in a fire-code paragraph, a model has to have absorbed how fire-code paragraphs go. So the prediction machine behaves, most of the time, like something that understands.

But hold onto what it is optimising for: plausibility, not truth. Usually the most plausible next word is also the correct one - which is precisely why Claude is so useful, and why it feels like magic. The catch is the gap between usually and always. When the true answer is obscure, or you have asked in a way that makes a wrong answer sound plausible, the same machine will produce that wrong answer with exactly the same fluency and confidence as a right one. It is not lying and it is not guessing wildly; it is doing the only thing it does - predicting a plausible continuation - and this time plausible and true have parted company. Nothing inside flags the difference. That job is yours.

Everything Claude can 'see' when it answers lives in one place: the context window - its working memory for this conversation. Into that window goes your prompt, any files or images you have attached, any custom instructions or Project knowledge, and the entire back-and-forth so far. Claude predicts its next word from all of it at once. As of 2026 that window is large - on the order of hundreds of pages of text - so you can paste a long byelaw chapter, a full brief, or pages of meeting notes and have Claude work across the whole thing. That capacity is one of its most useful properties for practice, and Module 1 is largely about filling the window well.

Two consequences matter from day one. First, the window is finite. Pour in more than it holds and the earliest material scrolls out of view - in a very long chat, Claude can effectively 'forget' something you said at the top, not through carelessness but because it is no longer in front of it. When a long conversation starts drifting, the fix is usually to restate the key facts or start fresh, not to scold it. Second, and more importantly: what is in the window is the truth Claude reasons from. Give it the actual clause, the real dimensions, the correct brief, and its plausible continuation is anchored to real facts - this is the whole principle behind grounding, which the research modules lean on. Leave the window empty of specifics and it fills the gaps with whatever is generally plausible, which may have nothing to do with your project.

The context window is separate from a second, very different kind of memory: training. Claude's general knowledge - language, facts, how documents are shaped - was baked in once, at training time, and it is fixed. That training has a cutoff date, after which Claude simply does not know what happened: a product launched last month, a byelaw amended this year, a standard just revised. Some plans add web search to reach past the cutoff, but the base model does not know your firm, your client, your site, or last week's news unless you put it in the window. Working memory you fill; trained memory you cannot, and it has a horizon.

A hallucination is when Claude states something false as though it were fact - an invented citation, a clause that does not exist, a confidently wrong number, a plausible-sounding but fictitious product or precedent. Understanding the next-word machine, you can see why this is not a bug that will one day be fully patched but a direct consequence of how the thing works. When Claude reaches a point where it does not actually 'know' the answer - the fact is obscure, absent from training, or you have asked for something that does not exist - it does not stop and say so. It does what it always does: it produces the most plausible continuation. And a plausible-looking IS code number, a realistic journal citation, or a confident clause reference is often exactly what gets generated, because that is what such text looks like.

Two things make this genuinely dangerous in practice rather than merely annoying. The first is fluency: the wrong answer arrives in the same calm, well-structured, authoritative prose as a right one. There is no tremor in the voice, no hedge, no asterisk. The second is that models tend to be agreeable - lead Claude with 'the code says 1.5 m, right?' and a plausible continuation is to agree with you, whether or not the code says anything of the sort. A confident tone is not evidence; it is a property of the writing, produced whether the content is solid or invented.

The practical reading is not fear but discipline. Hallucination clusters in predictable places: specific facts, numbers, names, dates, citations, legal and code references - exactly the high-stakes, verifiable details where being wrong costs you. It is rarer in the open, generative work - brainstorming directions, restructuring your own text, explaining a concept - where there is no single truth to miss. So you do not distrust everything equally. You learn where hallucination lives, you never accept a fact, figure or citation you have not confirmed at its source, and you treat a confident tone as worth nothing on its own. The next section turns this into how you actually prompt.

Once you see Claude as a plausibility engine working from a context window against a fixed training cutoff, good practice stops being a list of tricks and becomes obvious. Fill the window with truth. The single highest-leverage habit is giving Claude the real material - paste the actual clause instead of asking it to recall one, attach the real brief, quote the real dimensions - so its plausible continuation is anchored to facts you control rather than to whatever sounds generally right. A grounded Claude is a dramatically more reliable Claude, and it is the difference between research you can use and fiction that reads well.

Ask for the reasoning, not just the verdict. Because the answer is built word by word, prompting Claude to work step by step - lay out the logic, show the calculation, explain how it got there - often produces better results and, just as valuable, makes its thinking auditable. You can see where a chain went wrong far more easily than you can second-guess a bare conclusion. Ask where each fact comes from, and be suspicious of any citation, clause or number offered without a checkable source; if it cannot point you to one, treat the claim as unconfirmed. And do not lead the witness - ask 'what does the code require here?' rather than 'the code says 1.5 m, doesn't it?', so you are not simply feeding it the plausible answer you want back.

Above all, scale your scrutiny to the stakes - the discipline from Lesson 0.1, now with a mechanism behind it. On divergent, low-stakes work - concept directions, a first draft of your own prose, a brainstorm - there is no single truth to miss, so let Claude run and check it lightly. On convergent, high-stakes work - a code clause, a structural figure, a dimension, a spec bound for site - a confident-wrong answer is a real liability, so verify every claim against the actual source. Knowing how the machine works does not make you trust it less across the board; it makes you trust it precisely - loosely where being wrong is cheap, ruthlessly where it is not.