LLM Teaching Kits That Make ChatGPT Click (Unplugged)

LLM Teaching Kits That Make ChatGPT Click (Unplugged)

Introduction

If you’ve ever watched someone type a prompt into ChatGPT and then walk away acting like the model “understands,” you’ve probably felt the same frustration: how is this thing producing that answer so smoothly, and what’s actually happening under the hood? The tricky part is that most people don’t have a mental model for text generation—they just experience outputs.

New research from the arXiv paper “LLMs Unplugged: Teaching Resources for a ChatGPT World” tackles that problem with an intentionally old-school solution: unplugged, hands-on activities that teach how language models generate text step by step. The big idea is simple but powerful—build a tiny language model yourself using pen-and-paper counting (specifically n-grams), then generate new text by repeatedly making weighted random choices.

Even better, this isn’t just theory. The authors report delivering these materials to over 400 participants across secondary, tertiary, and executive education contexts, including groups as small as 5 and as large as 50. And the consistent qualitative feedback: the activities demystify LLMs by reframing them as scalable “next word generation,” not magic reasoning.

Why This Matters

Here’s why this research feels especially urgent right now: LLMs have become everyday infrastructure for writing, summarising, brainstorming, and decision support. But most training about AI still comes in two unhelpful extremes—either “it’s magic,” or “it’s math.” If you’re a journalist, public servant, manager, or teacher, you don’t need to design models from scratch—you need a reliable intuition for what they do and what they don’t do.

A very real scenario: imagine a government team using an LLM to draft policy briefings. The risk isn’t just hallucinations—it’s over-trust driven by misunderstanding. If people think the model “reasons like a person,” they’ll treat confident phrasing as evidence. But if they understand the model as probability-driven next-token sampling (patterns learned from text), conversations shift from “Is it true?” to “Is it plausible given the training text and prompt context—and what should we verify?”

This is also a smart continuation of earlier “unplugged” AI education work, but with a key gap filled: prior unplugged resources often teach classification or basic analysis of text, yet they don’t always give learners the experience of generating text in a controllable way. This paper’s contribution is that it keeps the learning loop intact: training → then generation—exactly the loop modern systems rely on. In other words, it builds the mental model that users need before they start trusting (or panicking) every output.

Build Your Own Next-Word Machine: The Core Learning Loop

At the heart of LLMs Unplugged is a mechanic that feels almost too simple: you create an n-gram model from a book, then you use it to generate sentences.

Training with hand-built n-gram “model grids”

Learners pick a children’s book like “Dick and Jane” or “Dear Zoo” as training text. During the training phase, they:
- convert to lowercase,
- treat punctuation as tokens,
- then count which words follow which other words.

Depending on the variant, they do this using either:
- a grid (paper grid + tally marks),
- or buckets (cut text into pieces and sort them into groups).

Either way, the end product is the same: a table of frequencies that represents what the training text tends to do.

Generation with weighted sampling (and a die roll)

During the generation phase, learners generate text by:
1. looking up the current word/context in their model grid,
2. identifying the possible next words and their relative counts,
3. rolling a dice to make a weighted random choice.

The “aha” moment is that the output is not deterministic. That randomness is not a bug—it’s part of the method. This is where the activity connects to real LLM behavior: both are essentially doing iterative next-word prediction using learned statistical structure.

And because learners physically experience the randomness, they start to understand why:
- two prompts that are identical can still yield different outputs,
- outputs can be both fluent and weird,
- “predictable but surprising” is normal.

In the authors’ own workshop delivery, people repeatedly described the insight as LLMs being “just probability and randomness at scale—not reasoning, not understanding,” but pattern matching plus weighted sampling.

Why the Paper’s Activities Actually Demystify LLMs (Not Just “Explain Them”)

Plenty of educational resources can tell you how LLMs work. This one tries to make you feel it in your hands.

The unplugged design principle: remove syntax, keep substance

