How to Learn AI in 3 Weeks

Intro

Welcome to Your 3 Week Learning Curriculum,
Build AI Knowlegde without the Need for Deep Technical Expertise!

Dentro de AI translates to Inside AI – this curriculum is combining all the content on this site (visualizations, articles, timeline & glossary entries, industry landscape) into one coherent learning path.

The goal: around 3 weeks to AI fluency for people serious about it – enough to think, work, and decide with AI, without becoming an engineer. (Read more on how this project came about in this blog post.)

---

What you get

By the end of this curriculum, you will:

• Have a clear mental model of what happens before, inside, and after the AI black box.
• Have real benefits in your job upgraded with AI – not just toy “prompt tricks”.
• Be able to judge AI outputs for quality, risk, and bias.
• Geared up to explain to others the key fundamentals of how AI works.
• Speak enough of the AI vocabulary to negotiate with tech teams or vendors.

What this is not

• ❌ Not a coding bootcamp.
• ❌ Not a math-heavy deep dive.
• ❌ Not a collection of “magic prompts that solve everything”.

It is a practical playbook for:

• ✅ Understanding the AI Black Box
• ✅ Working with AI
• ✅ Making decisions about AI

Worth the effort?

• Time: Three focused weeks with some buffer
• Payoff:
  • Faster analysis and clearer communication.
  • Better judgment on “we should use AI for this” ideas.
  • Greater confidence saying both “yes, let’s try this” and “no, this is not a good AI use case”.

• Success looks like:

  • You use AI weekly on real tasks.
  • You can sketch an AI-enhanced workflow for your team.
  • You’re no longer intimidated by AI headlines or vendor pitches.

• Questions you will be able to answer

  • Right now (orientation)

    • What does it mean to look into the AI Black Box?
    • How is the BEFORE → INSIDE → AFTER Mental Model designed?
    • How can Dentro de AI help me as repository & reliable resource?

  • BEFORE – Setup, architecture, training

    • What needs to be considered before training a modern AI model?
    • How do data, scale, and training choices shape what a model is good or bad at?
    • Where are the natural limits of what I can expect from an AI model?

  • INSIDE – A giant mathematical function

    • How does it look like Inside AI? What does that even mean?
    • How to understand that an LLM is “just predicting the next token”?
    • Why can the model sound confident and still be wrong - even haluzinating at the same time?
    • What do tokens, embeddings, parameters, and context window mean in practice?

  • AFTER – Prompting, context, workflows

    • How do I brief AI so it reliably helps with my work?
    • What are the Do's and Don'ts when interacting with AI?
    • What is a context window?
    • How does it all fit together?

  • By the end of the 3 weeks

    • What is AI?
    • What happens inside the AI Black Box before and after prompting?
    • What is an AI Model - and what is it not?
    • What happens with my prompt within the AI Black Box?
    • How to use the knowledge insights for prompting?
    • Which use cases are suitable for AI?
    • How can I explain AI in easy terms?

---

AI Mental Model

At the heart of this curriculum is one simple (but powerful) mental model for the AI Black Box.

BEFORE

1. Tokenize – turn text into tokens (vocabulary).
2. Architecture – choose a transformer with layers; parameters will be learned.
3. Embeddings – map tokens to vectors capturing meaning.
4. Model type & deployment – text-only, vision, multimodal; open vs. closed weights; on-prem vs. cloud.
5. Training data & objectives – decide what the model sees, how it learns, and where bias can creep in.

INSIDE

1. Giant mathematical function – hundreds of layers and billions of parameters.
2. Next-token prediction – predicts probabilities for the next token, not “truth”.
3. Attention – decides which parts of the context matter for each token.
4. Sampling – temperature / top-p to balance determinism vs. creativity.

AFTER

1. Context window – how much the model can “hold in mind”.
2. Prompt patterns – role, task, context, constraints, output template.
3. Tools – RAG, function calls, code execution, images, etc.
4. Guardrails – safety filters, validation, traceability, evaluation, human review.

