What AI actually is

What you'll walk away with: a working model of what this machine actually is — who makes it, where it came from, what happens when you press send, and the beginnings of the feel for when you've asked it to carry more than it can.

You need: about 40 minutes of reading and demos — the real-thread exercise in Step 4 adds its own time when you do it properly — and one messy email thread you're allowed to paste into a chat tool; Step 4 explains what counts. No account needed until Step 4; everything before that runs in your browser. Nothing to install, no code.

Where you're standing

Here is the situation, plainly. In late 2022 a website appeared with a text box. You type ordinary English into it — a question, a half-formed idea, a pile of notes — and a written answer types itself back, usually a good one, in seconds. Within two months, by the estimates that made the headlines, a hundred million people were using it. The reason your clients, your colleagues, and your industry's conference circuit have not stopped talking about it since is that so much professional work is made of exactly this — drafts, summaries, restructured notes, first-pass analyses — and a written answer in seconds, good or not, lands in the middle of all of it.

You have heard names: ChatGPT, Claude, Gemini, Copilot. You have probably also heard that it makes things up, that one firm banned it and another now requires it. All of that is true at once, and none of it tells you what the thing is.

That is this lesson's job. Before anything else, write one sentence — on paper, in a note: what do you think happens in the moment you press send? If you have never used one of these tools, write what you imagine. Keep the sentence; you will check it against the machine before the end.

And here is the machine in one move, because you have met a tiny version of it already. The suggestions that hover above your phone's keyboard are a small pattern machine with one job: read the last few words you typed, propose the next little chunk. This is that, given whole documents instead of a few words — a scale that changes what the move can do. It reads in a bunch — a whole email thread, a whole contract, an afternoon of notes — and it writes out a bunch, making the same move again and again, each chunk chosen to follow everything before it, until a whole answer stands on the page. "Super-charged autocomplete" is the right first idea, not a joke at the machine's expense. Hold onto it; this lesson's job is to make it precise — including the parts it does not prepare you for.

By the end you will know what this machine is, where it came from, and why the brilliant draft and the confidently invented citation are the same behavior — not a good mode and a bad mode. One mechanism.

The game board

Three companies matter most for this site's purposes, and you already know their products' names even if nobody ever lined them up for you. OpenAI makes ChatGPT. Anthropic makes Claude. Google makes Gemini. There are others, but these are the front doors most professional work walks through. The labs here use the first two; Gemini is real and good, we simply don't cover it — everything you learn transfers.

Now the distinction that unlocks the rest of this lesson. Each of those products is two things under one name. There is the app — the website with the text box, the chat history, the folders, the settings. And inside the app there is a model — the machine that actually writes. The app is ordinary software, built by people, changed weekly. The model is the strange part, and it is the part this lesson is about.

One more fact, because the first dropdown you will meet is this one: each company makes a family of models — larger ones that reason more deeply and cost more to run, smaller ones that answer faster and cheaper, different ones tuned toward code, toward writing, toward images. That is why "which AI is best" has no standing answer — it depends on at what, and on when you ask. The names change too fast to print here; the decoder keeps the current ones, dated.

Hold onto the split. When something remembers your name across visits, that is the app. When something writes a paragraph, that is the model. The rest of this lesson is about the model — and the window through which the app feeds it everything it gets.

Where it came from

The model was not programmed the way software is programmed. Nobody coded its behavior rule by rule. It was trained, and the word means something specific that is worth a minute, because everything else follows from it.

Act one. A program was given a colossal share of human writing — books, articles, contracts, documentation, argument, code — and one job: read a passage, guess the next small chunk, check the guess, adjust, repeat. Trillions of times. Early on that gets you spelling; then grammar; then the learned fact that "the defendant was found" tends to continue with "guilty" or "not guilty" and almost never with "purple." And to keep getting better past that point, the machine is forced to absorb the deep structure of the writing it reads — how a contract clause is built, how an argument concedes and turns, how an analysis moves from figures to a finding. Competence is what next-chunk prediction extracts from competent text. That is the answer to the objection you should be forming right now: predicting words can do real work because the words it practiced on were the work product of people who could.