The paper builds on the philosophy of CS Unplugged: teach core computing concepts without computers so learners focus on underlying principles. That matters here because LLM confusion is rarely about knowing programming syntax—it’s about not having a working model of the pipeline.

So the activities intentionally strip away:
- tooling and model deployment,
- complex neural network terminology,
- heavy math.

But they preserve the essential structure:
- you train by counting patterns,
- you generate by repeatedly sampling from those patterns.

The result is that learners can connect their experience directly to the modern system. The paper explicitly positions this approach as “training-to-generation loop (and beyond)” education, and the materials are built to do that end-to-end rather than stopping at text analysis.

What works in practice: the “shareback” inflection point

The authors report something very practical about delivery: there’s an inflection point after the first round of outputs are generated and shared.

They describe a consistent pattern during workshops:
- the Training lesson is necessary setup,
- but the room “buzzes” during Generation,
- once groups share what their model produced, questions become more incisive and the discussion gets playful.

They even recommend leaving space for dramatic readings of generated text—because laughter isn’t just for fun. It lowers defenses, increases engagement, and keeps the focus on the mechanism that produced the output.

That’s a teaching design detail you can actually reuse immediately if you run any AI literacy session.

How the LLMs Unplugged Curriculum Scales from 90 Minutes to Multi-Day Workshops

The suite is modular, which sounds like a boring logistics point until you realize why it matters: learners and educators need different depths and timelines.

The “Fundamentals” spine: Training → Generation → (sometimes) Pre-trained Generation

The paper describes a core path that many workshops successfully used:
- 2 lessons labeled Fundamentals:
- Training
- Generation
- plus an extension called Pre-trained Generation (optional in a 90-minute run, but often included).

With an additional 30 minutes, they often add the Sampling lesson.

A key detail: this isn’t just a single activity. It’s a progression where later lessons frequently require the model created earlier—or at least models shared between groups.

Grid vs Bucket: same concept, different entry points

To keep the content accessible across ages and numeracy comfort levels, the paper provides two variants for the Fundamentals activities.

The site includes a toggle to switch between these variants, which makes it easy for facilitators to adapt to their class.

Pre-trained Generation: show what “foundation model as a service” means

After learners build their own tiny models, the Pre-trained Generation lesson flips the experience:

Participants get a provided booklet containing a model trained on a larger corpus, so they can generate text without training it themselves.

This is a crucial shift for modern users: most of the time, people don’t train models—they just use them through an interface. The activity makes that workflow obvious by letting learners immediately generate from a ready-made “trained” booklet.

Going Deeper Without Going Full Lab: Extensions That Mirror Real Tradeoffs

The extension lessons are where the curriculum starts to feel closer to the modern transformer world—still unplugged, but more conceptually demanding.

Below is a compact view of what these extensions teach and how they map to practical LLM concerns.

Trigram context: better text, more bookkeeping

The Trigram lesson moves from one-word context to two-word context—tracking what comes next given the last two words.

That typically improves coherence, but it also costs more complexity: far more combinations to track (many more grid rows or buckets). It’s a clean, physical illustration of a central LLM tradeoff: longer context can help, but it increases the state you must manage.

Sampling control: the same model, different “personalities”

In Sampling, learners experiment with generation settings such as:
- temperature (scaling counts before rolling),
- truncation strategies (including greedy and a few constraints like no-repeat or alliteration).

The punchline: you can get meaningfully different outputs from the same trained model by changing how you sample. This mirrors how prompt settings and decoding strategies affect outputs in real systems.

Beam search: why “one path” isn’t always enough

Beam Search is taught as a parallel-path generation exercise:
- multiple students track different generation branches,
- then prune to top candidates after each step.

It shows why search strategies often produce more coherent sequences than simple single-path sampling. Even though this is an unplugged approximation, learners come away understanding that “how you generate” matters as much as “what you trained on.”

Tool use: LLMs generate text, but knowledge may come from elsewhere