This curriculum is built around these three phases. Each week focuses on one phase:

• Week 1 → BEFORE
• Week 2 → INSIDE
• Week 3 → AFTER

---

Curriculum How-To

• The plan is structured as a 3-week path around the BEFORE → INSIDE → AFTER model.
• 3 weeks with 3 categories each: Overview | Learn | Practice

You can follow it strictly week by week – or treat it as a menu and jump around. You find an overview box at each week and you can use the Table of Contents navigation. The complete course structure is on this one page in chronological order, but does link to other areas of dentro.de/ai, like visualizations, glossary entries or articles. We use these building blocks, which you can visit any time for deeper learning:

Core building blocks used throughout

• AI Timeline – historical & cultural context
• AI Glossary – plain-English definitions
• AI Visualizations – interactive tools & videos
• The Big Players in AI – industry landscape
• AI Blog – the three cornerstone articles:
  • How Large Language Models like ChatGPT Work
  • AI Model Lifecycle – Analogy Explained with Cars
  • Understanding Open Source in AI Models
• AI News - bonus content to stay up-to-date

Let's go!

---

🟪 ⬜️ ⬜️ Week 1 - BEFORE

	BEFORE (Week 1)	INSIDE (Week 2)	AFTER (Week 3)
Overview	Where modern AI models come from	What happens inside the AI black box	How models behave when you use them
Learn	Foundations of AI & LLM lifecycle · Data & training	How LLMs represent, process, and score text	Prompting, randomness, model differences & evals
Practice	Explore how raw text becomes model-ready input	See the internal mechanics in action visually	Probe model behaviour and compare responses

Overview

This is your BEFORE week.
You’ll focus on everything that exists before you ever type a prompt:

• A defined vocabulary set of tokens (IDs)
• The model lifecycle up to and including the large-scale training run (phases 1–5)
• A basic feel for how text → tokens → token IDs works

By the end of Week 1 you should:

• Be comfortable with the basic AI vocabulary and the BEFORE → INSIDE → AFTER mental model.
• Understand the LLM lifecycle BEFORE phase (phases 1–5 of the car/assembly-line analogy).
• Have an intuition that:
  • text is turned into token IDs from a vocabulary, and
  • a massive training run bakes patterns into the model before anyone uses it.

Learn

Step 1.1 – Orientation

• If you not have already done so, read the Intro at the top of this page.

Step 1.2 – Lifecycle 1–5

• Read: AI Model Lifecycle – Analogy Explained with Cars

  Focus on phases 1–5 of the article:

  • Architecture Design & Research
  • Data Curation & Preprocessing
  • Training, Tuning & Alignment
  • Infrastructure & Code Finalization
  • Large-Scale Model Training (Core Creation)

  Together, these are the BEFORE phase:

  • you design the model and plan the factory (1, 4)
  • you decide what data goes in (2)
  • you run smaller test runs and alignment (3)
  • and finally, you execute the big assembly-line style training run (5) that “bakes” the patterns into the model.

Step 1.3 – TL + Glossary

• Browse the AI Timeline.
  • Focus on the Transformer and ChatGPT moment, which had massive impact for the state of AI.

• Skim the AI Glossary. Don’t memorize – just see what’s available.

  Key glossary terms for Week 1

  • AI, Machine Learning, Deep Learning

  • Model, Parameters, Training, Inference

  • Token, Vocabulary, Embedding, Word Embeddings

  • Data Set, Training Set, Data Preprocessing

Practice

This week is about the BEFORE phase – what exists before you ever type a prompt:

• A fixed vocabulary of tokens (IDs).
• A huge training run (phases 1–5) that turns data + architecture into a trained model.
• The idea that the model later chooses next tokens from a probability distribution over that vocabulary.

---

Exp. 1.1 – Tiktokenizer

Goal:
Feel how normal text is chopped into token IDs and why some text is “token expensive”.

