Understanding AI

Why we start with theory

For one simple reason: everything else (good prompts, common pitfalls, choosing the right tool) flows from the mathematical nature of these models. An hour of theory now will save you weeks of trial-and-error later.

By the end of this module, you'll be able to answer three questions without hesitation:

• What is the difference between AI, Machine Learning and Deep Learning?
• How does an AI "think" (or rather, why doesn't it actually think)?
• Why are there so many different models (ChatGPT, Claude, Mistral, Gemini)?

Three simple questions that open the door to everything that follows.

The Russian dolls of AI

When people say "AI", they often mean very different things. The simplest mental image is Russian dolls: each concept contains a smaller, more precise one.

🪆 Artificial Intelligence (AI)

This is the umbrella concept. Anything that lets a machine mimic intelligent human behaviour: reasoning, learning, understanding language, making decisions. A simple chess programme with hand-coded rules already qualifies as AI.

🪆 Machine Learning (ML)

A subcategory of AI. The big difference: the rules are no longer written by humans. Instead, you feed the machine millions of examples, and it learns the patterns on its own.

Concrete example: to recognise a cat on a photo, you don't describe a cat ("4 legs, pointy ears, whiskers"). You hand over 10 million cat photos, and the machine works out its own rules. That's automated learning in action.

🪆 Deep Learning (DL)

Deep Learning is Machine Learning "on steroids". Where classical ML learns from the data as a whole, Deep Learning stacks several successive layers, each detecting a different level of detail.

Concrete example: face recognition on your phone. When you open the Photos app, your phone automatically identifies the faces of your loved ones. Here is what happens under the hood:

• The first layer detects edges and contrast zones (a light eye on a darker skin, for instance).
• The second layer combines those edges to recognise shapes (a nose, a mouth, ears).
• The third layer assembles those shapes into faces.
• The fourth layer compares the face to a library to identify the person.

No one wrote these rules by hand. The system learnt them on its own, from millions of annotated examples. That stacking of layers, each refining the result a bit more, is what gives "Deep" Learning its name (deep means many layers).

The same machinery powers voice recognition (Siri, Alexa), automatic translation (DeepL, Google Translate), Tesla's autonomous driving, and of course generative AI.

The Transformer revolution (2017)

Generative AI as we know it today was born in 2017 with a research paper: "Attention is All You Need". It introduced the Transformer architecture (the "T" in GPT, which stands for Generative Pre-trained Transformer). Nearly all today's AIs are descendants of that paper.

The attention mechanism

Before Transformers, models read sentences word by word, in order. A bit like us when we read, but without the ability to "look back".

The attention mechanism changes everything. The model analyses the sentence as a whole and assigns an "importance weight" to each word depending on the context. In "the bank of the river", it instantly figures out it's a riverbank, not a financial institution, because the word "river" carries more weight than the default meaning of "bank". That's the mechanism that makes modern models so good.

Generative AI is all about probabilities

This is the single most important point in the entire programme, and the least well understood.

When you write to ChatGPT, it doesn't "think". It doesn't "understand" your question the way a human would. Here is what it actually does, step by step:

1. It splits your prompt into "tokens" (chunks of words).
2. It computes the probability of the next most likely word based on its training.
3. It picks that word.
4. It starts again with your prompt + the word it just produced.
5. And so on, word by word, until the response is complete.

In short, it's a very sophisticated autocomplete machine. Impressive in its outputs, but purely statistical in how it works.

Why you must remember this

Every prompt engineering best practice (Module 2) follows from this principle. The more context you give, the more you frame the probabilities, the better the answer. That's also why people say "Shit in, shit out. Value in, value out": the quality of the answer is directly proportional to the quality of the input.

Tokens and context window: the hidden grammar of AI

If you only remember one technical concept from this entire programme, make it this one. The token is the unit of currency AI works with. Understanding tokens means understanding why AI costs what it costs, why it sometimes "forgets", and why it hallucinates after a long conversation.

What is a token, concretely?

A token is neither a letter nor a word. It's a chunk of word, decided by the model's training algorithm. The word "anticonstitutional" is split into several tokens (anti / constitu / tional). On the other hand, "the", "and", "of" are tokens on their own.

For English text, keep these orders of magnitude in mind:

• 1 token ≈ 4 characters
• 1 token ≈ 0.75 word
• 1,000 tokens ≈ 750 words ≈ a dense A4 page

How do you pay for AI?

Before going further, let's clarify this. There are two very different billing models coexisting on the market.

The calculator below is about Model 2 (API, enterprise usage). That's the one that becomes strategic at scale. If you're using ChatGPT from the web app with your personal subscription, you don't need to count tokens. You already pay the flat fee.

Pick a model, tune the volume, and watch the monthly and yearly cost for a 200-user deployment.

The context window: AI's working memory

The context window is the maximum amount of tokens a model can "see" at once. It includes your prompt, the conversation history, the attached documents, and the answer being generated. All of that, combined.

In 2026, the orders of magnitude have exploded compared to 2023:

The "lost in the middle" trap

Having a big context window doesn't mean the model uses it well. Recent studies have shown that past a certain volume, models tend to focus on the beginning and the end of the context, and neglect the middle. That's the "lost in the middle" effect.

Concretely: if you paste a 200-page PDF and the key info is on page 100, the model may miss it. For very long contexts, it's better to either summarise upfront, or use a RAG system that only surfaces the relevant passages.

Why AI "forgets" and hallucinates when the context overflows

Here's the concrete experience. You start a conversation, you give context, you exchange 20 messages, you add a document, and then 30 messages later the AI "forgets" your name or contradicts what it said at the start. That's context window overflow.

Click "Send 8 tokens" several times. You'll see the older tokens turn grey and crossed out: the model "loses" them. When you later ask something that depends on those lost tokens, two things can happen.

• Case 1: the AI says it doesn't know. Ideal scenario. You start a fresh session with a clean summary of the key context.
• Case 2: the AI makes something up. As you saw in the probabilities section, the model must produce a next word. If it no longer has the real info in memory, it fills the probable space with something that looks like the truth. That's a hallucination caused by context overflow.

Three habits to adopt starting tomorrow

1. Estimate your tokens before sending a big prompt. A 30-page PDF is about 15,000 tokens. An average email is 200 tokens. Having this reflex saves you from billing surprises.
2. Start a new session when the topic changes. Rather than piling 50 messages into the same chat, open one session per task. Your results will be more precise and less costly.
3. Give just what's needed, no more. If one page is enough, don't paste the entire document. The model doesn't "read better" because it has more context: past a certain threshold, the opposite happens.

LLM vs SLM: why so many different models?

LLM, the "Large Language Models"

The "giant" models. Hundreds of billions of parameters, trained on terabytes of text. Versatile, powerful, capable of complex tasks. That's what you use when you go to Claude or ChatGPT.

SLM, the "Small Language Models"

The "light" models. Much smaller, faster, cheaper. Ideal for specific tasks, or to run directly on a phone or an enterprise server without sending data to a public vendor.

Concrete examples: Apple Intelligence on iPhone runs partly locally thanks to an SLM. Mistral also offers SLMs for targeted business use cases.

Key takeaways before the quiz

• AI ⊃ Machine Learning ⊃ Deep Learning. Each concept contains a more precise one.
• Transformers (2017) revolutionised AI by analysing the global context of a sentence via the attention mechanism.
• A generative AI does not think. It mathematically computes the most probable next word.
• As a result, hallucinations are structural. Not a bug, it's how the system works.
• A token is a chunk of word. LLMs charge by token, and their memory (the context window) is bounded. When it overflows, the model hallucinates.
• LLM = large, versatile models (cloud). SLM = light models, perfect for targeted or sovereign use cases.