When training ends, everything it learned freezes — and what it learned is, concretely, odds: for any run of text, which chunk tends to come next. Those frozen odds are the instincts you will watch in a minute, and nothing you ever type changes them. The running model does not learn your business between Tuesday and Thursday, and pasting a memo into a chat does not teach it your client's affairs. Whether your text is kept to help train future models is a separate thing — an app setting, on by default in some products, and the next lab shows you where it lives.

That gives you a ledger worth keeping: everything this machine draws on reaches it in exactly two ways — what training baked into the frozen odds, and whatever sits in front of it when you press send. The first is fixed. The second is yours, and you will watch both below.

Act two, because the raw guesser is not what you meet. A machine trained only to continue the internet's writing will continue anything — a question with another question, a rant with a better rant. So the companies shaped it: people were hired to write thousands of ideal answers — helpful, structured, confident — and the model was trained again to continue in their voice. What answers you, mechanically, is a statistical simulation of those hired expert writers. That is why it reads like a capable colleague and never like a page of search results.

One consequence of act two runs through every lab on this site. The example answers those people wrote almost never said "I don't know." So the simulation learned that answers are confident and complete — and it will produce a confident, complete answer whether or not it has anything real to build one from. That is the first-order account, not the whole story — the shaping stack has more layers than hired writers, and each release rebalances how often not-knowing wins the draw — but the pressure is the durable part: answers complete the pattern of answering. You are about to watch exactly that happen, and in Step 4 you get the countermeasure.

Step 1 — Meet the pattern machine

Now, the sentence you wrote at the start. If it described some version of looking something up, you are in good company — and if you wrote "no idea," that is the honest answer most people would give. Looking-something-up is the most expensive wrong idea in this subject, and it is wrong in a specific way worth naming: the thing answers like a search engine, so we assume it works like one. It doesn't. You read what it actually does — it predicts the next chunk of text, then the next, then the next. No plan survives beyond what gets written — whatever look-ahead happens while writing dies with the answer. When a product shows you its "thinking," that is more text from the same move, and there is no small researcher behind the glass deciding what you deserve to know.

Here is the whole loop, drawn, so you can hold its shape while you watch it run:

THE LOOP — WHAT EVERY SEND ACTUALLY SENDSSCHEMATIC — THE SHAPE, NOT THE SIZES

THE WINDOW

• the app's instructions
• the app's memory file
• the chat so far
• your files
• your newest message

MODELfrozen odds — nothing you type changes them

NEXT CHUNKone small piece of the reply

⟲ each chunk is appended and the odds run again until the reply ends. On your next send, the pile rides again — as much of it as fits, the app trimming or condensing the rest — finished reply included; no model runs between sends.

Don't take the origin story on faith, though. What follows is an x-ray of one send — the name the rest of this site uses for it — and a simulation: hand-authored numbers, no model behind the glass, and the pattern machine says so in its own first line. The shape is the real thing; watch the shape.