1. Open Tiktokenizer.

2. Paste three kinds of text, one after another:

   • A normal work sentence.
   • A list of numbers or a calculation.
   • Emojis, special characters, repeating characters.

3. For each input, just look at the result:

   • How input is translated into IDs.
   • Total token count.
   • Which words become one token vs several tokens.
   • How numbers, punctuation, emojis are split.

4. Make small edits:

   • Make one version shorter (same meaning, fewer words).
   • Make one version more detailed (extra context).
   • Optionally, reformat into bullet points or add headings.

5. After each change, check:

   • How much did the token count change?
   • Which edits give you more meaning per token?
   • How are the IDs representing the written input?

Takeaway:
The model doesn’t see “words” or "numbers", it sees a sequence of token IDs from its fixed vocabulary (cl100k_base in this case), and every extra bit of text has a token cost in a limited context window. The concept of tokenization has been introduced for efficiency reasons.

---

Exp. 1.2 – Vocabulary

Goal:
Get a feel for the size and structure of the model’s vocabulary and how words map to IDs.

1. On the AI Visualizations page, under Tiktokenizer, click the link for cl100k_base vocabulary.

2. Scroll or search in that file and notice:

   • Rough number of entries (size = 100k, precisely 100256).
   • That each entry has:
     • A token string (text piece).
     • An integer ID.

3. Go back to Tiktokenizer and:

   • Paste a short sentence.
   • Hover each coloured token to see its token text and ID.
   • Look up one or two of those IDs in the vocabulary file.

4. Try with:

   • A very common word (e.g. “the”, “and”, “time”).
   • A more unusual word (e.g. a brand name, a technical term).

As you play, keep this mental picture:

• The model has a large but finite vocabulary.
• At each step it will later choose one ID from this vocabulary based on probabilities.
• Common patterns → higher probability tokens; rare patterns → lower probability tokens (you’ll see the probability side more clearly in Week 2).

---

Exp. 1.3 – Assembly Line

Goal:
See how the whole front half of the lifecycle (phases 1–5) belongs to BEFORE: everything that happens before you get a finished model.

1. Open the blog post AI Model Lifecycle – Analogy Explained with Cars.

2. Skim phases 1–5:

   • Architecture Design & Research
   • Data Curation & Preprocessing
   • Training, Tuning & Alignment
   • Infrastructure & Code Finalization
   • Large-Scale Model Training (Core Creation)

3. For each phase, just think (quick mental notes are enough):

   • Is this mainly about design, data, infrastructure, or the big training run?
   • Is this something our organisation would do itself, or would we rely on a vendor?

4. At the end, ask yourself:

   • “If I had to explain where most of the value is created, which phase would I point to?”
     (Hint: the big training run / assembly line in phase 5 is where data + design + compute turn into a trained model.)

Takeaway:
The BEFORE phase is a whole massive pipeline (phases 1–5) with large scale training needing enormous compute. Most companies won’t run that pipeline themselves, but understanding it helps you ask better questions of vendors and evaluate their claims.

---

⬜️ 🟪 ⬜️ Week 2 — INSIDE

	BEFORE (Week 1)	INSIDE (Week 2)	AFTER (Week 3)
Overview	Where modern AI models come from	What happens inside the AI black box	How models behave when you use them
Learn	Foundations of AI & LLM lifecycle · Data & training	How LLMs represent, process, and score text	Prompting, randomness, model differences & evals
Practice	Explore how raw text becomes model-ready input	See the internal mechanics in action visually	Probe model behaviour and compare responses

Overview

This is your INSIDE week.
You’ll focus on what happens inside the model once your tokens enter:

• A giant FIXED mathematical function
• Many layers, high-dimensional operations and billions of parameters
• Embeddings and attention as core building blocks
• Next-token probabilities and sampling (why the model is non-deterministic)

By the end of Week 2 you should:

