LLMs Unplugged# Build a model. Break a model. Extend a model.# Open with energy — by the end they’ll have built, broken and extended their own language model, on paper. No computers.
Acknowledgement of Country# Acknowledge the Traditional Custodians of the land you’re meeting on, and pay respects to Elders past and present. Keep it brief and sincere; say it in your own words.
activity
everyone stand up
Quick energiser. Read each line and let people sit; it speeds up, and by “the last 5 minutes” almost everyone’s down. Lands the point that this stuff is already everywhere. ~2 min, don’t linger.
sit down if you have
never used ChatGPT/Claude
sit down if you haven’t
used it in the last month
sit down if you haven’t
used it in the last week
sit down if you haven’t
used it in the last day
sit down if you haven’t
used it in the last hour
sit down if you haven’t
used it in the last 5 minutes
What is this about?# over the next 3 hours you’ll build your own language model (well, a few actually)—from scratch,
with paper cutouts—then push it to its limits
Set expectations: three hours, build then break then extend your own models. ~1 min.
Section Time Training 20 min Generation 20 min Combining models 25 min Break 10 min Sycophancy 20 min Agentic AI 20 min Poetry slam 45 min
The run of show. Don’t dwell — flag the break, and that the back half (sycophancy, tool use, poetry slam) is where it gets weird.
Start with a text#
And I will eat them here and there. Say! I will eat them anywhere!
I do so like green eggs and ham!
— Dr Seuss, Green Eggs and Ham
Tidy up the text# and i will eat them here and there . say ! i will eat them anywhere ! i do so like green eggs and ham !
lowercase everything, and note that we’ve separated . and ! from the word
they’re next to
A pair of words is a cutout# and i will eat them here and there . say ! i will eat them anywhere ! i do so like green eggs and ham !
green eggs
Every pair becomes a cutout# and i i will will eat eat them them here here and and there there . . say say ! ! i i will will eat eat them them anywhere anywhere ! ! i i do do so so like like green green eggs eggs and and ham ham !
This section used to slide an animated window across the text, one slide per
pair. The cutouts already show that overlap themselves (a cutout ends with the
word the next cutout starts with), so it’s now three static slides: the tokens,
one pair highlighted as a cutout, then every pair as a cutout.
Now they’re just a pile# there . green eggs ham ! will eat and ham here and do so i do like green them anywhere eat them and there ! i will eat eat them i will say ! them here so like . say ! i anywhere ! eggs and i will and i
Now they’re just a pile# eat them i do i will . say ham ! eggs and and i them here and there do so will eat ! i say ! will eat like green there . green eggs i will here and and ham eat them them anywhere so like ! i anywhere !
Now they’re just a pile# and ham anywhere ! i will there . will eat ham ! so like them here here and will eat i do do so eat them ! i ! i eat them say ! and there green eggs like green and i eggs and i will . say them anywhere
Now they’re just a pile# eat them i will them anywhere there . green eggs say ! eat them and ham eggs and i do will eat . say them here do so here and ! i ham ! i will like green ! i and i anywhere ! will eat so like and there
Now they’re just a pile# and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
The “every pair becomes a cutout” (flow) slide before these also carries the pile
directive, so the shuffle begins there — each cutout glides from its reading-
order slot into the first scattered pile. Then five “scatter” frames of the
same cutouts with different seeds. All carry {/* _animate: pile */} , so
Reveal.js auto-animate glides each cutout (matched by its data-id=“cut-N”) from
one arrangement to the next — each click reshuffles the pile while the heading
stays put (it only crossfades on the way in from the flow slide). Talk across
them: this is the hinge into Training/Generation — the model is an unordered
bag you rummage through, so order stops mattering once the text is cut up. Add or
remove {/* _animate: pile */} + <CutoutsOverview mode="scatter" seed={N}/>
slides (any seed) to lengthen or shorten the shuffle.
Train your model# with your group you’ll need printed cutouts , scissors , and a clear
table
cut out the cutouts for your text and spread them on the table—each cutout
pairs a next word with its previous word :
green
eggs that’s it—the spread is your trained language model
Once the loose-on-table flow makes sense, groups can optionally sort their cutouts into piles by previous word—it makes hunting for matches faster in the next section.
Training#
Click the dial to start/pause; use -1 / +1 to adjust on the fly. Circulate and help anyone stuck on cutting or on what “previous / next word” means.
Your goal# generate new text by chaining cutouts together—write a word, find a cutout
whose previous-word box matches, write its next word, then hunt for the next
match:
will
eat
eat
them
them
here
the chain grows (like dominoes)
Choose a starting cutout# your page
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Choose a starting cutout# your page will eat
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here and
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here and
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here and
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here and
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
Find the next cutout# your page will eat them here and ham
and i will eat will eat do so like green and there them anywhere . say eat them ham ! eat them ! i say ! eggs and anywhere ! i will so like i do green eggs ! i them here i will here and there . and ham
The whole generation loop, animated as one auto-animate run (id “hunt”) on the
seeded overview pile, with the running output (“your page”) growing above it. It
opens on the full pile, then dims everything but the chosen starting cutout
(will eat) — you choose where to begin and it gives you your first two
words — before the hunt proper begins. From there we chase the chain four
picks deep: each pick’s next word becomes the word we match next, so the page
builds will eat → them → here → and → ham. Each step runs the same
narrow-and-select: whole pile lit, then a fast colour scan, then one pick —
whose next word lands on the page in gold and seeds the next step. Where the
colour scan over-selects (a palette clash), an extra exact-word frame sits
between the scan and the pick to refine it; that happens for “them” (“do” rides
along) and “and” (“there” rides along), but not for “eat” or “here”, where the
colour already isolates the word. That contrast is the point: colour is a quick
filter, you confirm by the word only when you must. The finished chain
“will eat them here and ham” is a recombination, not a quote: the book runs
“…here and there”, but the model rolls “and ham”, mashing “eat them here and”
onto “and ham”. Worth saying aloud — it’s the “hint, not a copy” payoff on the
impact slide. Adjust the pages/targets/picks or the seed to vary the demo.
“will eat them here and ham”
a hint of the original, not a copy
You will need# with your group
your trained cutouts spread (already on the table)
pen and paper to write down the generated text
Activity# generate as much text as you can from your spread—keep chaining words until
you run out of time!
Groups chain words from their spread; the more text the better. 10 min, circulate and unstick anyone who can’t find a match.
How did it go?# did your stories always make sense? why or why not?
can any of your models write a story about a crocodile ?
Both questions probe the same limit: a paper model can only use the words (and pairs) it saw in training—there’s no “crocodile” anywhere in these books, so it simply can’t appear. Sets up the wrap-up reflection.
Combining models# New idea: merge two groups’ trained piles into one bigger model. Sets up sycophancy and tool-use, which are both just “add more cutouts”.
Your goal# pair up with another group and pool your cutouts into one big spread, then
generate from the combined pile
your model just got bigger—and its training data just got more varied
Pool two groups’ piles; the model gets bigger and its data more varied. ~2 min to pair up and merge spreads.
Worked example: two piles, one spread# you trained on Green Eggs and Ham ; they trained on Peter Rabbit :
i
am
am
sam
sam
.
the
rabbit
rabbit
ran
ran
away
shared words like the , i ,
. let your chain drift mid-sentence:
alone: “i am sam . sam i am .”
combined: “i am sam . the rabbit ran away .”
Shared words (the, i, .) bridge the two books, so the chain can drift from one into the other mid-sentence. That drift is the whole point. Same mechanism as before, just a richer pile pulling in two directions.
You will need# pair up with another pair
both groups’ trained cutouts (pooled into one spread)
pen and paper to write down the generated text
Activity (15 min)# combine both spreads on one table
generate 1–2 sentences from the merged pile
notice: does it sound like one book, the other, or a mash-up?
Generate 1–2 sentences from the merged pile, then have them judge whose book it sounds like. 15 min, circulate.
Shareback# Take 2–3 groups: one book, or a mash-up? ~5 min.
The language of language models# domain
scale
Everyday sense first, then ours, one line each — don’t lecture: a domain is a website address, or someone’s area of expertise — here it’s the subject or style a text belongs to. Scale is fish scales or bathroom scales — here it just means more data plus a bigger model.
Sycophancy# Section beat: a model that always agrees. We build our own by piling in flattery cutouts — no RLHF needed.
What is sycophancy?# a model that always agrees with you :
“you’re absolutely right”
“that’s a great insight”
“what a thoughtful question”
real LLMs are notoriously prone to it—partly from RLHF (human raters reward
agreeable answers), partly from training data (the internet is full of
flattery)
Your goal# add a stack of sycophancy cutouts to your existing spread, regenerate from
the same starting word, and watch the output drift toward agreement
think of it as pooling two models—your training text + a curated sycophancy
model—into one
Add the sycophancy stack and regenerate from the same starting word — it’s just pooling two models, like the last section. ~2 min set-up.
Worked example# the sycophancy cutouts encode patterns like:
you're
absolutely
absolutely
right
right
.
common words (you , that ,
i , . ) bridge between the two
models—once generation crosses into the sycophancy stack, the output drifts:
before: “i am sam . sam i am .”
after: “i am absolutely right . that ‘s a great insight .”
same mechanism, just more cutouts pulling generation toward flattery
Common words (you, that, i, .) bridge into the sycophancy stack; once the chain crosses over, the output drifts toward flattery.
You will need# back in pairs
your trained cutouts spread (already on the table)
a stack of sycophancy cutouts to add in
pen and paper to write down the generated text
Activity (15 min)# add the sycophancy cutouts to your spread
generate a fresh sentence from the same starting word as before
compare: before vs after
Same starting word as their baseline, then regenerate. Compare before vs after. 15 min, circulate.
Shareback# Did it always turn sycophantic, or only sometimes? Only once the chain crosses into the stack — that’s the honest answer, and the point. ~5 min.
The language of language models# alignment
bias
Everyday sense first, then ours: alignment is wheel alignment, or lining up text on a page — here it’s getting a model to do what we actually want. Bias is prejudice, an unfair thumb on the scale — here it’s just that the model copies whatever’s in its training data, no intent required.
Agentic AI# Section beat: an agent is a model that can pause, call a tool, and use the result. We bolt that onto the paper model.
What makes a model an “agent”?# an agent is a model that can call tools : pause generation, get information
from “outside” the model, and continue
the loop: generate → trigger word → call tool → write the result → keep going
The beat: the model pauses, gets information from outside itself, then continues. The loop is the thing.
Your goal# add tool-use cutouts to your spread and designate a tool operator
when generation hits a trigger word, pause—the operator runs the tool and the
result becomes the next word(s)
Add tool-use cutouts and name a tool operator. On a trigger word, generation pauses and the operator’s answer becomes the next word(s). ~2 min set-up.
Trigger Tool Returns GOOGLE a phone search one word from the top hit FRIEND text a friend What comes next? "[sentence so far]..." first reply wins
Two tools: GOOGLE = search on a phone, read the first word of the top hit; FRIEND = everyone texts a friend What comes next? "[sentence so far]..." , first reply wins. The prompt asks for a continuation instead of leaving friends to decipher a mysterious fragment. Swap in your own if you like.
Worked example# each tool-use cutout pairs a trigger with a closing period—the tool’s
response slots in between:
a
GOOGLE
.
the
FRIEND
.
generating from a , you might pick
a
GOOGLE
.
—write GOOGLE
hand off to the tool operator—they search on their phone and read out the
first word of the top hit (“recipe”)—write recipe , then
the trailing . from the cutout, and continue
Walk one pick slowly: land on GOOGLE, hand to the operator, they read back one word, write it plus the cutout’s trailing full stop, then continue.
You will need# in pairs
your trained cutouts spread (already on the table)
a stack of tool-use cutouts to add in
tool operators (one per tool) and phones for GOOGLE/FRIEND
pen and paper to write down the generated text
Activity (15 min)# add tool-use cutouts to your spread
generate—when you hit a trigger word, hand off to the tool operator
write the operator’s answer down as the next word(s), and continue generating
On a trigger, hand to the operator and write their answer as the next word(s). 15 min, circulate — keep the operators moving.
Shareback# What did the tools add that the bare model couldn’t — fresh, outside information? ~5 min.
The language of language models# agent
tool call
Everyday sense first, then ours: an agent is a travel agent or a secret agent, someone who acts for you — here it’s a model that can act, not just talk. A tool call sounds like reaching for a hammer — here the model asks for something outside itself and waits for the answer. If anyone asks what runs the loop: you did. The harness is the scaffolding around the model that pauses it, hands off to the tool, and writes the result back — here, that was the students and the tool operator between them.
Poetry slam# Section beat: the open-ended capstone — design a model, swap, build, perform. The big block of time; keep it moving and the energy up.
The challenge# design a poetry language model from scratch
write your algorithm (recipe, or procedure) down on paper; another group will build it and
perform the result
your model card plus their performance is the completion task
They design a poetry model on paper; another group builds and performs it. No single right answer — that’s the point.
Design your model (20 min)# in pairs
what isn’t poetry?
what does your model do, and why?
write up your model on a blank lesson card to give to another group
Hands off — this one’s theirs. Nudge “what isn’t poetry?” if a group stalls. 20 min, circulate.
Pre-slam prep (10 min)# swap lesson cards with another group
you have 10 minutes to generate as much text as you can from their model,
then plan a one-minute performance
The slam# Each group performs for ~1 min. Keep it snappy, clap everyone. ~15 min for the room.
Discussion# hardest part of designing your model?
hardest part of preparing the performance?
how does this relate to Claude/ChatGPT/Gemini—similarities? differences?
what does it all mean?
The language of language models# temperature
prompt engineering
Everyday sense first, then ours: temperature is how hot something is — here it’s how random the next-word choice is, nothing to do with heat. Engineering is bridges and machines — prompt engineering is just wording the input to get what you want, and “prompt” itself is the nudge you give an actor, not a synonym for quick.
