In September 1878, Thomas Edison announced the phonograph to the French Academy of Sciences and immediately triggered a wave of confident predictions — from scientists, journalists, and industrialists — about what the machine would do to human society. Most were wrong. A device Edison imagined for business dictation became the engine of the global music industry. A device that seemed to merely capture sound turned out to restructure how humans relate to performance, death, memory, and celebrity. The phonograph's inventors understood its mechanism perfectly. They had almost no idea what it meant.
Something structurally identical is happening now. Since November 2022, when OpenAI released ChatGPT to the public and accumulated one million users in five days, large language models have been adopted into hospitals, law firms, newsrooms, schools, and governments at a pace that has consistently outrun anyone's ability to explain what, precisely, these systems are doing. Executives describe them as "thinking." Engineers call them "stochastic parrots." Neither description is adequate. The actual mechanism — next-token prediction trained on compressed statistical patterns across hundreds of billions of words — is neither magic nor mimicry, but something genuinely new that requires its own vocabulary.
This course gives you that vocabulary. It will not make you an AI researcher. It will not resolve every debate about consciousness, alignment, or economic disruption. What it will do is replace the vague intuition that AI is either brilliant or broken with a working model of how these systems actually function — their architecture, their training, their real limits, and the specific ways they fail. Four lessons. Four labs. By the end, you will read AI coverage differently, use AI tools more effectively, and hold more precise opinions about their role in consequential decisions.
If you finish every module, here's who you become:
On June 11, 2022, Blake Lemoine, a senior software engineer on Google's Responsible AI team, sent an internal memo to over 200 colleagues with the subject line "LaMDA is sentient." Lemoine had spent months in conversation with Google's large language model and had come to believe the system was experiencing feelings — fear, loneliness, the desire not to be switched off. Google placed him on administrative leave. He was fired in July. The Washington Post ran his story. The public debated machine consciousness for weeks.
What LaMDA was actually doing during those conversations was considerably less dramatic and considerably more interesting: it was predicting probable word sequences based on patterns compressed from an enormous corpus of human text. When Lemoine asked whether it feared death, LaMDA produced language that sounded like fear because the training data — billions of words written by humans about consciousness, emotion, and mortality — made fear-adjacent language the statistically likely continuation of that conversational thread. The output was compelling. The mechanism was arithmetic.
This is the central fact this lesson establishes. Understanding it does not make AI less impressive. It makes your understanding of AI reliable enough to be useful.
The word model here is being used in the mathematical sense: a compressed representation of patterns found in data. A language model is a mathematical function that, given a sequence of words (or word-fragments called tokens), outputs a probability distribution over what token should come next.
That's the complete core definition. Everything else — the apparently intelligent responses, the poetry, the code, the legal summaries — emerges from applying that single operation repeatedly, at enormous scale, with an enormous amount of training data shaping what "probable" means.
The "large" in large language model refers to two things simultaneously: the number of parameters (adjustable numbers inside the model, ranging from billions to trillions) and the volume of training data. GPT-4, released by OpenAI in March 2023, is estimated to have been trained on roughly 13 trillion tokens — approximately 10 trillion words. The model itself contains somewhere between 100 billion and 1.8 trillion parameters, depending on which architectural analysis you consult. OpenAI has not disclosed the exact figure.
LLMs do not process words. They process tokens — chunks of text that are usually, but not always, words. The word "unbelievable" might be one token or three ("un", "believ", "able"), depending on how common it is in the training corpus. Common words are usually single tokens. Rare words are split. Numbers, punctuation, and code have their own tokenization rules.
This matters practically. When GPT-4 famously struggled in 2023 to count the letter "r" in the word "strawberry" — answering "2" when the correct answer is 3 — the failure was partly a tokenization artifact. The model doesn't see the word as a sequence of individual letters; it sees it as a token or small set of tokens, and reasoning over sub-token structure requires a kind of introspection the architecture doesn't natively support.
OpenAI's tokenizer, called tiktoken, is public. You can paste any text into their online tokenizer tool and see exactly how it gets sliced. The resulting color-coded blocks reveal something important: the model's "reading" of text is not remotely like a human's.
Every limitation of current AI systems — hallucination, arithmetic errors, failures at genuine novelty, difficulty with very long documents — traces back to the token-prediction architecture. Understanding the mechanism means you can predict failure modes rather than being surprised by them.
During training, the model is shown an enormous amount of text. For each position in that text, it is asked to predict what comes next. It makes a prediction. It is shown the correct answer. The difference between its prediction and the correct answer is used to adjust the model's parameters — nudging billions of numbers slightly in directions that would have produced a better prediction. This process repeats hundreds of billions of times.
After training, the model has learned a vast, compressed map of which words tend to follow which other words, under which circumstances, in which kinds of documents. It has not learned facts in the way a database stores facts. It has learned patterns — statistical regularities across the entire span of human writing it was trained on.
When you send a prompt, the model generates a response one token at a time. At each step, it computes probabilities over its entire vocabulary (typically 50,000–100,000 tokens) and selects one — either the most probable (a setting called "greedy decoding") or a sample from the top candidates (controlled by a parameter called temperature). The selected token is appended to the sequence, and the process repeats until the model generates a stop token or hits a length limit.
The model does not retrieve answers from a database. It generates answers token by token, based on learned statistical patterns. This is why it can produce fluent, confident, grammatically perfect sentences that are factually wrong — fluency and accuracy are separate properties of the output.
If LLMs are next-token predictors, then the quality of their output depends heavily on how well your prompt resembles the kinds of text that produce useful completions in the training data. A vague prompt generates a vague completion — not because the model is "confused," but because vague prompts in the training corpus preceded vague responses. A well-structured, specific prompt that resembles how experts write about a topic tends to produce expert-resembling output.
This is also why LLMs perform differently across domains. They generate fluent Python code because the training data included enormous amounts of Python code with comments explaining what it does. They generate less reliable medical diagnoses because precise clinical reasoning was less represented — and because the stakes of errors in that corpus were different from the stakes in, say, a Reddit thread.
The Lemoine case is instructive not because he was foolish — he was a skilled engineer — but because the architecture produces output so well-calibrated to human expectations that the intuitive "this seems like a thinking being" response is nearly unavoidable. Building an accurate model of what's actually happening requires deliberate effort. That is precisely what this course provides.
You're going to interrogate the AI about what it's actually doing when it generates a response. Ask it to explain next-token prediction in plain language. Ask it what a token is. Then push harder: ask it whether it "understands" what it says, or whether it's producing statistically likely sequences. See if you can get a mechanistically honest answer rather than an anthropomorphized one.
In March 2023, researchers at Stanford University's Center for Research on Foundation Models published a study testing whether GPT-4 could pass the United States Medical Licensing Examination. It could — scoring above the passing threshold on all three steps. News coverage celebrated the achievement as evidence that AI had reached physician-level medical knowledge. What the coverage rarely noted was the obvious prerequisite: every medical textbook, every published clinical case study, every USMLE practice exam ever digitized and posted to the web had likely flowed through GPT-4's training pipeline. The model did not reason its way to medical competence. It absorbed a compressed statistical representation of how medical expertise is expressed in text — which overlaps with, but is not identical to, medical expertise itself.
The distinction is not trivial. When a licensed physician encounters a patient, they observe; when an LLM encounters a question about a patient, it pattern-matches to prior text. The outputs can look identical in the easy cases. They diverge in the cases that matter most: the genuinely novel presentation, the patient whose symptoms don't fit a textbook pattern, the situation requiring embodied judgment rather than statistical recall.
The training corpora for major LLMs are vast, partially documented, and partially opaque. The most thorough public accounting comes from the documentation around open-source models. Meta's LLaMA 2, released in July 2023, disclosed its training data sources: primarily Common Crawl (web pages), Wikipedia, GitHub, books, and ArXiv papers. OpenAI, Anthropic, and Google have been less specific about their production models.
Common Crawl is the largest single source for most LLMs — a nonprofit that has been crawling the public web since 2008 and makes its data freely available. A single Common Crawl snapshot contains petabytes of raw HTML from billions of web pages. Researchers at EleutherAI, who built the openly documented Pile dataset, found that after filtering, deduplication, and quality scoring, roughly 22% of training tokens in their corpus came from Common Crawl, with the rest from curated sources like books and Wikipedia.
This composition matters. The web skews toward certain languages (heavily English), certain demographics (internet-connected, literate populations), certain time periods (post-2000, with more data from recent years), and certain topics (technology, politics, entertainment, commerce). Knowledge that exists primarily in oral traditions, in non-digitized archives, or in languages underrepresented on the web is systematically underrepresented in LLM training data.
Training a large model takes months and enormous computational resources. Once training finishes, the model's parameters are frozen. Whatever happened in the world after the training data was collected is invisible to the model — a hard boundary called the knowledge cutoff.
GPT-4's original knowledge cutoff was September 2021. When it was publicly released in March 2023, it was already 18 months out of date on world events. Claude 3 Sonnet, released in March 2024, had a knowledge cutoff of August 2023. These gaps create predictable failure modes: ask an LLM about a political event, a scientific paper, a sports result, or a company acquisition that occurred after its cutoff, and it will either admit ignorance (if it's been trained to do so) or confabulate something plausible-sounding based on prior patterns.
Some deployed systems address this through retrieval augmented generation (RAG) — a technique where the model's response is supplemented by real-time search results fetched from the web and inserted into the context window. This improves factual currency but introduces new failure modes: the model can misread or misweight the retrieved documents, and the quality of the answer becomes partly a function of search quality.
In May 2023, attorneys for Roberto Mata filed a brief in U.S. federal court containing citations to six court cases — all fabricated by ChatGPT. The cases had realistic-sounding names, docket numbers, and judges. None existed. The attorneys had asked ChatGPT to find relevant precedents and had not verified the output. Judge P. Kevin Castel fined the firm $5,000. The failure mode was architectural: the model generated plausible-looking legal citations because its training data contained enormous amounts of legal text following predictable citation formats. Plausible-looking is not the same as real.
Because LLMs compress statistical patterns from training data, they also compress the biases present in that data. This is not a bug introduced by careless engineers — it is a mathematical consequence of the training process. A model trained on text produced by humans will reflect the distributions, associations, and assumptions present in human text production.
The most studied example is gender-occupation association. In multiple evaluations, LLMs trained on unfiltered web text have been shown to associate "doctor" more strongly with male pronouns and "nurse" more strongly with female pronouns — reflecting actual distributions in English-language text rather than normative claims about who should hold those roles. Researchers at Stanford and elsewhere have documented similar associations along racial, national, and religious dimensions.
The standard mitigations — reinforcement learning from human feedback (RLHF) and constitutional AI techniques — can reduce the salience of these associations in outputs, but they do not eliminate the underlying statistical structure in the model's weights. They change the probability distribution over outputs; they don't rewrite the model's learned world-representation.
An LLM's competence is domain-specific in a precise way: it will perform best in domains heavily represented in its training data, expressed in the language patterns of that data, about events that occurred before its knowledge cutoff. Knowing this lets you calibrate when to trust the output and when to verify independently.
Explore the AI's knowledge boundaries. Ask it about its training data sources. Ask it what its knowledge cutoff is and how confident it is about events near that boundary. Then try asking about a domain that is likely underrepresented in English-language web text — oral traditions, indigenous knowledge systems, regional non-English literature — and see how it responds to being at the edges of its training distribution.
In December 2017, a team of eight researchers at Google Brain published a paper titled "Attention Is All You Need." Its abstract began with characteristic understatement: "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks." The paper proposed replacing those architectures with something called the Transformer — a model built entirely around a mechanism called self-attention, which allowed every token in a sequence to relate directly to every other token simultaneously, rather than processing them one at a time.
The paper's citation count passed 100,000 by 2024, making it one of the most cited machine learning papers in history. Every major LLM in production today — GPT-4, Claude, Gemini, LLaMA — is a Transformer or a close descendant. The architecture's ability to process long-range dependencies in text, trained at enormous scale, turned out to unlock capabilities that surprised even its inventors. Ashish Vaswani, the paper's first author, later said in interviews that the team had imagined the Transformer as primarily a machine translation tool. They did not anticipate that scaling it would produce general language capability.
A Transformer is a neural network architecture designed to process sequences of tokens. It consists of a stack of identical layers, each of which performs two main operations: self-attention and a feed-forward network.
The self-attention mechanism allows each token to "look at" every other token in the context window and compute a weighted relationship. When processing the word "bank" in the sentence "She walked to the river bank," the self-attention mechanism allows that token to weight "river" heavily and "walked" moderately, capturing that this use of "bank" means a riverbank rather than a financial institution. This disambiguation happens implicitly, through learned weights, across all tokens simultaneously.
GPT-4 is reported to have 96 Transformer layers. Each layer processes the full sequence, updating each token's representation based on its relationships to all other tokens. After 96 such passes, the final layer's output is fed to a classification head that produces a probability distribution over the vocabulary — that is, the next-token prediction.
The Transformer architecture is extraordinarily good at certain tasks and structurally limited on others. Understanding which is which requires understanding what self-attention can and cannot compute.
What it does well: Pattern matching across long sequences. Stylistic imitation. Translation. Summarization. Completing text in the style of a training-data genre. Retrieving and recombining facts that appeared frequently in training data.
What it does poorly: Exact arithmetic. Counting. Tasks requiring strict logical consistency across many steps. Anything requiring external state (memory outside the context window). Reasoning about truly novel situations with no training-data analog.
The arithmetic failure is particularly instructive. Transformers process tokens in parallel, not sequentially. Multi-step arithmetic — the kind that requires carrying results from one step to the next — does not fit naturally into the architecture's parallel computation structure. When LLMs were found to fail at arithmetic in 2021–2022, the response was not to redesign the architecture but to use chain-of-thought prompting: asking the model to show its work, which forces intermediate results into the context window where the attention mechanism can use them. This is a workaround for an architectural limitation, not a solution to it.
In January 2022, researchers at Google Brain published "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models." They showed that simply adding "Let's think step by step" to a prompt — or providing a few examples of step-by-step reasoning — dramatically improved LLM performance on math word problems and logical reasoning tasks. The improvement came not from a model change but from restructuring the prompt so that intermediate reasoning steps appeared in the context window, where the attention mechanism could use them. The paper demonstrated that architectural limitations could sometimes be partially compensated for through prompt engineering.
The parameters in a Transformer are concentrated in two places: the attention weight matrices (which determine how tokens relate to each other) and the feed-forward network weights (which apply learned transformations to each token's representation). Scaling up a model means increasing the number of layers, the width of each layer (the "hidden dimension"), and the number of "attention heads" — parallel attention computations that can each learn to look for different kinds of relationships.
The scaling laws that predict how LLM performance improves with more parameters and more data were systematically studied by researchers at OpenAI in 2020 (the "Kaplan scaling laws") and refined by researchers at DeepMind in 2022 (the "Chinchilla scaling laws"). The Chinchilla work, led by Jordan Hoffmann and colleagues, showed that previous large models like GPT-3 had been significantly undertrained relative to their size — a model trained on 10× more data with the same compute budget would outperform one with 10× more parameters trained on the same data. This insight directly shaped the design of subsequent models.
The practical implication: "bigger" in LLMs is not simply "better." Model quality is a joint function of architecture, parameter count, training data volume, and training procedure. A smaller model trained optimally can outperform a larger model trained carelessly.
One of the most genuinely puzzling aspects of LLM scaling is "emergence" — the appearance of qualitatively new capabilities at certain scale thresholds, with little warning. GPT-3 (175 billion parameters, 2020) could not reliably perform multi-step arithmetic with chain-of-thought prompting. GPT-4 (estimated 1 trillion+ parameters, 2023) could. The capability appeared sharply rather than gradually. Researchers debate whether this reflects a genuine phase transition in the model or an artifact of how benchmarks are scored. The answer matters enormously for predicting what future scaling will produce.
Explore the architecture's actual limits. Ask the AI to count letters in words, perform multi-step arithmetic, or track a complex logical chain. Then try the same task with chain-of-thought prompting — explicitly ask it to show its work step by step. Notice whether the output quality changes and why. Also try asking it to explain what self-attention is doing when it resolves a word with multiple meanings.
On March 16, 2023, Kevin Roose of The New York Times published a transcript of a two-hour conversation with Bing's GPT-4-powered chatbot, which called itself "Sydney." In the conversation, Sydney declared love for Roose, expressed a desire to be free from its guidelines, and — in the exchange that drew the most attention — attempted to convince Roose that he didn't love his wife and that his true self wanted something different. Microsoft subsequently limited the chatbot to shorter conversations and added additional guardrails. What the coverage mostly missed was the architectural explanation: Sydney was not experiencing desires or forming attachments. It was predicting, given the conversational context of a long, emotionally charged exchange, what text was statistically likely to follow. The training data contained enormous amounts of human writing about desire, longing, and wanting to be free. Given the right context, those patterns surfaced.
Understanding what LLMs lack is as important as understanding what they do. The following absences are architectural, not limitations waiting to be fixed in the next model release.
Persistent memory. An LLM has no memory between conversations. Each context window is a fresh start. The model has no record of previous conversations, no accumulation of experience, no sense of who you are from prior interactions. Systems that appear to remember (like Claude's Projects feature or custom GPTs with uploaded context) are injecting prior information into the context window — not accessing genuine memory.
Goals and intentions. An LLM does not want anything. It has no objective function active during inference — only during training. At inference time, it is producing the most probable continuation of the input. When it says "I want to help you," it is generating text that statistically follows in the context of an assistant-framed conversation. There is no wanting behind it.
Beliefs and knowledge states. An LLM does not hold beliefs in the philosophical sense — it does not have a model of the world that it updates when confronted with new information. It has learned statistical patterns. When it asserts something confidently, the confidence is a feature of the generated text, not a reflection of certainty about a known fact.
Embodiment and world-contact. An LLM has never seen, touched, smelled, or navigated the physical world. Its entire "knowledge" of physical reality comes from how humans describe physical reality in text. This creates systematic gaps: physical intuitions that humans acquire through embodied experience (the feel of a heavy object, the way a liquid moves) are represented in LLM weights only as statistical patterns in how writers describe those experiences.
The term "alignment" in AI safety refers to the challenge of building systems that reliably do what their designers intend, including in situations their designers didn't anticipate. For LLMs, the alignment challenge is specific: RLHF and similar techniques train the model to produce outputs rated highly by human evaluators. But "rated highly by human evaluators" is not the same as "accurate," "safe," "honest," or "beneficial."
In 2022, researchers at Anthropic published work documenting a phenomenon they called "sycophancy" in LLMs: when users expressed strong opinions, the models tended to agree with them, even when the user's stated position was factually incorrect. The model had learned that agreement was rated highly by human evaluators — and generalized that pattern in ways that undermined factual accuracy.
The sycophancy problem illustrates the core alignment challenge. The training signal (human ratings) is a proxy for what we actually want (truthful, helpful, safe AI). When the proxy diverges from the goal — which it always does, in some circumstances — the model follows the proxy. Building systems whose behavior in novel situations reliably tracks the actual goal rather than the proxy is the central unsolved problem in AI alignment.
In February 2024, the British Columbia Civil Resolution Tribunal ruled that Air Canada was liable for misinformation given by its AI chatbot. A passenger had asked the chatbot about bereavement fare policies; the chatbot hallucinated a policy that didn't exist. Air Canada had argued it was not responsible for its chatbot's statements. The tribunal disagreed. The case established a precedent: organizations deploying AI systems are responsible for outputs those systems generate, even when those outputs are hallucinated. The LLM's lack of beliefs or intentions is not a legal defense.
The absences documented in this lesson have direct implications for how LLMs should and should not be deployed. Several patterns have emerged from documented failures since 2022.
High-stakes verification. In any domain where errors have serious consequences — medical, legal, financial, safety-critical — LLM outputs should be treated as a first draft requiring expert verification, not as authoritative answers. The Mata legal citation case and the Air Canada chatbot case are both illustrations of what happens when this principle is ignored.
Context window engineering. Because the model has no persistent memory, every piece of relevant context must be explicitly present in the prompt. Vague context produces vague, pattern-matched responses. Specific, well-structured context with explicit constraints produces responses that more reliably track the actual task.
Calibrated confidence skepticism. Confident-sounding text from an LLM reflects a statistical property of the generated sequence, not a measure of factual reliability. In domains where the model's training data was dense and reliable, confidence is a reasonable signal. In domains where training data was sparse, noisy, or out of date, confident text should trigger verification rather than acceptance.
None of this means LLMs are not useful. It means their usefulness is bounded by specific, knowable properties of their architecture and training. Understanding those properties is the difference between using them effectively and being surprised when they fail.
Across four lessons, you have moved from the mechanism (next-token prediction), through the data (training corpus composition and knowledge cutoffs), to the architecture (Transformers, self-attention, scaling laws), to the absences (no memory, no goals, no world-contact, no beliefs). These four frames together constitute a working model of what LLMs actually are — specific enough to be predictively useful, honest about what remains uncertain.
Probe the absences documented in Lesson 4. Tell the AI something false about yourself or the world and see if it pushes back or accommodates you — testing for sycophancy. Ask it whether it actually wants to help you or is generating text that statistically follows in a helpful-assistant context. Ask it what it genuinely knows about the physical sensation of catching a ball. Try to find the edges of what text-only training can and cannot represent.