• Be able to explain, in plain language, what happens from tokens to next-token probabilities.
• Understand why the model is a FIXED function after training (weights = frozen knowledge).
• Have a mental picture of:
  • embeddings in a vector space
  • attention deciding what to focus on
  • sampling (temperature, top-p) making outputs more or less creative.
• Be comfortable saying “LLMs predict the next token distribution, not truth.”

Learn

Step 2.1 – How LLM Work

• Read the article:
  How AI Large Language Models (LLM) Work

Pay special attention to these sections:

• The Building Blocks: Turning Words into Numbers
  How text becomes tokens and embeddings.

• The Core Task: Predicting What Comes Next
  The model calculates a probability for every token in its vocabulary as the next token.

• Inside the Model: Layers, Weights, and Fixed Knowledge
  After training, the weights are FIXED – the model is a giant mathematical function.

• Putting It All Together: From Prompt to Generated Text (Inference)
  How a prompt flows through: tokenize → embeddings → layers + attention → next-token probabilities → sampling (temperature) → output.

---

Step 2.2 – 2 x Video

Go to AI Visualizations, Videos section.

1. Short intro (8 minutes) – 3Blue1Brown

   • Watch: Large Language Models explained briefly
   • This 8-minute video from 3Blue1Brown gives a clear, conceptual overview of how LLMs work.
   • It emphasises that LLMs are trained on huge amounts of text to do one thing extremely well:
     predict the next word/token in a sequence.
   • As you watch, connect it to Step 1:
     • “Predict the next word” = the probability distribution over the vocabulary you saw in the article.
     • The diagrams for embeddings and layers match the building blocks section.

2. Deep dive (3.5 hours, high signal) – Andrej Karpathy

   • Watch in chunks over the week (you don’t have to binge it):
     Deep Dive into LLMs like ChatGPT
   • This 3.5-hour lecture by Andrej Karpathy walks through the three-stage process:
     1. Pretraining – internet-scale training to create a base model.
     2. Supervised Finetuning (SFT) – teaching the model to be a helpful assistant.
     3. Reinforcement Learning (RLHF) – refining behaviour using human feedback.
   • For Week 2, you don’t need to catch every detail; focus on:
     • How he explains a model as a big function mapping tokens to probabilities.
     • How the training stages relate to your BEFORE (phases 1–5) and INSIDE (phase 6) mental model.
   • You can treat this as a “bonus university lecture” that you chip away at over time.

---

Step 2.3 – Lifecycle 6

Revisit the lifecycle article:

• AI Model Lifecycle – Analogy Explained with Cars

Focus now on Phase 6 – Trained Model Weights (Parameters).

• Phases 1–5 (Week 1) were BEFORE: design, data, training, infrastructure, and the big assembly-line training run.

• Phase 6 is your INSIDE:

  • The result of training is a fixed set of weights/parameters – the model’s “frozen brain”.
  • Those weights encode the model’s behaviour and “knowledge”.
  • During normal use (inference), these weights do not change – you are feeding tokens in and getting probabilities out.

• One-sentence summary:

  • “Inside the black box is a giant, fixed mathematical function (the trained weights) that turns a sequence of token IDs into a probability distribution over the next token.”

---

Key glossary terms for Week 2

From the AI Glossary:

• Attention Mechanism
• Embedding, Embedding Space
• LLM, Transformer Architecture
• Autoregressive
• Parameters, Model
• Temperature, Greedy Decoding

Practice

This week’s practice is about seeing and feeling what happens INSIDE:

• How a prompt becomes embeddings and flows through layers.
• How attention decides which tokens matter.
• How the model outputs a probability distribution and then samples a next token.

No long write-ups – mostly click, watch, and connect it to what you’ve read and watched.

---

Exp. 2.1 – LLM Viz

Goal:
See the full path from tokens → embeddings → layers → probabilities → sampled token, just like in the “How LLMs Work” article and the 3Blue1Brown video.

1. Open AI Visualizations and click LLM Visualization.