Press SEND and follow it through — the assembly, then the tokens (the model's units of text, chunks roughly the size of a short word), then the reply. If the toy pauses between stages, the next stage's button moves you on. Read what is actually in that window on the way past: a block of instructions you never wrote, a date, a list of tools, a one-line memo, and your five tokens. You typed under 2% of what the model received.

Then press Watch the reply and hit Let it pick until the sentence finishes, then Run it again: the starting odds come back identical, because nothing was learned. That identical restart is the figure's bottom line: same pile in, same odds out. It is also why arguing with a chat that has gone sideways works so badly — your objection joins the pile, but everything that tilted the odds wrong is still in there, still tilting. You don't argue with this machine. You change the pile, and Steps 2 and 5 are both ways of doing it.

Then do the thing that matters. Step back to the start of the toy's stage rail, turn ATTACH THE MEMO off, and send it again. The request is unchanged — summarize this memo — but the memo is gone, and when you reach the reply, look at the odds before you touch anything. The window's contents changed, so the odds changed — and the first pick is now a choice of voice. In the lead sits "The," the opening of a memo-shaped summary about a document that does not exist. Below it, visible and losing: "I," the opening of I don't see a memo. Press Let it pick and watch the likelier voice win — a complete, confident summary, with no hint it is working from nothing. Then Run it again and pick "I" yourself: the honest reply was in the odds the whole time.

Both endings live in the odds; the shaping decides which one usually wins. You read where that habit comes from — the example answers it was shaped on almost never said "I don't know," so the confident summary completes the pattern better than the confession does. And now you can read your own experience with these products correctly: when one tells you it can't find your attachment, the honest branch won that draw. When one summarizes a document that isn't there, you have watched exactly how. Neither is a malfunction. Both are the mechanism.

Now change what it has to work with.

Flip the facts in and out of the window and watch the blank's odds move.

Two toys, one shape — and the shape is the whole lesson. Three parts of it:

• The instincts are frozen. You read where they came from; nothing you type changes them.
• A long-shot pick still reads beautifully. Fluency is what the machine is made of, not evidence of being right. It writes what fits, not what's true.
• What sits in front of it moves the odds. For a given model, that is the lever you hold, and it is enormous.

Now look at your sentence. If it described looking something up — or said "no idea" — replace it with the one the machine just demonstrated: everything in front of it is handed, all at once, to a frozen guessing machine, which writes a likely continuation. That sentence is the lesson; the rest is consequences.

Step 2 — Everything it knows about your problem is in the window

Between your messages, no model is running — nothing sits up overnight holding your project in mind. (When a product does work while you are away — a scheduled task, a long research run — that is the app opening fresh windows and saving the text.) Every time you hit send, the app repackages everything and hands the whole pile over again: its own hidden instructions on top, the conversation beneath them oldest-first, your newest message at the bottom, plus whatever you attached. That pile is the context window, and it is the complete list of everything the model will ever know about your problem.

Which reframes the most common complaint in AI. "It forgot what I told it" is almost never memory failing; it is the window ending — a new chat, or a thread long enough that the app quietly trimmed or condensed the middle to make room. The window is big — think a long report's worth of text, sometimes several — but it is finite, and everything you add competes for it. Nothing broke. You started a new window and expected the old one to still be standing.

TWO SOURCES — WHERE AN ANSWER CAN COME FROMSCHEMATIC — THE SHAPE, NOT THE SIZES

BAKED IN — AT TRAINING

• how contracts, memos, and code read
• the shape of a good answer
• frozen when training ended

IN THE WINDOW — RIGHT NOW

• what you pasted or typed
• the file you attached
• what the app pulled from your files
• what web search fetched in
• what the app’s memory pasted

THE ANSWERa likely continuation of both together

One row of that figure deserves its own sentence, because it looks like a third door and isn't. When an answer arrives carrying this morning's prices or last night's news, the model did not go anywhere. It asked for a search — one of the tools you saw listed in the x-ray's TOOLS block — and the app ran it, took the text that came back, and pasted it into the window; the model then continued from a window that happened to contain fresh search results. Baked in at training, or sitting in the window at send time: search is the second door. The model asks, the app fetches, the window receives.

Now the honest complication, because you will meet it within a day: both products include one — Memory (both) — and it looks like a counter-example. It isn't. The model still remembers nothing between sends. The app keeps notes about you and loads them into the window on your behalf — a saved file of facts, and in some products a reach back into your older chats for whatever looks relevant. Which is exactly why you can open memory in settings, read it, and delete what you don't want carried. That is the ledger confirming itself, not breaking: everything it knows about your problem is in the window, including what the app put there on your behalf.

Which hands you the honest fine print on that sentence: the app builds the window, and it edits it. You decide what is eligible — what you paste, attach, or leave standing in the thread. The app decides what actually makes the cut each send. Small piles ride whole. Big ones arrive worked over — a long thread gets its middle trimmed or condensed, a fat attachment gets read through an extractor — and the app does not show you its cuts. So add one diagnosis to the kit: when something you supplied gets ignored, it may never have made the window at all. The fix is the lever you already hold — put the load-bearing part in the message itself, where you watch it go in.

One more consequence, and it is the one professionals miss: the machine keeps no notes. Whatever it weighed while writing an answer — the options you watched it hold and drop in Step 1, the paths not taken — is gone the instant the answer ends. Only what it actually wrote survives to ride back in on the next send. So when the reasoning matters, make it say the reasoning out loud. "Walk me through it before you answer" isn't politeness; it is how that reasoning becomes text in the window, where you and it can both use it next turn. One boundary keeps this discipline honest: what it writes down is a rendition of the work — more text from the same move, not a window into the machinery. So don't ask for a soliloquy; ask for the checkable parts: which sources it used, what it assumed, what it calculated. A written assumption can be challenged. A hidden one can't.

So: a fresh chat is an empty window — and Step 5 turns that fact into the cheapest tool on this site.

Step 3 — What a file carries, and what you control

You now know the window is rebuilt on every send — whatever you load rides in it again and again. So the next question is what a file actually hands over when you attach one. Everything above was a simulation. This one is a real measurement, run live in your browser: open loading the window in a new tab and run the autopsy — then come back; this step continues here.

It is the same memo you just put in the window upstairs — Q1 revenue grew 14% on paving volume. — weighed instead of read. One 37-character sentence, saved two ways. Saved as Markdown — a plain-text format, nothing but the characters — it is 37 bytes, and every byte is the sentence. As a Word file it is 36,607 bytes that unzip into a pile of XML — styles, themes, namespaces — with the sentence about a tenth of a percent of it.

Be precise about what that ratio measures, because it is not a window measurement. When you attach a file, the app does not shovel those 36,607 bytes at the model; it runs an extractor first and sends along what the extractor keeps. The ratio measures how much of the file is not your sentence — and everything that isn't the sentence is something you are trusting an extractor to handle for you, sight unseen, with fidelity that varies by product and by file.

A Word file also carries more than formatting. Open docProps/core.xml in the file tree and you are reading the document's property fields: creator, last-modified-by, revision count, timestamps. In the bundled sample some are filled in and some are empty. To find out what yours say, drop one of your own files into the same panel — it never leaves your browser, and the fields it shows you are the fields that would have travelled with that file. The extractor is usually after your text, not your file's properties — but the whole file left your machine, and what a provider's tooling can read from it is no longer yours to limit.

So the working rule: paste when you want control, attach when you need the file. Pasting is the only way to see exactly what you hand it — nothing added, nothing dropped, no extractor deciding for you, no property fields riding along. Attaching hands the app an extraction decision, which is sometimes the right trade — structure, length, a format worth keeping — and when you take it, check what came through: ask for the two sentences that matter, quoted, before you build on the summary.

Step 4 — Prove it to yourself

This step needs a real account — the first one that does. If you don't have one yet, read it now, do the next lab (it sets up both products), and come back; the lesson holds. And the confidentiality answer you are owed before you paste anything anywhere: what you paste is sent to the company's computers and, in some products by default, may be kept for training future models — the running model learns nothing either way, and the next lab shows you the setting that turns that off. For today, pick a thread you could forward outside the firm.

Find a genuinely messy thread — fifteen emails of a decision being made badly, nothing confidential in it. Getting it out is unglamorous: use your mail client's print or forward view, select all, copy — formatting mess is fine, the machine reads through it. Open a fresh chat and paste it in as text.

Below is an email thread, pasted in full. Pull out its operating system: (1) every DECISION actually made, quoting the line that made it; (2) the OWNER of each one — only where a person visibly took it or was handed it, otherwise write UNASSIGNED; (3) the DEADLINE for each — where no date was said, write "no date," never a guess; (4) what is still OPEN.

Three instructions in there are doing the work, and they are the house signature — you will meet them again in half the labs.

Quoting the line that made it is the checkable one. A quote you can find in the thread in four seconds; a summary you cannot check at all.

UNASSIGNED and "no date" are the other two, and they matter for the reason Step 1 gave you. Without them, a pattern machine asked for owners and deadlines will fluently supply owners and deadlines. It isn't lying to you; it is completing a pattern, and "Priya, by the 14th" completes that pattern better than a blank does. Giving absence its own word is how you let the machine tell you it doesn't know. (You read why in the origin story: its training examples almost never said "I don't know," so you have to make not-knowing a completable pattern.) Later labs use UNKNOWN for the same job — same discipline, different noun.

Last, put the good one somewhere it will live — a doc, a page, a file with a name. The chat that produced it is a script of how you got there, not a place to keep it. In a week that chat is a wall of text you have to re-read; the document is a thing you can use.

Step 5 — A second window is a second opinion

You now have everything you need for the most useful move on this site, and it costs nothing.

A window that just built something is a poor judge of it. Its contents — your instructions, its own draft, every reason it already committed to — sit there tilting the odds toward yes, that's good. Ask it to find the flaws in its own work and you often get a polite note from a window with a stake in the answer — real flaws surface softer and rarer there. Nothing is being dishonest. You asked for the likely continuation of a window that already contains the thing being judged.

So don't. Open a new chat, paste in only the work — not the conversation that made it, not what you were hoping for — and ask what is wrong with it. A fresh window has no stake, and it drifts toward a different average because you loaded it differently. It is not a different mind, though — same model, same instincts, same blind spots. Treat what it raises as leads you resolve against the source, not as a second vote that settles the question.

Do it now, with what you just made. Open a fresh chat — nothing pasted but the work — and give it your Step 4 extraction with: "Here is a decision log pulled from an email thread. What is wrong with it? What would a careful reader challenge — which owners look guessed, which deadlines look invented, what is missing?" Then, separately, run the lazy version in a third fresh chat — paste the original thread with only "Summarize this and tell me who owns what." Compare the three artifacts. The same machine produced them all. The differences are the window — and you have now performed the move half the labs on this site are built on, on your own material.

This is the shape behind half the labs here: build in one window, judge in another. When a later lab asks you to open a fresh chat as a skeptical CFO, or a buyer reading your proposal cold, this is the move it is making — and now you know why it works.

---

The jagged edge, and your next ten hours

What this machine is good at does not follow a smooth line: two tasks that look adjacent to you can sit on opposite sides of an invisible boundary, because the boundary follows the shape of its training, not the shape of your job ladder. You cannot deduce that edge from here — you map it by use, and you start inside your own expertise, where you can judge output cold. But the failures on its far side have shapes you can learn in advance, and the third Lab 00 lesson, Where it breaks, teaches you to recognize each one from the mechanism you just watched.

And know a failure mode the research keeps finding in professionals: not early distrust, but overtrust after a run of good answers — the moment the checking stops. The two disciplines from this lesson — make the work inspectable, judge it from a second window — are what checking looks like when it's cheap.

Three words you will hear at dinner, mapped to what you now own: a prompt is everything you load into the window on purpose. A hallucination is fluent completion with nothing under it — nothing in the window, or nothing the continuation actually used from it. You watched one summarize a memo that wasn't there, and the confident summary was the odds-on favorite, not a fluke. An LLM — large language model — is this machine's technical name, and "model" on its own is what everyone calls the engine inside the app.

Intuition does not arrive from reading; roughly ten working hours of use on your own material is our working rule. The labs on this site are those hours, arranged.

Check your understanding: if nothing runs between your messages, what is actually happening when a chat seems to remember last week — and why does telling it to write UNASSIGNED change what comes back?

Check yourself first — then open one good answer+−

Nothing runs between your messages — so a chat that "remembers last week" is the app loading the window well: the conversation rides in again on every send, and memory is notes the app keeps and loads on your behalf. The model recomputes everything from that pile, every time.

And UNASSIGNED changes what comes back because it gives absence a shape the odds can complete. Asked for owners, a pattern machine fluently supplies owners — "Priya, by the 14th" completes the pattern better than a blank does. With the instruction in the window, not knowing becomes a continuation that can win the draw.

Your answer should have hit three things: the window rebuilt each send, memory as app furniture rather than model learning, and absence given a completable word.

Use this understanding in every Lab. Every other lab here is this one with more furniture: load the window on purpose, check what fluency handed you, judge it from a second window, and put the result somewhere it will live. Next up — Meet both workspaces: the two front doors, opened and read.