The Tool Use extension uses trigger words: when a trigger appears, generation pauses and a “tool” returns an answer.

This is a practical conceptual bridge for modern assistant systems where the model orchestrates external calls. It helps learners understand an important limitation: LLMs don’t inherently contain all knowledge—they may need to delegate.

Context columns and attention previews: a hand-made “attention-ish” mechanism

With Context Columns, learners add categories like “after pronoun” or “after preposition,” and combine those counts with word-specific counts during generation.

The paper frames this as a preview of how transformers learn to weight relevant context—without requiring readers to implement anything. For educators, this is a great “middle step” between counting n-grams and understanding attention as a weighting mechanism.

Embeddings and meaning-as-patterns

In Word Embeddings, learners treat each word’s row in the model grid as a vector and compare similarity between rows.

The outcome: words that appear in similar contexts cluster together. That’s a surprisingly intuitive way to learn that “meaning” can emerge from usage patterns rather than from a dictionary-like lookup.

LoRA and RLHF (conceptually): adaptation and preference shaping

Two extensions also aim at modern training themes:
- LoRA: learners train a small adaptation grid on new domain text and add it to the base model—demonstrating how specialization can happen via lightweight add-ons.
- RLHF: learners generate multiple candidates, vote on preferences, then adjust the model counts based on likes/dislikes—shifting “good” outputs toward human preference patterns.

Synthetic data collapse: why “train on model output” can backfire

Finally, Synthetic Data has learners generate text from their model, train a new model on that generated text, then compare.

They observe degradation: rare words disappear and common phrasing dominates across generations. The paper uses this to demonstrate the risk of “model collapse” when training repeatedly on AI-generated corpora.

What the Authors Found After Running It for Real: Reception from 400+ Learners

This is a practitioner paper, not a controlled study with pre/post test scores or control groups. But it still reports clear qualitative findings from workshop delivery.

Who the learners were

Across sessions at institutions including the Australian National University, the authors ran the activities with about 400 participants. Groups ranged from:
- school-age up through undergraduates,
- and senior executives in short executive education courses,
- with many participants being senior leaders in the Australian Public Service.

That mix matters: it suggests the materials aren’t only effective for people already interested in AI or CS.

What participants consistently reported

The dominant feedback themes were:
- The hands-on activity builds a new mental model of LLMs.
- People often summarize the insight as probability + randomness at scale, not human-like understanding.
- The generative aspect makes it emotionally engaging: learners are delighted when their model produces grammatical text—even when it’s imperfect or nonsensical.

Why this might work better than “lecture explanations”

The repeated emphasis on demystification suggests an important educational mechanism: learners aren’t just receiving an explanation. They’re running the mechanism themselves, so the model stops being an ungraspable black box and becomes a predictable system of choices.

And the playful “shareback” moment seems to amplify that effect—turning conceptual uncertainty into a shared experiment.

Key Takeaways

• LLMs Unplugged teaches the training-to-generation loop using hand-built n-gram models and weighted random sampling, so learners understand how text is generated, not just how it’s classified.
• The core activities work with pen-and-paper counting (grid) or cut-and-sort buckets, making the approach adaptable across age groups and comfort levels.
• In workshops with 400+ participants, learners consistently report that the activities demystify LLMs by reframing them as next-word probability machines.
• The curriculum is modular: you can run a 90-minute session (Training + Generation + often Pre-trained Generation) and add deeper extensions like Sampling or Trigram when you have more time.
• Extensions such as Sampling, Beam Search, Tool Use, Trigram context, embeddings, and RLHF-style preference tuning help learners connect practical LLM behavior to the underlying idea of how decisions are made.
• The larger message for the future: if LLMs are becoming part of how society communicates and decides, then hands-on mental models may be as important as access to the tools themselves.

If you want, tell me your audience (teachers? executives? students?) and time budget (60/90/half-day), and I can suggest the best lesson path from the LLMs Unplugged suite for maximum impact.