2. Select nano-gpt (very small model) and start the flow through the model by pressing Space.

3. Step through the visualization and look for these waypoints:

   • Tokenization
     Where does the prompt get turned into tokens (little pieces of text)?

   • Embeddings
     Where do those tokens become vectors / numbers instead of words?

   • Layers / Transformer
     Watch how the representation is updated across layers – each layer transforms the vector a bit more.

   • Probabilities
     Find the point where the model produces a score or probability for every token in the vocabulary as the next token.

   • Sampling
     Finally, see how one token is chosen from that distribution to extend the text.

4. Notice that each run is only ever producing the next token.

Takeaway:
The model always computes a probability distribution over the vocabulary, then a sampling rule picks one token. Creativity vs. reliability is largely a sampling-time choice, not something that changes the trained weights.

---

Exp. 2.2 – Attention

Goal:
Develop an intuition for attention – how the model decides which earlier tokens to focus on.

1. In AI Visualizations, open Transformer Explainer.

2. Use the Examples dropdown to select different prompts.

3. In the attention view:

   • Hover over a token.
   • Look at which other words it connects to with higher values.

4. Optional, more advanced:

   • Open BertViz from the same page (opens in Google Colab).
   • Interactively inspect the cells and how attention is distributed across the tokens.

Takeaway:
Attention lets each token “look back” at all other tokens and decide which ones matter most. This is how transformers turn a sequence into something where long-range context can influence each prediction.

---

Exp. 2.3 – Moebio Mind

Goal:
Build a feel for networks of simple units creating complex behaviour – without any equations.

1. In AI Visualizations, under Interactive Websites, click Moebio Mind.

2. Play with it for a few minutes:

   • Hover across the spectrum and watch how the words and sentence travels through the probabilities.
   • Hover on different places and see how patterns change - the viz is simulating the probability game.
   • Let it settle, then start again.
   • Use the 3D Vector space to see how words are combined to a sentence and meaning.

3. Notice:

   • Locally, each node’s behaviour is simple – respond to signals from neighbours.
   • Globally, you get rich, emergent patterns resulting in meaning.

Takeaway:
Modern AI models are also made of many simple components (neurons, attention heads, layers) wired together. You don’t need to understand every detail; it’s enough to feel that structure + connections can lead to surprisingly complex behaviour – which is exactly what you see when an LLM produces fluent text.

---

After Week 2, the Black Box should feel less magical:

• We looked INSIDE the AI model.
• You know the sequence tokens → embeddings → layers + attention → probabilities → sampled tokens.
• You see the model as a FIXED mathematical function (parameters, weights) that you probe with prompts, not something that “learns on the fly” from each of your inputs.

---

⬜️ ⬜️ 🟪 Week 3 — AFTER

	BEFORE (Week 1)	INSIDE (Week 2)	AFTER (Week 3)
Overview	Where modern AI models come from	What happens inside the AI black box	How models behave when you use them
Learn	Foundations of AI & LLM lifecycle · Data & training	How LLMs represent, process, and score text	Prompting, randomness, model differences & evals
Practice	Explore how raw text becomes model-ready input	See the internal mechanics in action visually	Probe model behaviour and compare responses

Overview

This is your AFTER week. You’ll focus on how models behave when you use them:

• What actually happens after you press Send (from prompt to sampled answer).
• Why the same prompt or different models can give different answers.
• What makes a good prompt, and where prompts / models tend to break.
• How people use small benchmarks / evals to compare models and settings.
• How this fits with BEFORE (tokens & training) and INSIDE (embeddings & attention).

By the end of Week 3 you should:

• Be able to narrate what happens after you send a prompt:
  • prompt → tokens → fixed mathematical function → next-token distribution → sampling → extend prompt → repeat.
• Understand why answers differ:
  • the same prompt can give different answers (sampling, temperature), and
  • different models give different answers to the same prompt (different weights, training data, safety layers).
