Your cousin Dev's group chat has a new word in it, and it's everywhere: bardiwac.

"Grabbing a bardiwac before practice." "Who drank my last bardiwac??" "Never again. Two bardiwacs and I didn't sleep."

You could ask what it means. But asking means admitting you don't know, and Dev will never let that go. So you do what detectives do. You read the clues.

Your job: work out what a bardiwac is without anyone defining it. You'll get five messages, one at a time. After each one, lock in your best guess. You're allowed to change your mind.

Look back at your guess trail. After one message you probably had a vague idea. By the fifth, you were sure. Nothing about the word itself changed. Only the words around it did.

"You shall know a word by the company it keeps."Linguist J. R. Firth, 1957

That one sentence is the starting idea behind every language model. A model never gets a dictionary. It reads billions of sentences and learns each word from its neighbors, exactly like you just did.

Dev finds out you cracked it and challenges you back. You get to invent a word: glimber. Your secret meaning is skateboard.

You drafted six messages. Some give the meaning away through context. Some say nothing at all. Sort them, so you only send the clues that do real work.

The useless clues all had something in common: you could swap in any noun and they'd still make sense. The good ones only fit one kind of thing. That's what context is: the words around a word that narrow down what it can mean.

A model does this with numbers instead of instincts. Words that keep the same company end up with similar numbers. That list of numbers is called an embedding, and you'll draw a map of them in The Meaning Map.

It's late. You're texting your friend Sam about tomorrow, and the forecast looks bad. You type "I grabbed my umbrella because it looked like it might" and three words pop up above your keyboard.

That little bar is a language model, a tiny one. It doesn't know what you're going to say. It looked at everything you typed so far and made a ranked list of what usually comes next.

The chatbots you've heard of do the exact same thing, just with a much bigger model and a much longer list. Writing an essay is just this, over and over, one word at a time.

You're going to be the model: finish the text one word at a time, then find out what the temperature dial does.

Sam replies: "lol my phone said the same thing." Of course it did. Ask a model the same question twice at low temperature and you get the same answer twice.

Run the first blank ten times at low temperature, then ten times at high. Compare what comes out.

Sam bets you can't think like the autocomplete. Prove them wrong. For each text, pick the word you think the model ranks first. Your first try is the one that counts for your score.

Some apps let you pick the temperature yourself. Low is careful and repeatable. High is surprising, and more likely to go wrong.

For each job, pick the setting you'd want.

Long before chatbots, an engineer named Claude Shannon asked a strange question: how predictable is English?

To find out, he built fake English by hand. He picked a word, then found that word in a book and wrote down whatever came right after it. Then he did it again with the new word. The sentences he got were weird, but they sounded oddly like English.

That trick has a name: an n-gram model. It doesn't understand anything. It just counts which word follows which in the text it was given, its training text.

You're going to rebuild Shannon's machine. Your training text is ten sentences from an English class.

A counter only knows what's in its training text. So read it like one. Count carefully.

Build a sentence one count at a time. Pick a first word, then pick from whatever followed it in the training text. Keep going until you end the sentence.

A substitute shows up and introduces herself as the class's new instructor. Any student knows that's basically a teacher. Let's see if the machine does.

Counting works. Your sentence was built from real numbers, and early autocomplete ran on exactly this. Feed it more text during pre-training and the guesses get better.

But a counter treats every word as a stranger to every other word. "Teacher" and "instructor" share nothing. To fix that, a model needs to know which words are alike. That's the next activity.

The counting machine had a blind spot: it couldn't tell that "teacher" and "instructor" are close in meaning. Researchers fixed that with a simple idea. Give every word a location.

Words that show up in the same kinds of sentences get placed near each other. Do that for every word and you get a map of meaning. Those coordinates are called an embedding.

Real maps have hundreds of directions, not two. But the idea works the same on a flat page.

Explore the map, then put an old friend on it: the bardiwac.

A model uses distance on the map to decide what's related. Try it yourself: in each group, one word lives far away from the others.

When you ask a chatbot about your "instructor," it knows you probably mean a teacher, because the two live in the same neighborhood. That's the upgrade over counting.

Where does the map come from? Nobody draws it. The model adjusts millions of numbers, its parameters, until words that keep the same company end up close. The bardiwac landed with the drinks for the same reason you guessed it in the first activity.

You just became editor of the school paper. It's the night before the issue goes to print, and three writers sent in drafts they wrote with an AI's help.

Every sentence sounds confident. That's the problem. An AI can be fluent and wrong at the same time, and nothing in the writing warns you.

Read each draft line by line. Tap a sentence and mark it with one of four marks. When every line is marked, check your edit.

Priya is reviewing Frankenstein for the books column.

Marcus asked the AI for feedback on his opinion piece before sending it in. He pasted its answer into his notes.

Lena is writing fiction for the creative page and asked the AI to start her cast.

The issue is safe. Now help your writers so it doesn't happen again.

Jordan is building a science fair app that names birds from photos. Training a model from scratch would take huge amounts of data and computing power. So Jordan does what developers do every day: downloads one that's already trained.

The place to get it is Hugging Face, a huge public website where people and companies share AI models, the way people share videos on YouTube. Anyone can upload. Anyone can download. Millions of downloads happen every day, and almost all of them are fine.

Almost.

Jordan is made up for this story. The attack in it is real. Security researchers found it on Hugging Face in 2024, and attackers tried new versions of it in 2025.

A model file is mostly its parameters: millions of numbers. But numbers have to be packed into a file somehow. A popular older packing method, called pickle, doesn't just store the numbers. It stores a list of steps for rebuilding the model, and when you load the file, your computer follows every step. It doesn't stop to ask whether a step makes sense.

Jordan downloaded a bird model packed with pickle. Be Jordan's computer: load it one step at a time.

Jordan deletes the bad file and goes back to Hugging Face, more careful this time. Five search results look useful.

For each one, decide: load it, or skip it?

Jordan's app works, and the computer is clean. Here's the checklist Jordan taped next to the monitor:

The bigger lesson: a model is supposed to be just parameters. But a file is whatever its maker put in it. The more people build with downloaded AI, the more this kind of check matters.