What an LLM Is and How It 'Thinks'

LLM = Large Language Model. It's the type of AI behind Claude, ChatGPT, and Gemini. In the last lesson, we saw WHAT it is (a predictor); now we're going to see HOW it 'thinks,' because there are four things that, once you get them, completely change how you use it — and they're the difference between fighting with the AI and making it your superpower.

1. It thinks in tokens, not words

The model breaks your text into little pieces called tokens (sort of like syllables or word fragments) and predicts the next one, and the next. It doesn't read individual letters or whole words: it reads tokens.

Why does this matter to you? Because it explains weird behaviors that would otherwise confuse you. For example, sometimes it miscounts the letters in a word or gets stuck on accents: it's not that it's dumb, it's that it literally doesn't see letters, it sees fragments. Knowing this, you stop asking it to do things it wasn't built for and start asking for the things it can do.

2. It has a 'context window'

This is how much it can 'keep in mind' at once: your instruction + any files + the entire conversation. Think of it like a fixed-size workbench. It can hold a lot, but not an infinite amount. If you keep piling on papers, the first ones fall off the edge.

In other words: if the conversation gets super long or you paste in too much material, the model 'forgets' what you said at the beginning. It's not broken — it just ran out of space. That's why, when you're building, you give it just the right, relevant context: not too much (you'll overwhelm it), and not too little (it'll have to guess).

3. It sometimes hallucinates (and it's not lying)

Since it's just predicting, it sometimes makes up things that sound perfectly correct but are false: a function that doesn't exist, a made-up library, a fact that was never real. This is called 'hallucinating.' It's not acting in bad faith: it's just that, at that point, the most probable pattern happened to be a convincing fabrication.

4. It responds to how you talk to it

The same model can give you mediocre or brilliant results depending on how you ask. With the same capability, a vague prompt produces garbage and a clear one produces gold. That's the core skill of the modern builder, and we'll cover it in depth in Module 1: structuring prompts.

• Give it clear, specific context — it can't see your project or read your mind.
• Tell it the output format you want (code? a list? steps?).
• Break large tasks into steps: ask for one piece at a time, not 'the whole app'.
• Verify and correct — it's an iterative process, not a magic button.

A worked example: why it 'forgot' what you told it

Imagine you've been building an app in a conversation for two hours. At the beginning, you told it, 'always use Tailwind for styling.' Forty messages later, you ask for a new component, and it gives it to you with handwritten styles, ignoring Tailwind. You get frustrated: 'But I already told you!'

What happened wasn't defiance: your initial instruction fell off the workbench when the context window filled up. The fix isn't to scold it, but to put that instruction back on top: 'remember, use Tailwind for everything' — or to open a fresh chat with the rules at the beginning. Understanding the mechanism turns a moment of frustration into a two-second fix.

Your takeaways

• The LLM thinks in tokens (fragments), not individual letters or whole words.
• It has a finite context window: if you exceed it, it forgets what you said at the start.
• It hallucinates — confidently makes things up — because it's filling in patterns; that's why you verify the key stuff.
• Its performance depends on how you talk to it: same model, opposite results depending on the prompt.
• These four ideas alone put you ahead of 90% of people who 'use AI'.

You don't need to know how the engine is built. You need to know how to drive it — and that's exactly what you just learned.