• Have intuition for where models break:
  • “R in Strawberries” (letter-level reasoning),
  • structured SVG / code tasks like Bouncing Ball Hexagon, Vitruvian Robot,
  • Pelican riding a bicycle as another SVG benchmark.
• Know what a tiny eval is: a small, reusable set of prompts to compare models or settings, instead of trusting a single cool demo.

Learn

Step 3.1 – How LLM Work

From the LLM article:

• How AI Large Language Models (LLM) Work

Re-read the sections around “Putting It All Together: From Prompt to Generated Text (Inference)”.

Focus on the AFTER flow:

• Your prompt (and chat history) is tokenized.
• Tokens are turned into embeddings and passed through the transformer layers.
• The model computes logits / scores for every token in the vocabulary.
• These are turned into a probability distribution over the next token.
• A sampling rule (temperature, top-p, etc.) chooses one token.
• That token is appended to the prompt and the process repeats.

This is the micro-view of AFTER: one request, one generation.

---

Step 3.2 – Lifecycle 7–9

Reopen the AI Lifecycle article:

• AI Model Lifecycle – Analogy Explained with Cars

In Week 1 you focused on phases 1–5 ( BEFORE).
In Week 2 you looked at phase 6 ( INSIDE).

This week, look at phases 7–9 ( AFTER):

1. Deployment & Access Provisioning – how the trained model is exposed (APIs, products).
2. Inference Engine & Interaction – what happens when your prompt hits the model.
3. Ongoing Model Usage – using the model again and again, with monitoring and updates.

Think of it like this:

• BEFORE (1–5): designing and building the car factory + assembly line.
• INSIDE (6): the finished engine + car.
• AFTER (7–9): car delivery and people driving the cars every day.

Your Week-3 practice will live in that “driving” world.

---

Step 3.3 – Open Weights

One more angle on AFTER comes from the open-source blog:

• Understanding Open Source in AI Models

Revisit how it distinguishes:

• Closed Source models – you use them via an API or product; internals are hidden.
• Open Weights models – weights are published, but not necessarily full training code/data.
• Truly Open Source models – code, weights, and often datasets or recipes are public.

Connect this to AFTER:

• Different models = different frozen mathematical functions (different weights, data, architecture).
• That’s why the same prompt can behave very differently across models.
• Fun examples (all linked from AI Visualizations):
  • Bouncing Ball Hexagon – simple physical/geometry challenge, many models fail in different ways.
  • Vitruvian Robot – “Vitruvian Robot in SVG (embedded in HTML). Don’t ask back.”
    Different models produce very different SVG – sometimes creative, sometimes broken.
  • Pelican riding a bicycle (external benchmark by Simon Willison) –
    Generate an SVG of a pelican riding a bicycle – a now-famous test for structured, creative SVG output.

AFTER is not “one AI”. It’s a whole ecosystem of different Black Boxes – and you now have the tools to recognise and compare their behaviour.

Practice

In Week 3 you are not “doing homework”.
You’re playing scientist with the behaviours of LLMs:

• Try prompts.
• Notice how different models behave.
• Use your BEFORE + INSIDE knowledge to explain why.

Do as many of these as you like – they build on each other.

---

Exp. 3.1 – Strawberries

Goal:
See a classic failure mode and explain it with what you know about tokens and training.

1. From the AI Timeline, find “The 'R in Strawberries' Problem” (2023-01).
   It’s the simple question:

   “How many r’s are in ‘strawberries’?”

2. Ask one or more models you have access to:

   • “How many r’s are in ‘strawberries’?”
   • Model providers addressed this by now, but usually models have difficulties to "count".

Just observe:

• Does the model always get it right?
• Does it ever answer confidently but incorrectly?

Why this happens (connect to BEFORE + INSIDE)

• The model works on tokens, not characters.
• In Week 1 you saw how tokenisation splits text into subword pieces – not into individual letters.
• In Week 2 you saw that the model learns patterns over tokens in embedding space, not over letters.
• Counting letters is “off-grid” for that representation, so the model is effectively guessing based on patterns, not running a precise algorithm.

