Quick Navigation
- Start here — What even is AI?
- What makes Generative AI different?
- How does it actually work?
- How did it learn all this?
- Why does it forget things?
- What can it do well?
- Where does it go wrong?
- What is it trying to be?
- Putting it all together
- Cheat sheet
Before we start — the one thing to hold onto
Most people get this wrong. I've sat in rooms with senior engineers and marketing directors who all believed the same thing: that when you ask an AI a question, it searches the internet, finds the best answer, and hands it back. Like a very fast librarian with good taste.
It does nothing of the sort.
It generates. Every single word in every response is produced fresh, in the moment, from patterns it absorbed during training. There is no lookup. There is no database of correct answers sitting behind the curtain. Think of it more like a session musician who has played ten thousand gigs and is now improvising — not replaying something from memory, but creating something new that sounds right because of everything they've absorbed along the way.
AI generates. It does not retrieve.
That one idea explains almost everything about why this technology is powerful, why it occasionally lies to you with total confidence, and how to use it without making a fool of yourself.
Keep it in mind.
1. What is AI? — Let's start from scratch
The word "AI" has become one of those terms that everyone uses and nobody can quite define. I see it in job descriptions, board presentations, vendor pitches — and most of the time, the person writing it couldn't tell you what they mean by it if I asked.
Let's sort it out properly.
Old software follows instructions. A developer writes: if the customer clicks Buy, charge the card. If the card fails, show an error. If the item is out of stock, block the purchase. Every rule, written by hand, one at a time.
AI learns from examples instead. You show the system thousands — or millions — of examples, and it works out the rules itself.
Here's a concrete one. Building a spam filter the old way meant writing rules like: if the email contains "click here to claim your prize," mark it as spam. Worked fine. Until spammers changed their wording to "click here to receive your reward." Then someone had to update the rules. Then spammers adapted again. Endless arms race.
The AI approach: feed it a million emails already labelled "spam" or "not spam" and let it find the patterns. It picks up on things nobody thought to write a rule for — a particular sending time, a certain word frequency, a link structure that looks off. And when spammers change tactics, you retrain it on fresh examples. No rule-writing required.
That's it. Software that learns from examples rather than following hand-written rules.
flowchart LR
A["📋 Old Way\nHuman writes every rule"] --> B["Rule Engine\nIF this THEN that"]
B --> C["Output\nWorks until the world changes"]
D["🧠 AI Way\nHuman provides examples + goal"] --> E["Learning Engine\nFinds patterns on its own"]
E --> F["Output\nAdapts as more examples arrive"]
Once you understand that AI learns rather than follows rules, the rest of this module makes sense — including why it makes the kinds of mistakes it makes.
Try it yourself — Spot the difference
Think of one process in your work that currently runs on hand-written rules — a checklist, a policy, a standard operating procedure. Now think of one where people use judgment and experience rather than following a fixed script.
| Rule-based process | Judgment-based process |
|---|---|
| e.g. Expense approval under £50 | e.g. Deciding which customer complaint to escalate |
Which of these two suits an AI approach that learns from examples? Write down your answer before moving on. Don't overthink it — the obvious answer is usually right.
2. Traditional AI vs. Generative AI — The shift that changed everything
"AI" has been around for decades. Your email's spam filter is AI. Netflix's recommendation engine is AI. The fraud detection that occasionally blocks your credit card when you're on holiday — AI.
None of those feel like the thing everyone is talking about now. So what actually changed?
The old kind — Traditional AI — looks at something and makes a decision. It classifies. It predicts. It scores.
- Is this email spam or not? → Decision
- Will this customer churn in the next 30 days? → Prediction
- Is this credit card transaction fraudulent? → Score
Enormously useful stuff. But the output is always a number, a label, or a category. It decides; it doesn't create.
Generative AI does something different. It takes a prompt and makes something new. Not a label. Not a score. Actual content — text, code, images, audio — that didn't exist before you asked.
Where Traditional AI would answer "likely spam" or "87% confidence," Generative AI would answer with a paragraph explaining what looks suspicious, how to rewrite the email, and three alternative subject lines.
flowchart TD
INPUT["Your Input"]
INPUT --> TRAD["Traditional AI\n'What is this?'"]
INPUT --> GEN["Generative AI\n'What should I create?'"]
TRAD --> T1["Spam / Not Spam"]
TRAD --> T2["Fraud / Not Fraud"]
TRAD --> T3["Cat / Dog / Bird"]
GEN --> G1["📝 Write this email for me"]
GEN --> G2["🖼️ Generate this image"]
GEN --> G3["💻 Build this code"]
GEN --> G4["🎵 Compose this music"]
Traditional AI narrows your options down to one answer. Generative AI opens up a whole space of possibilities and creates within it.
Think of it this way: Traditional AI is like a judge — it evaluates and decides. Generative AI is like a well-read collaborator — it understands and creates.
Try it yourself — Map your work
List three tasks you did this week. For each one, decide: would Traditional AI (classify, predict, score) or Generative AI (create, explain, transform) be the right fit?
| Task | Traditional AI or Generative AI? | Why? |
|---|---|---|
| e.g. Sorting incoming support tickets | Traditional AI — it's a classification task | |
| e.g. Drafting a project status update | Generative AI — it needs to create new text | |
Now pick one Generative AI task and write down what a good first draft would need: audience, purpose, key points, tone. That's your first real prompt.
3. How it actually works — No math, I promise
The technical details of how AI works are genuinely complex. I'm not going to pretend otherwise. But the intuition behind them isn't. And the intuition is all you need to use this stuff well.
Three things came together to make Generative AI possible. Think of three dials, all being turned up at the same time.
Dial 1 — Better algorithms. Specifically, a new architecture called the Transformer (invented in 2017) that could understand language in context — not word by word, but all at once, working out how every word relates to every other word in a sentence.
Dial 2 — More data. Not thousands of examples. Not millions. Trillions of words — essentially a large chunk of written human knowledge: books, articles, websites, academic papers, code, conversations.
Dial 3 — More computing power. Specialised chips (GPUs and TPUs) that could process this data at a scale that simply wasn't possible before.
flowchart TD
ALG["Better Algorithms\nTransformers — understand\nlanguage in context"] --> POWER["🌟 Generative AI\nCapable of creating\nacross almost any domain"]
DAT["More Data\nTrillions of words\nfrom human knowledge"] --> POWER
COMP["More Compute\nSpecialised chips\nprocessing at massive scale"] --> POWER
Here's the part that catches people out: when you combine all three at sufficient scale, something unexpected happens. The model starts doing things nobody explicitly programmed. It reasons. It translates between languages it never saw side by side during training. It debugs code. It explains concepts using analogies. It writes poetry in the style of someone specific.
These aren't features someone added. They emerged from scale.
That emergence is what makes Generative AI feel qualitatively different from earlier software — and it's also why the people who built it don't fully understand everything it can do. They're still figuring it out too.
For the curious: The system that made this possible is called a Large Language Model, or LLM. The architectural breakthrough was the Transformer — specifically its "attention mechanism," which lets the model weigh how relevant every word is to every other word simultaneously. It's the reason these models understand context rather than just counting words. GPT, Claude, Gemini — they are all built on this same foundation.
Try it yourself — The three dials
Think about your organisation's current AI use (or planned use). Rate each dial from 1 to 5:
| Dial | Your rating (1-5) | Evidence |
|---|---|---|
| Algorithms — Are you using modern AI tools or still building custom models? | ||
| Data — Do you have clean, accessible data the AI can learn from? | ||
| Compute — Do you have the infrastructure to run AI at the scale you need? |
Where is your weakest dial? What would it take to turn it up by one notch? Be honest — most organisations are weaker on data than they'd like to admit.
4. How it learned — The three-stage education
A Generative AI model doesn't know anything when it starts. It has to learn. And that learning happens in three distinct stages — each building on the previous one.
Stage 1: Read everything.
This is called pre-training, and it is exactly what it sounds like. The model ingests an enormous amount of text — think of it as reading a significant chunk of the written internet, plus books, academic papers, and code repositories.
The task it is given during this stage sounds almost too simple: predict the next word.
That's it. Given "The Eiffel Tower is located in," what word comes next? Given "She opened the envelope and felt," what word comes next?
But here's the thing — to predict the next word well, the model has to understand what the sentence means. It has to know geography to answer the first one. It has to understand human emotion to answer the second one. Predicting the next word, done billions of times across trillions of sentences, forces the model to build something like a map of human knowledge and language.
Nobody told it about geography. It figured it out because it had to, to make good predictions.
Stage 2: Learn to be helpful.
A model that just completed stage one is smart but wild. It has absorbed everything — including a lot of the internet that you'd rather not reproduce. It's also not naturally structured to answer questions helpfully.
Fine-tuning reshapes that. The model is trained on carefully curated examples of good conversations — thoughtful questions with genuinely helpful, accurate, well-structured answers. It learns the format of being useful.
Stage 3: Learn from human feedback.
This is where it gets refined. Human reviewers read outputs from the model and rate them — which responses are genuinely helpful, which are confusing, which are harmful. Those ratings feed back into the training as a kind of ongoing correction.
Over millions of feedback signals, the model learns not just what to say, but what good looks like from a human perspective.
flowchart TD
PT["Stage 1: Pre-training\nRead trillions of words\nLearn to predict what comes next\nAbsorbs language, facts, and patterns"]
PT --> FT["Stage 2: Fine-tuning\nTrain on curated examples\nLearn to give helpful, structured answers"]
FT --> RLHF["Stage 3: Human Feedback\nHumans rate responses\nModel learns what 'good' looks like"]
RLHF --> GOAL["The result\nHelpful · Honest · Harmless"]
The reason Claude, ChatGPT, and Gemini all feel different — even though they share a similar underlying architecture — comes down to stages two and three. Same foundation. Different values and style baked in through fine-tuning and human feedback.
Try it yourself — Your own three stages
Think about how your team or organisation would "train" an AI to work the way you work. What would each stage look like?
| Stage | What it means for your organisation |
|---|---|
| Stage 1: Read everything | What documents, knowledge, and data would the AI need to absorb? List 3-5 sources. |
| Stage 2: Learn to be helpful | What does a "good answer" look like in your context? What format, tone, and level of detail? |
| Stage 3: Learn from feedback | Who on your team would be the best at rating AI outputs? What criteria would they use? |
This exercise reveals how much tacit knowledge your team carries — and how much of it has never been written down. That's usually the uncomfortable bit.
5. Why it forgets — The context window explained
Here's something that trips up a lot of people. If AI has read half the internet, why does it sometimes seem to lose track of what you said three messages ago?
The answer is one of the most important things to understand about how AI actually works.
Imagine you have a brilliant friend who has read an astonishing number of books — history, science, fiction, law, medicine, you name it. All of that is in their long-term memory. But when you sit down to have a conversation with them, they can only actively hold a certain amount in focus at once. Whatever is in front of them — your question, the document you handed them, the context you've built up in this conversation — that's what they're working with right now. Everything else is still there in their head, shaping how they think, but not actively accessible unless it's in front of them.
That's the context window. It's the active working space of the conversation.
- Your message goes in.
- Their previous responses go in.
- Any documents or files you've shared go in.
- Any information pulled in from tools like web search goes in.
What doesn't go in: anything from a previous conversation, unless you copy it across.
flowchart TD
WEIGHTS["Everything learned during training\nBaked into the model's weights\nAlways influencing, never directly accessible"]
CW["The Context Window\nWhat's actively in focus right now"]
CW --> P["Your messages"]
CW --> R["The model's responses so far"]
CW --> D["Documents you've shared"]
CW --> T["Tool outputs — web search, files, etc."]
WEIGHTS -.->|"Shapes how it thinks\nabout everything in the window"| CW
CW --> OUT["Response"]
This has real practical implications.
Every new conversation starts completely blank. The model has no memory of your last conversation unless you re-share it. If you've spent an hour building context in one session and then close the tab, that context is gone.
When you want a better answer, one of the most effective things you can do is give the model more context — paste in the document, share the background, explain the situation. The more relevant information is in the window, the better it can work with it.
Longer context windows (measured in "tokens," which are roughly three-quarters of a word) mean more can fit in at once. Models have been getting larger context windows over time — this is one of the reasons newer models handle longer documents better than older ones.
Try it yourself — The context window test
Take a real task you've given AI (or plan to give AI). Now answer these three questions:
- What context did I give it? List everything: your prompt, any background, any documents you shared.
- What context did I forget? What does the AI not know that would help it give a better answer?
- What would I paste in next time to get a noticeably better result?
| What I gave it | What I forgot | What I'd add next time |
|---|---|---|
Most people's "what I forgot" list is longer than their "what I gave it" list. That's the single fastest way to improve your AI results.
6. What it does well — The genuine strengths
I've seen a lot of people go one of two ways with AI: they either think it can do everything perfectly, or they've had one bad experience and dismissed it entirely. Neither position is defensible.
Generative AI has genuine strengths. They're significant. And understanding them specifically helps you put the tool in the right hands for the right jobs.
It writes. Drafts, summaries, emails, reports, proposals, creative pieces — it handles the blank-page problem well. Give it context and direction and it will produce a solid first draft faster than most humans can. The key word is first. It's a starting point, not a final product. I've seen people treat AI output as finished work and live to regret it.
It explains. Ask it to explain quantum physics to a ten-year-old, and it will. Ask it to explain the same concept for a PhD student, and it will do that too. The ability to meet someone at their level — and adjust on request — makes it a genuinely useful learning tool.
It shifts tasks without being reprogrammed. This is what makes it different from any tool that came before it. The same system that just helped you write a job description can immediately help you debug a Python script. No switching tools. No reconfiguring. One conversation, many tasks.
It holds a thread. Within a conversation, it remembers what you've discussed and builds on it. You don't have to repeat yourself every message.
It connects to other tools. Modern AI systems can search the web, read your documents, query databases, run code. The right combination turns it from a chat interface into something closer to a working assistant.
flowchart TD
GEN["Generative AI"]
GEN --> C1["Writing\nDrafts, summaries, reports, creative work"]
GEN --> C2["Explaining\nAny topic, any level, any style"]
GEN --> C3["Flexible Tasking\nSwitches roles without reprogramming"]
GEN --> C4["Conversation Memory\nBuilds on what you've discussed"]
GEN --> C5["Tool Use\nWeb search, files, code, databases"]
A single conversation can move from drafting to debugging to explaining to summarising — and the model keeps up. That's genuinely new. Every tool that existed before this was built for one specific job.
Try it yourself — Your capability map
For each of AI's five strengths, write down one real task from your work where it would genuinely help:
| Strength | Your real task |
|---|---|
| Writing | e.g. First draft of monthly board report |
| Explaining | e.g. Explain our new pricing model to non-technical sales team |
| Flexible tasking | |
| Conversation memory | |
| Tool use |
If you can't fill a row, that's useful information too — it means you haven't yet found the right task for that strength.
7. Where it goes wrong — The honest list
Anyone selling AI as a perfect tool is selling you something. Here are the real limitations, explained plainly.
It can make things up — confidently.
This is the big one, and it has a name: hallucination. It happens because of how the model was trained. Remember that the training task was predict the next word. The model learned to produce fluent, coherent, contextually appropriate text. It did not learn to only speak when it's certain.
So when it doesn't truly know something, it doesn't say "I don't know." It generates what should plausibly come next — and that output can be fluent, confident, detailed, and completely wrong.
It might cite a paper that doesn't exist. Attribute a quote to someone who never said it. State a statistic with precision and authority that has no basis in fact.
This is not a bug that will be fixed in the next version. It is a structural consequence of how the model was built. The right response is not to avoid AI — it's to verify anything high-stakes independently, especially facts, figures, citations, and legal or medical claims.
flowchart LR
Q["Question the model\nisn't certain about"]
Q --> OBJ["Training objective:\n'Predict the next word'"]
OBJ --> GEN2["Produces fluent,\nplausible-sounding text"]
GEN2 --> HALL["Hallucination\nConfident. Coherent. Wrong."]
Its knowledge has an expiry date.
The training data ended at some point — there's a cutoff date. The model doesn't know about things that happened after that date. Ask it about recent news, new laws, who currently holds a specific position, or new product releases, and you might get an outdated answer delivered as if it's current. Use web search tools for anything time-sensitive.
It doesn't give the same answer twice.
This is called non-determinism. Ask the same question twice and you'll likely get two different answers. That's not an error — it's how the system was designed (some variability produces better, more creative outputs). But it means you can't treat AI like a calculator where the same inputs always produce the same outputs.
Long chains of reasoning are where it stumbles.
For multi-step mathematical problems, complex logical deductions, or tasks requiring precise counting and arithmetic, the model is weaker than you might expect. It pattern-matches to similar problems it's seen before — and that can mislead it on novel problems. It's better at explaining reasoning than performing it.
It forgets between sessions.
We covered this in the context window section, but it's worth repeating here as a limitation. There is no persistent memory unless you or the system explicitly provide it. Each conversation starts from scratch.
Try it yourself — The verification habit
Take one piece of AI output you've received recently (or generate one now). Run it through this checklist:
| Check | Pass or Fail? | What would I verify? |
|---|---|---|
| Factual accuracy — Are any claims, numbers, or dates wrong? | ||
| Citations — Are any references or sources fabricated? | ||
| Completeness — Is anything important missing? | ||
| Tone — Is it appropriate for my audience? | ||
| Stakes — If this went out with my name on it, could I defend it? |
Any "Fail" means this output needs editing before use. This is the verification habit — and it takes two minutes.
8. What it's trying to be — Helpful, Honest, Harmless
Every serious AI lab trains toward the same three goals. They get shortened to: Helpful, Honest, Harmless.
These are not marketing phrases. They're design targets baked into the training process — specifically into the fine-tuning and human feedback stages.
Helpful means actually useful. Not hedged to the point of uselessness. Willing to engage with real questions and give substantive answers.
Honest means accurate and transparent. Acknowledges when it's uncertain. Doesn't try to deceive or manipulate. Admits its own limitations.
Harmless means it avoids generating content that could cause real damage — instructions for weapons, content that exploits vulnerable people, things like that.
Here's the thing they don't always tell you: these three goals are sometimes in tension with each other.
Being maximally helpful might require saying something the person doesn't want to hear — which is honest, but not comfortable. Refusing everything that could possibly be misused would make the model useless — harmless, but not helpful. Giving confident, action-oriented answers risks overstating certainty — helpful, but not fully honest.
flowchart TD
GOAL["The Three Goals"]
GOAL --> H1["Helpful\nGenuinely useful\nNot hedged into uselessness"]
GOAL --> H2["Honest\nAccurate and transparent\nAcknowledges uncertainty"]
GOAL --> H3["Harmless\nAvoids content\nthat could cause damage"]
H1 <-->|"Tension"| H2
H2 <-->|"Tension"| H3
H1 <-->|"Tension"| H3
Every AI system is a calibration between these three. When a model refuses a reasonable request, it's being over-cautious on the harmless axis. When it hedges every sentence with caveats, it's over-weighted on honest at the cost of helpful. When it confidently produces inaccurate information, helpful has overridden honest.
Understanding this helps you read AI behaviour — and it also tells you something about your own responsibility. The model is trying to be helpful, honest, and harmless. Your job is to verify what it gives you, use it transparently, and apply judgment to what you do with it.
Try it yourself — The tension exercise
Think of a real decision or communication from your work this week. How do the three goals of AI (Helpful, Honest, Harmless) create tension in your context?
| Scenario | Where the tension lives |
|---|---|
| e.g. Telling a client their project will be delayed | Helpful = give them a solution. Honest = admit our mistake. Harmless = don't damage the relationship. |
Now think: if AI drafted this communication, which of the three goals would it likely over-weight? Which would it under-weight? What would you need to edit?
Putting it all together
Here's the complete picture in one diagram. This is the mental model worth internalising.
flowchart TD
RAW["Training Data\nTrillions of words, images, code"]
RAW --> LEARN["Learning\nNeural networks find patterns\nat enormous scale"]
LEARN --> ALIGN["Alignment\nFine-tuning and human feedback\nshape helpful, honest, harmless behaviour"]
ALIGN --> MODEL["Generative AI Model\nCapable of creating across almost any domain"]
MODEL --> CONTEXT["Context Window\nYour prompt + documents + conversation history"]
CONTEXT --> GEN["Generation\nProduces new content token by token"]
GEN --> OUTPUT["Output\nText · Code · Images · Analysis"]
OUTPUT --> CHECK{"Is it accurate,\nuseful, appropriate?"}
CHECK -->|"Yes"| USE["Use it"]
CHECK -->|"Not sure"| REFINE["Verify it\nor refine your prompt"]
The foundation:
Traditional AI decides. Generative AI creates. That single distinction reframes everything — every use case, every limitation, every risk. It generates, it doesn't look up — every word in every response is being produced fresh, and that's the source of both its power and its failure modes. Helpful, Honest, Harmless is what it's aiming for, not what it always achieves. Understanding that helps you use it well and catch it when it falls short.
Cheat Sheet — All the key terms
| Term | Plain English | Technical name |
|---|---|---|
| AI | Software that learns from examples, not rules | Machine Learning |
| Traditional AI | Looks at something and makes a decision | Discriminative model |
| Generative AI | Looks at something and creates something new | Generative model / LLM |
| Transformer | The architecture that made modern AI possible | Transformer / Attention mechanism |
| Training data | Everything the model ever learned from | Pre-training corpus |
| Pre-training | Reading everything; learning to predict what comes next | Next-token prediction |
| Fine-tuning | Learning to be a helpful assistant | Supervised Fine-Tuning (SFT) |
| Human feedback | Learning what "good" looks like from human ratings | RLHF |
| Context window | The active working space of a conversation | Context length (tokens) |
| Hallucination | Generating confident, fluent, wrong information | Confabulation |
| Knowledge cutoff | Doesn't know what happened after training ended | Training data cutoff date |
| Non-determinism | Same question, different answer each time | Probabilistic sampling |
| Helpful · Honest · Harmless | What the model is trained to be | AI Alignment |
How to know if this landed
You'll know this has landed when someone stops treating AI like a search engine and starts treating it like a capable but occasionally unreliable colleague — someone you collaborate with and check, not blindly delegate to. They can explain the difference between Traditional AI and Generative AI using their own words. They understand why hallucination happens and why it's not going to be "fixed." They know what a context window is and adjust how they work with AI because of it. They treat AI output as a first draft, not a final authority. And they understand what Helpful, Honest, Harmless means — and what their own responsibility is on top of it.
What changes when the mental model clicks
I've run this session with teams ranging from senior engineers to HR managers to executive leadership. The knowledge gap at the start is usually not about technical depth — it's about mental model.
Most teams using AI day-to-day have no shared vocabulary for talking about it. Some think it searches the internet. Others think it just makes things up randomly. Others are vaguely worried they'll misuse it but aren't sure how. Without a shared foundation, every conversation about AI policy, adoption, or risk goes in circles.
What changes after this session:
Teams can finally have the real conversations — not "should we use AI?" but "which of these tasks is AI genuinely suited for, and which ones require us to verify the output?"
The hallucination demonstration (watching a model confidently produce a wrong answer live, in the room) is always the moment things click. People stop treating AI like a search engine and start treating it like a capable but occasionally unreliable colleague — someone you collaborate with and check, not blindly delegate to.
The context window section tends to immediately change how people prompt. They start giving more context. Their results get better. They stop blaming the model when the real problem was that they didn't give it enough to work with.
Book a Workshop
Ready to give your team the mental model they need?
or
Half-day foundations workshop includes interactive sessions on all 8 core concepts, live hallucination demonstrations, Traditional AI vs. Generative AI comparison exercises, capabilities and limitations mapped to your specific domain, and a foundation for the full AI Fluency 4D workshop.