Once you see this, the failure is no longer mysterious – it’s a natural consequence of the architecture.

---

Exp. 3.2 – Same Prompt

Goal:
Experience non-determinism and model differences – and explain them in terms of probabilities and different fixed functions.

1. Pick a light, open-ended prompt, for example:

   • “List 5 creative analogies for the AI black box.”
   • Or any fun prompt you come up with.

2. Same prompt, same model, multiple runs

   • Run the prompt 3–5 times on the same model.
   • If your tool has a temperature or “creativity” slider (try openrouter.ai as provider):
     • Try with low value (e.g. 0–0.2) vs
     • with higher value (e.g. 0.7–1.0).
   • Notice:
     • How similar/different are the answers?
     • Does higher temperature make the model more varied but also more error-prone?

3. Same prompt, different models (if you have access)

   • Run the same prompt on a second model (or more, if you can).
   • Optionally, compare with public examples:
     • Vitruvian Robot gallery on AI Visualizations.
     • Simon Willison’s pelican riding a bicycle SVG benchmark.
     • The Bouncing Ball Hexagon challenge.

Why this happens

• In Week 2 you learned that, for each step, the model produces a probability distribution over the vocabulary and then samples a token.
  • Same model + same prompt + same settings → still sampling → different tokens can be chosen.
  • Temperature changes how “flat” or “peaky” that distribution is, which changes how adventurous sampling becomes.
• Different models have:
  • Different weights (phase 6 of the lifecycle – a different mathematical function).
  • Different training data and sometimes different architectures.
  • Different safety/decoding settings in the deployment stack (phases 7–9).

So:

• Same prompt, same model → different sample from the same distribution.
• Same prompt, different model → sample from a different distribution produced by a different function.

---

Exp. 3.3 – Good Prompt

Goal:
Connect good prompting patterns back to tokens, embeddings, and training data – not “magic prompt hacks”.

1. Pick a simple, real task, e.g.:

   • “Summarise this email thread into 5 bullet points for leadership.”
   • “Draft a polite reply to this customer asking for a refund.”
   • “Explain this concept to a non-technical colleague.”

2. Try two versions of the prompt:

Version A – Minimal / vague

• “Summarise this email thread.”
• “Reply politely.”

Version B – Structured

• Role: “You are an assistant to a VP at a large company.”
• Task: “Your task is to summarise the following email thread.”
• Context: “The audience is executive leadership; they care about decisions, risks, and next steps.”
• Constraints: “Maximum 5 bullet points, no jargon, mention risks explicitly.”
• Output: “Return only the bullet points.”

(Use your own wording; the structure is what matters.)

Run both versions on the same model and compare.

Just notice:

• Does the structured prompt give an output that feels more “on target”?
• Is it easier to reuse the structured prompt pattern in other situations?

Why this works

• A prompt is just more tokens.
• During training, the model saw many examples of structured text: instructions, Q&A, docs, bullet lists, JSON, etc.
• When you give it a structured shape (role, task, context, constraints, format), you’re helping it:
• land in the right region of embedding space, and
• match patterns from training that looked similar.
• Clear output instructions reduce the number of plausible continuations, so the probability mass is focused on outputs that match your desired shape.

Once you understand this, “prompt engineering” stops feeling like superstition and becomes “sending better signals into a probabilistic system”.

---

Exp. 3.4 – Tiny Eval

Goal:
Build a tiny, human-sized version of an eval: a small set of prompts you can reuse to compare models or settings.

1. Choose 5–10 prompts from your own domain. For example:

   • 2–3 straightforward questions where you know the correct answer.
   • 2–3 “typical” tasks (short summary, rewrite, simple explanation).
   • 1–2 “edge cases” or tricky questions (your own version of “R in Strawberries”).

2. Run your mini-eval:

   • Option A: Same model, different settings

     • e.g. deterministic vs “creative” mode, or with vs without a special system prompt.

   • Option B: Different models

     • Run the same prompts on two different models you have access to.

3. For each prompt, just mentally note:

   • Which model/setting gave you the most useful answer?
   • Are there prompts where one model consistently struggles?

Why this matters

• This is exactly the idea behind formal evals and benchmarks:
  • A fixed set of inputs.
  • Compare how different models behave on them.
• Public challenges like:
  • R in Strawberries (letter-level reasoning),
  • Bouncing Ball Hexagon (physics + geometry + code),
  • Vitruvian Robot and Pelican riding a bicycle (structured SVG + creativity), are all just specialised evals that stress specific capabilities.

The key habit is:

• Don’t decide “this model is good” based on one impressive answer.
• Decide based on repeatable behaviours across a small test set.

---

Exp. 3.5 – Full Loop

Goal:
Mentally rehearse the entire BEFORE → INSIDE → AFTER chain on a real prompt, so it finally “clicks”.

1. Pick any prompt you used in the earlier experiments.

2. As the model responds (or as you step through the visualization), walk through this in your head:

   1. Prompt ( AFTER) – you type text into the box.
   2. Tokenisation ( BEFORE) – the system turns your text into tokens (IDs) from a vocabulary.
   3. Embeddings & layers ( INSIDE) – those IDs become vectors, pass through many transformer layers with attention.
   4. Next-token distribution ( INSIDE) – the model computes a probability for every token in the vocabulary.
   5. Sampling ( AFTER) – a sampling rule (temperature, etc.) picks one token.
   6. Extend the prompt ( AFTER) – that token is appended to the text…
   7. …and the whole process repeats until some stopping condition is met.

If you can “see” this sequence in your mind for any prompt you send, the Black Box has gone from magic to mechanism – which was the whole point of this three-week journey.

---

Optional Modules

These are “bonus tracks” you can explore after (or alongside) the core 3-week path.

– Industry & Vendor Landscape Deep Dive

If you want a better feel for the AI value chain and strategic positioning:

• Spend more time in The Big Players in AI.
• Use the AI Timeline to trace how key players evolved.
• Pair this with your own reading on investment, regulation, and hardware.

Open Source, Open Weights & Governance

Learn the different approaches on control, compliance, and transparency:

• Re-read Understanding Open Source in AI Models.
• Cross-reference open vs. closed models with your own requirements depening on the use case.

Technical Deepening via Visualizations

If you’d like to get a bit more technical without diving into code:

From AI Visualizations, re-visit this mini-track:

1. Tiktokenizer – understand tokenization.
2. LLM Visualization – see the full prompt → tokens → embeddings → prediction pipeline.
3. Transformer Explainer / BertViz – get a feel for attention patterns and inner layers.
4. LLM Architectures – browse how different modern models are structured.

Glossary Quiz

Test your own AI Vocabulary! Head to the Quiz at the top of the Glossary section and challenge yourself.

Select Next Random Term and Show Definition to reveal the answer.

News Room

Dentro de AI has a News Section! Manually curated and powered behind the scenes with LLM support (to prove the point). A regular digest of the most important headlines from the busy AI/ML world. Some gossip too to spice it up.

Expectation After 3 Weeks

If you followed this curriculum (imperfectly is still fine!), you should:

• Have a solid mental model of BEFORE → INSIDE → AFTER the AI Black Box.
• Have an understand of the fundamentals INSIDE the AI Black Box.
• Be able to explain LLMs and the model lifecycle to non-technical colleagues.
• Use 2–3 AI-supported workflows in your real job, with clear human-in-the-loop safeguards.
• Be able to push back on AI hype and ask vendors sharp, informed questions.

And maybe most important:
AI will feel less like magic and more like a powerful, understandable tool that you can reason about.

---

If you've come this far: thank you! Let me know if is helpful.

One last goodie for reading all the way: press f (for find) or / anywhere on the site to invoke the Search function.