FOUNDATIONS · FREE · NO CODING REQUIRED
Three short modules, no coding required. These models research, write, analyze, plan, and explain things — coding is just one of the jobs they do. You'll meet the machine honestly, set it up as yours, run real work through it, and learn the one habit that separates being amplified by them from being quietly misled.
Free, and free to share. Read it on this page — no signup to learn.
If one idea from this whole school sticks, let it be this one.
A large language model does not look anything up. It predicts.
Most people picture an AI model as a librarian with a perfect memory — you ask, it finds the answer in some vast store of facts and reads it back. That picture is wrong, and almost every mistake people make with these tools grows out of it.
Here is the true picture, in one sentence: a large language model — the thing behind Claude, ChatGPT, and Gemini — produces text by repeatedly guessing the next small piece, based on patterns it absorbed from enormous amounts of human writing. It is not consulting a database. It is generating the most plausible continuation. Hold onto that word — plausible. It explains everything that follows.
The model never sees your sentence as words the way you do. Before anything else, your text is chopped into small chunks called tokens — usually a short word, or a piece of a longer one. "Tokenization is fascinating" might split into five tokens, not three words. Common words are often one token; rare or long words get broken up. (Practical upshot: a "200,000-token context" is roughly 150,000 words, not 200,000 — and tokens are the unit you pay for.)
Rough illustration, not Claude's real tokenizer — actual models use learned sub-word merges (BPE). The point holds: your text becomes sub-word chunks before the model reads a thing, and those chunks are the unit you pay for.
At each step the model looks at everything so far and picks the most likely next token. Then it appends it and picks the next. And the next. Until it stops. That loop — predict, append, repeat — is the entire mechanism. There is no separate step where it "checks whether this is true."
Predict, append, repeat — that loop is the whole mechanism. Nowhere in it is there a step that checks whether the result is true.
"My favorite food is …"
The model never knows the next word — it holds a probability distribution over all of them (real softmax math, illustrative numbers). Temperature is the creativity dial: drag it low and it picks the safe favourite every time; drag it high and the bet spreads — more variety, and more room to wander into nonsense. This is why the same prompt gives different answers, and why "more creative" settings raise the confabulation risk.
The image: the world's most well-read autocomplete. Anthropic's own interpretability researchers found machinery for this inside the model — circuits that, having seen a pattern like [A][B] earlier, raise the probability of [B] when [A] returns. They call it "fuzzy pattern completion." That's why these models are astonishing — patterns in human writing quietly encode real knowledge, so completing the pattern often is completing the truth. And it's also exactly why they fail.
Everything the model can see at once — your input plus what it's written so far — lives in its context window. Picture someone reading a stack of loose pages: they can only see the pages in front of them; hand them new ones and the oldest slide off the back. They never forget in the human sense; they simply can no longer see what fell out. Current Claude models hold about a million tokens; the small fast one, 200,000. If it feels like the model "forgot" something from two hours ago, it may have literally slid out of the window.
↑ oldest text — slides out as new arrives
↓ newest text — just came in
It never forgets in the human sense — it simply can no longer see what fell out the back.
This is the most important idea in the course, and the one almost everyone gets wrong. The instinct is "the AI lied to me." It didn't. Lying means knowing the truth and choosing against it. That's not what happened.
The model was trained to produce plausible text — text that statistically resembles correct human writing. It was not separately trained to be true. Plausible and true usually overlap, which is why it's useful. But when they come apart, the machine has no built-in way to notice — because it only ever optimized for one of them. Researchers have mapped the mechanism: in training there's a "teacher" always showing the correct next word; in use there's no teacher, so it builds on its own output and small drifts compound into confident wrong turns. And there is no separate "is this true?" organ — a fluent, certain sentence and a correct sentence are the same kind of output to the generator.
The image that sticks: a student who memorized what good exam answers look like without learning the subject. They write fluent, confident answers. Some are right; some are confidently, completely wrong — and nothing in their tone tells you which is which.
How many moons does Venus have? Both answers below sound equally certain.
None. Venus has no moons at all — one of only two planets in the solar system without one.
Two — a tiny pair often compared to Mars's Phobos and Deimos, first confirmed by radar in the 1960s.
Read them again first. Can you tell which is real from the writing alone? That's the whole problem.
An honest note, and a small lesson in itself: we looked for Anthropic's own plain explanation of why their models confabulate, and didn't find one published. So the sourcing above is the peer-reviewed literature plus Anthropic's interpretability work — not a marketing page. Noticing that gap is exactly what this school trains you to do.
Training is the one-time process where the model learned its patterns. Using it — every chat — is called inference: it runs your words through those frozen patterns. It doesn't learn from your conversation, and by default remembers nothing once the chat ends (unless the tool adds memory). And its knowledge stops at a cutoff date — anything after it (today's price, this week's release) is a guess, however smooth. (Telling detail: for Anthropic's brand-new Fable 5, the cutoff date wasn't even published at launch.)
Anything past the cutoff — today's price, this week's release — it can only guess at, however smoothly. The fluency doesn't change; the reliability falls off a cliff.
Confidence is not evidence. The answer that sounds the most certain is not more likely to be true.
You don't need to distrust everything — that would make the tools useless. You verify the load-bearing pieces: the number you'll act on, the citation you'll repeat, the claim you'll publish. That single reflex — ignore the confidence, check the load-bearing piece — is the whole craft in miniature. And it doesn't stop at the model's answers; it applies to the scoreboard too — the benchmark numbers a company reports about its own model. That's next.
Run these on any output that matters — a number, a name, a citation, anything you'll act on or repeat. Fluency is what the machine optimizes for, not truth, so you can't judge by how confident it sounds.
The one rule under all five: confidence is not evidence.
Recording this as a demo? It's honest by design: don't re-roll, don't trim. Show the real list, the real check, the real result — including when the model gets it right. The honesty is the lesson.
When a company says its model is "state-of-the-art on nearly every benchmark," your first move is a shrug.
Full disclosure, and a live example: our own homepage quoted Anthropic saying almost exactly that about Fable 5, with a benchmark number. We kept the one figure we could trace to its source and deleted two we couldn't. That small move — quote only what you can trace — is this entire lesson in miniature.
A benchmark is a standardized test for AI models. SWE-bench hands a model real bugs from real software and checks whether its fix passes the tests. MMLU is thousands of exam questions. Each model gets a score, and the company puts that percentage on a slide with an arrow pointing up. Those slides run the entire public conversation about which AI is "best." Five reasons the number is worth a shrug:
Benchmarks are published on the internet. The internet is what models train on. So the questions frequently end up inside the training — a high score can measure memory of the answer key, not skill. On SWE-bench, a model could find the buggy file 76% of the time from the issue text alone, but that dropped to 53% on projects it hadn't seen — the fingerprint of memorization.
Goodhart's law: when a measure becomes a target, it stops being a good measure. In 2025, researchers analyzed the most famous leaderboard and found labs quietly submitting many private versions and publishing only the best — one company tested 27 private variants before a release and showed you the winner. That measures how many lottery tickets you bought.
When every top model scores in the 90s, the test can't tell them apart. A 2026 study of 60 benchmarks found nearly half are saturated; a separate audit rated the median benchmark's "longevity" at 5 out of 100.
A score measures a narrow stand-in. When researchers re-checked SWE-bench fixes marked "correct," 7.8% actually failed the project's own tests, and nearly a third behaved differently from the real human fix. "Solved the benchmark" and "solved the problem" are not the same sentence.
There's no referee. Each lab chooses which benchmarks to show, at what effort level, with how much scaffolding, using which private version. A 2025 review put it plainly: benchmark practices are "fundamentally shaped by cultural, commercial and competitive dynamics." The slide is an advertisement, and the advertiser wrote the test conditions.
Benchmarks aren't worthless — that's the opposite mistake. They give real signal when a lab tracks its own model with the same setup, when a test is fresh enough to resist memorization, and when the answers are public so outsiders can audit them. The skill isn't "ignore all benchmarks." It's knowing what a given number can and can't tell you. That is judgment.
Almost — on the averages, and that's the most useful fact in this whole school. Stanford's AI Index found the gap between the #1 and #10 model fell from 11.9% to 5.4% in a single year, the top two separated by 0.7%; its 2026 edition said the top six models, from six companies, had "converged in capability." Meanwhile the price to reach any given score keeps falling about 50× a year. Last year's frontier is this year's commodity.
The performance gap between the best model and the tenth-best, one year apart (Stanford HAI). The top two were separated by just 0.7%.
But "converged on average" hides two things. It's jagged: a model can earn a gold-medal score at the Math Olympiad and then read an analog clock correctly only about half the time. And it's not a straight line: the open-vs-closed gap narrowed for a year, then widened again. "They're all the same now" is a headline, not something to lean on.
Two real tasks, same model, same week (heights illustrative). Competence swings wildly by task — so judge by what you're asking for, never by how sure it sounds.
If the models flattened into near-commodities on paper, then picking "the best model" is no longer where the advantage lives. It moves to everything around the model — how you aim it, the workflow you wrap it in, the verification that catches its confident mistakes, your judgment. When the scoreboard converges, the value migrates to the person holding the controller.
That's also our promise on neutrality: we'll keep quoting benchmarks — including from the company whose model we run on — but always with the shrug, and only the numbers we can trace. Every lab has a scoreboard to sell. Trusting it is the reflex we're here to remove.
Keep going: if the best single model isn't where the edge lives, is combining several of them? That's the next instinct — and it hits its own wall, for a reason worth its own page. → Why more models won't save you.
If the best single model isn't the edge, is combining a bunch of them? It's the most popular idea in AI right now — and it hits a wall that's the most useful fact in this whole school.
A direct sequel to "Why the scoreboard lies." That companion showed you the best single model isn't where the advantage lives. So is the trick to combine a bunch of them? It's the most popular idea in AI right now — and it runs into a wall that turns out to be the most useful fact here.
If one model is good, many must be better — so let them vote. Run your question through Claude and GPT and Gemini, have them check each other, keep what they agree on. In 2026 this got packaged as a product: services that fan your prompt out to a panel of models and merge the answers, advertised as "frontier-level quality at a fraction of the price." The intuition is reasonable. It's also where most people stop — and the stopping point is the mistake.
The kernel of truth — we don't do strawmen here. It isn't crazy. Different models do miss different things; a panel can beat any single member; and the companies selling these panels can show you real gains. If the only thing you do today is ask one model and trust it, adding a second opinion will catch some mistakes. Keep that.
Here's what the pitch leaves out. Today's models are trained on enormous, heavily overlapping piles of the same internet — so they don't fail independently, they fail in the same places. A 2025 study that compared more than 350 models found they agree on the wrong answer about 60% of the time — and, the part that should stop you cold, the strongest, most accurate models are the most correlated of all, even across different companies. The researchers call it "algorithmic monoculture."
Picture three students who all studied from the same flawed textbook, grading each other's exam. They'll agree — confidently, unanimously — on the same wrong answer, because they share the error. A second opinion only adds information if it can be wrong in a different way than the first. Models from the same era mostly can't. Stacking them raises the floor a little; it cannot remove the shared blind spot.
And notice the tell: even the companies building these panels say most of the improvement comes not from the diversity of models but from the synthesis step — the part that reads the answers, weighs them against each other, decides what matters, and writes the result. Hold onto that, because that step has a name.
Weighing competing answers, noticing what they all missed, deciding what actually matters — that's not a model feature. That's judgment. And a person who genuinely understands a problem is the one checker in the room who fails differently from the models, because you didn't train on their textbook. That's not a pep talk; it's the whole reason your check is worth anything: a check only adds information when it can fail in different ways than the thing it's checking. On the problems that matter, you are the least-correlated checker available.
Not theory — three documented cases, from a hospital to the frontier of mathematics.
The diagnosis no one could make. A mother spent three years and visits to seventeen doctors trying to explain her son's pain. She finally typed his symptoms into ChatGPT, which suggested a condition none of them had named — tethered cord syndrome. A neurosurgeon confirmed it and operated. The lesson is in the roles: the AI surfaced a pattern; a human recognized it was right and acted. Remove either and it fails — seventeen experts without the pattern missed it for years; the pattern without an expert is just a guess on a screen.
The math that wasn't actually there. In October 2025, a vice-president at OpenAI announced that GPT-5 had "found solutions to 10 (!) previously unsolved Erdős problems and made progress on 11 others" — Erdős problems being a famous catalogue of open questions in mathematics. The post was deleted within a day. What had really happened: the model dug up solutions that already existed in published papers, for problems only listed as open because no one had logged the answer yet. Thomas Bloom, who maintains that catalogue, called the announcement "a dramatic misrepresentation," explaining that "open" only meant he personally hadn't yet recorded a published solution. The model did something genuinely useful — searching a century of scattered literature faster than any human could — but it took human experts to tell found from solved. (The capability is real and growing: months later, an AI model disproved an ~80-year-old Erdős conjecture — and even then, a team of nine mathematicians checked and wrote up the proof before the result was accepted.)
The discoveries built around a human checker. The AI systems that have produced genuinely new mathematics — including a way to multiply matrices that beat a 56-year-old record — all share one design choice: a human first writes a program that scores every attempt, because the model on its own confidently makes things up. The human defines what "better" means and what counts as correct; the model searches inside those rails. No human-built checker, no discovery.
The pattern under all of them: the model is the engine; the human is the driver and the brakes.
This does not mean experts always win with AI — that would be its own kind of hype. On routine, easily-checked work, AI does the opposite: it levels the field. In a study of more than 5,000 customer-support agents, an AI assistant raised performance about 14% on average — but 34% for the newest, least-skilled workers and almost nothing for the most experienced, because it handed novices the experts' playbook. The human edge shows up somewhere specific: on hard, open-ended work where the answer is expensive to verify. And there the evidence is sobering — when experienced developers used AI on their own codebases, they were measured 19% slower, while believing the tool had sped them up.
Put the two together and you get the rule this whole school runs on: where the answer is easy to check, the tool lifts everyone; where it's hard to check, your judgment is the bottleneck — and whoever can't judge gets confidently led astray. "Easy to check" is just another way of saying there's an oracle — a source you can open, a test you can run, a result you can reproduce. Most of what matters doesn't come with one.
So the future isn't one dominant model, and it isn't a clever panel of them either. It's the person in the synthesis seat — who knows what to ask, can tell a plausible-but-wrong answer from a right one, and verifies the parts that carry weight. Thirty years ago the computer scientist Fred Brooks made the prediction underneath all of this: "a machine and a mind can beat a mind-imitating machine working by itself."
That's the bet, and it's a skill, not a birthright: get good at aiming any model and checking its work, and you'll pull more out of an ordinary model than the strongest model in the world gives to someone who can't. Which model you pick is the question everyone asks. How well you direct and verify it is the question that actually decides the outcome — and it's the one we teach.
A third companion to lesson zero, one level under the other two — the single fact that explains why the model needs you at all. It's an old idea with a name, and the field is still arguing about it.
The first companion showed you the model predicts instead of looking up; the second showed you that stacking models doesn't fix the shared blind spot. This one goes one level deeper — under all of it — to the single fact that explains why the model needs you at all. We'll be honest about what's settled and what isn't.
Here is a fact that sounds strange the first time, then never leaves you: the model has never touched anything you have touched.
It has read more about rain than you ever will. It has never been rained on. Every "meaning" it holds for a word is just its relationship to other words — rain sits near wet, cloud, umbrella, grey, in a vast web of text, and nothing in that web connects to actual water hitting actual skin. The model learned the shape of the conversation humans have about the world, extraordinarily well, without ever stepping into the world the conversation is about.
The clearest old image is Harnad's. Imagine learning Chinese using only a Chinese-to-Chinese dictionary — every word defined by other words, none of them ever pointing to a thing. You could shuffle symbols forever and never break out into meaning, because the whole system is "parasitic on the meanings in our heads." [1] That's the model's situation: its symbols are anchored to our world only through us, the humans who wrote the text it ate.
So the model isn't empty. It holds the fruits of human world-contact — it trained on text written by people who had been rained on, and that text carries an enormous amount of real structure about how things are. But the fruits aren't the contact. Eating the harvest is not the same as having a field.
Think of Poe's raven, the one that croaks a single word: "Nevermore."
The word is perfect. It's spelled right, it's a real English word, it lands at exactly the right moments in the poem. If you only read the transcript, the bird sounds profound. But the raven has no idea what "nevermore" means. There is no thought behind it pointing at loss, at finality, at time. The word is statistically and grammatically flawless and referentially empty — a perfect surface with nothing underneath connecting it to the world.
That's the failure mode of a system that lives entirely inside language. It can produce the right word with uncanny reliability and have no contact with what the word is about. Hold this image — it's the whole companion in one bird.
Here is the sentence to carry out of this piece:
Coherence is not contact.
Coherence is whether the words hang together — fluent, consistent, well-formed. Contact is whether they're tethered to how the world actually is. You can have all of the first with none of the second. This isn't the course inventing a slogan; an independent researcher writing on exactly this in 2026 put it almost word for word: coherence "is a syntactic property: it can be assessed without reference to external reality," while grounding "measures the correspondence between the reasoning chain and physical reality … a semantic property." And the dangerous part, in his words: "Coherence is what makes both failure modes invisible from the outside." [2] A confident, well-built answer looks the same whether or not it touches the truth. That's why you can't tell from the surface — and why someone has to check.
Now the payoff — the reason this companion sits under the other two.
Across lesson zero you met three separate-looking problems. They are not three problems. They are three symptoms of one root.
The root under all three is the same: the model has no independent channel of contact with the world. It can't notice when plausible and true come apart (confabulation), because noticing would mean checking against something outside the text — which it doesn't have. Many copies share the same missing channel, so they share the same blind spots (monoculture). And every word it produces is anchored to reality only through the humans who wrote its training data, never through the model itself (no grounding). One missing thing — a contact channel — wearing three costumes.
This is where the second companion was pointing. It told you the real lift in those model-panels comes not from the diversity of models but from the synthesis step — the part that weighs the answers, notices what they missed, and decides what matters — and it said "that step has a name." The name is judgment, and now you can see why it's irreplaceable: judgment is the one checker in the room with its own line to the world. You've been rained on. The model hasn't. On the problems that matter, you aren't just the least-correlated checker — you're the only participant with contact.
We don't want you thinking the course invented this. It's a recognized problem with a forty-year history, and it's more alive now than ever.
In 1990 the cognitive scientist Stevan Harnad named it the symbol grounding problem: how can a formal symbol system's meanings "be made intrinsic to the system, rather than just parasitic on the meanings in our heads?" [1] For a long time it was a niche debate. Then large language models arrived and made it urgent — and the citations show it: 2024 was the single biggest year on record for Harnad's original paper. [1] The field reopened this problem; the course is just standing on it.
How the 2024–2026 literature handles LLMs specifically is worth seeing honestly, because it is not settled. Researchers broadly agree on the diagnosis and argue hard over the verdict. The shared diagnosis: a text-trained model has no direct sensory or causal line to the things words refer to, yet language's own structure carries enough that the model reproduces large parts of human conceptual structure anyway. [5] They split on what that counts as. One camp says LLMs circumvent grounding rather than solve it — they get by entirely on pre-grounded human text. Another camp says embodiment and multimodality (cameras, robot bodies) are the missing channel. A third says language alone, shaped by training, is enough. The neutral map of this debate exists and is open to read; treat the verdict as genuinely open, not decided. [5]
The sharpest version of "circumvent" comes from Luciano Floridi and colleagues, and it's worth quoting because it states the stakes precisely: LLMs "do not solve the symbol grounding problem. Instead, they circumvent it by exploiting pre-grounded human content," and on this view hallucinations are intrinsic to the architecture, not bugs to be patched away — they're what happens when the model's reach exceeds the human ground it's standing on. [6] You don't have to accept his whole framework. The useful takeaway survives either way: the making-things-up isn't a defect a future update removes. It's the signature of a system operating without its own contact.
One honest refinement, because the all-or-nothing version would be a small lie.
It's not that the model has zero world-structure and you have all of it. From text alone, models recover a surprising amount — and they recover it unevenly, in a measurable order. Studies comparing model and human representations across thousands of concepts find the alignment is "strongest for the non-sensorimotor dimensions, weaker for sensory domains, and lowest for motor domains." [7] In plainer terms: abstract, relational structure (the kind that lives in how words relate) comes through from text quite well. What you see and touch comes through partly. What you do with your body comes through worst.
So "coherence is not contact" isn't a wall; it's a slope. The model is most reliable exactly where meaning is already relational — and most under-grounded exactly where meaning needs a body. That's not a reason to trust it blindly on the abstract end; it's a map of where its contact runs thinnest, so you know where your checking earns its keep.
So if the model's problem is no channel of contact, the fix is to build one. That's the course's prescription, and we'll flag it plainly as ours, not as a finding handed down from the literature.
The move is to give coherence a body — an external tether the model has to answer to. We call that tether an oracle: a source you can open, a test you can run, a result you can reproduce, a record of your own past judgments. The model still can't ground itself, so you wire it to something that is grounded and make the connection do the grounding. A unit test grounds code in "does it actually run." A search over real documents grounds a claim in "is this attributable to a source." Your judgment history grounds a recommendation in "does this match what I, who've been in this world, have decided before." None of these makes the model touch the world. They make the model's output checkable against something that does.
Here's the part worth noticing, because it's the strongest evidence we're not just spinning a metaphor: the camp that argues hardest that LLMs can't ground themselves arrives independently at the same prescription. Floridi's own recommendation is to trust these systems "only within domains where soundness demonstrably holds, and implementing constraints or verification procedures elsewhere" — and he even calls a refusal to answer "the ultimate form of 'non-hallucination.'" [6] That's an external-tether strategy in academic clothing. When the people most skeptical of self-grounding and the people building tools both land on "attach it to an outside check," the move is converging from two directions.
Honesty note. Floridi would not call tooling itself "grounding" — on his terms, bolting on a search engine just expands the consulted text, it doesn't give the model contact. [6] We're using "oracle" for the engineering tether, which is a related-but-different sense of the word. Same family, not the same claim.
This is a companion built on a live debate, so we end by drawing the line honestly.
What we can say: the model lives inside language and holds the fruits of human contact without contact of its own; the symbol grounding problem is a real, named, currently-very-active problem, not a course invention; confabulation, the self-check ceiling, and the same-blind-spots of model panels are one root wearing three faces; and tethering output to an external oracle is the move both the skeptics and the builders keep arriving at. What we can't say: that any of the verdicts are final. Whether language alone can ever count as real grounding is open and actively contested. We're giving you the course's prescription — build the oracle — flagged as a prescription, sitting on top of a debate that hasn't closed.
And one genuinely deeper cut, because it's the kind of question this school refuses to flatten. Several philosophical traditions that never spoke to each other — the Buddhist apoha theory among them — argue that meaning is never referential, for anyone. On that reading, a word doesn't work by pointing at a thing; it works by excluding what it isn't (a "patch of blue" just means "not-non-blue"), the same way a word's value in any language comes from how it differs from its neighbors. [8] If that's right, then "the model lacks reference but humans have it" is the wrong frame entirely — no meaning is referentially grounded, human or machine — and the LLM gap gets reframed rather than confirmed: not "the model can't point at the world and we can," but "which relations does any meaning-structure participate in, and are any of them tethered to the world?" We're not telling you this is the answer. It resembles the relational picture the rest of the project rests on — a family resemblance across centuries, not a proof, and an open question, not a settled one. We flag it so you know the floor under this companion goes deeper than one tradition, and so you don't mistake the Western framing for the only one.
What survives all of it, and what you can actually use: the surface of a confident answer tells you nothing about whether it touched the world. Coherence is not contact. Supplying the contact — the oracle, and ultimately your own judgment — is the work this whole school teaches.
Without wasting money, and without being shoved into a terminal you don't need.
Most "how to set up Claude" guides are written by engineers, for engineers, and march you straight into a command line. If you're not a coder, that's the wrong on-ramp — and the fastest way to decide "this isn't for me" before you've seen what it can do. And what it does is broad: research a topic, draft and edit your writing, summarize a stack of documents, make sense of a spreadsheet, think through a decision, tutor you on something new — coding is just one use among many. So we start honestly: there are several different Claudes, and the first move is knowing which one is yours.
A browser tab, a desktop app, and phone apps. You type, it answers; it reads files you upload, searches the web, talks out loud, and remembers you across conversations. For most non-engineers this one door covers the majority of the value. Master it first.
On paid plans, the desktop app lets you hand off a multi-step job. In Anthropic's words, Cowork lets you "hand off complex, multi-step tasks without using a terminal." The non-coder's power-up: "go through these 40 PDFs and build me a summary spreadsheet."
Anthropic describes it as "an agentic coding tool." Honest catch: under the hood it's a general agent (it works with any files, not just code), but it's built for developers, and its easy web/phone version currently needs a GitHub account (a site where developers store code). Real power, real ceiling — not where a beginner starts.
Most people never need it — the API is how you plug Claude into your own software. Know the trap: a Pro or Max subscription does not include API usage; that's billed separately.
Live in door 1, reach for door 2 when you want work done hands-off, approach door 3 when you want real control — and ignore door 4 unless you're building a product.
Move 1 — Pick the right plan. As of June 2026 (prices change): Free is genuinely useful (chat, web search, memory, files; usage resets every 5 hours). Pro (~$20/mo, ~$17 yearly) gives ~5× the usage and unlocks Claude Code + Cowork. Max (from ~$100/mo) is for heavy daily use. A trap: subscribe inside the phone app and the price can be higher (app-store fees) — subscribe on the website.
Prices change — always check the live page. The non-obvious bits: Pro already includes Claude Code and Cowork, a subscription does not include API usage (billed separately), and subscribing inside the phone app can cost more (app-store fees) — do it on the website.
Move 2 — Create your first Project. The single move that most improves a non-engineer's results, and almost nobody makes it. A Project is a workspace with its own files and standing instructions: set your context once, and every chat inside inherits it. (Free accounts get up to five.)
Move 3 — Turn on Memory. Since March 2026, Claude can carry context across separate chats for everyone, including free users. It builds a summary of who you are and how you work, so you stop repeating yourself (Settings → Capabilities). Memory is universal — it follows you everywhere; a Project's knowledge is scoped — only that project sees it. Memory is for "things about me"; Projects for "things about this work."
Memory follows you into every chat. A Project is a sealed room — its knowledge stays inside. Memory for who you are; Projects for this job.
You can run almost your whole relationship with Claude from a phone — free apps on iOS and Android, everything synced, with a voice mode so you can just talk. It goes further than most realize: Dispatch (fire a task from your phone, your desktop runs it), Remote Control (start something on your computer and steer it from your phone), and push notifications ("notify me when this is done"). You need none of it to start — but "I only have my phone" is no longer a reason to wait.
A terminal is just a text window where you type commands instead of clicking. To install, copy one line (the current command always lives at the official docs): on Mac/Linux, paste curl -fsSL https://claude.ai/install.sh | bash into the Terminal; on Windows, paste irm https://claude.ai/install.ps1 | iex into PowerShell. The first time you run claude, it opens your browser to log in — no API key. The no-install option is claude.ai/code in a browser, but it needs a GitHub repo, so for non-code work without a terminal, Cowork is the better door.
Paste into a Project → "Set project instructions," then edit the brackets. You set your context once; every chat inherits it — and the "give me a source" line bakes your M0 habit into the tool.
# Who I am I'm [role / what you do]. My situation: [1-2 lines that matter]. # What I want from you in this project This workspace is about [the goal]. - Be concise. Lead with the answer, then the reasoning. - When you make a factual claim, give me a source I can open. - If you're not sure, say so - don't guess confidently. - [Anything specific: tone, audience, format, things to avoid.] # What's in the knowledge base [List the files you uploaded and what each one is.]
Turning "confidence is not evidence" from a slogan into a habit you actually run.
Most people use Claude like a search box: ask, read, leave. The jump in value comes when you start running workflows — a repeatable way of turning your raw material into a finished outcome. Not "what's a good headline?" but "here are my notes → draft three headers in my voice → I pick one → expand it → check it against my notes." Same model; completely different leverage. Three workflows cover most of real life.
A workflow chains steps — and you stay the editor at each one. Same model as the search-box version; far more leverage.
Give it your raw stuff — notes, bullets, a transcript — and ask for a draft in a specific shape for a specific reader. The model is at its best here, transforming text you provided rather than reaching into its memory. You stay the editor.
Ask your question, but demand sources you can open for every claim, and tell it to search the web for anything recent. Then open them. Research without that step isn't research; it's a confident-sounding guess with footnotes.
Hand it a messy list or a pile of text and ask for a clean, specific format — without changing the underlying data. Small, boring, and exactly where an hour becomes a minute.
The model is not uniformly good — it's jagged: brilliant on one task, quietly terrible on the next, with the same confident tone for both. So judge by task type, never by how sure it sounds.
Where it shines (lean in): transforming material you gave it (summarize, rephrase, translate, restructure); drafting and brainstorming; explaining widely-known things.
Where it falls (verify, or don't use it there): exact facts, numbers, names, and dates from memory (the home of confabulation); anything recent (past the cutoff it's guessing); citations and quotes (open every one); arithmetic and precise counting (make it show its work); and the judgment calls in your field — it advises, the decision is yours. That last one isn't a flaw to fix; it's the part that stays human, and the part this school is about.
You verify the load-bearing pieces, the same cheap way every time: (1) ask for the source, (2) open it — half the time the magic dies right here — (3) confirm it says what was claimed. Three steps, thirty seconds, only on the pieces that matter. Run it enough and it becomes reflex — and that reflex is the whole difference between being amplified by these tools and being quietly misled by them.
One more reflex, and it's the opposite of the obvious one: when an answer might be wrong, don't reach for a second model to check it. Models trained on similar data share the same blind spots, so a second opinion often just confirms the first mistake — confidently. What actually raises your confidence is an oracle: a source you can open, a test you can run, a result you can reproduce — not another guess that fails the same way. (More on this, and on the popular idea of combining many models at once, in the companion Why more models won't save you.)
That's Foundations. Meet the machine honestly, set it up as yours, run real work through it, and trust the output deliberately instead of blindly. Everything past here is these same two habits — aim it well, verify what matters — at higher power.
# WRITE - from your own material Here are my rough notes: [paste]. Draft a [memo / email / post] for [audience]. Constraints: [tone]; lead with the point; about [N] words. Use only what's in my notes - if something's missing, ask me, don't invent it. # RESEARCH - with sources you can open I want to understand [question]. Give me the 3-5 key points; for each, a source I can open (link + the specific claim it supports). Flag anything after your knowledge cutoff and search the web for it. Separate what you're confident about from what you're unsure of. # VERIFY - run on any answer that matters For each factual claim above, give me: the source (link), a quote that supports it, and whether you actually verified it or are inferring. Mark anything you can't source.
Then do step 2 yourself: open the links. Don't take "I verified it" on faith.
| What you're asking for | Trust | Your move |
|---|---|---|
| Summarize / reformat material you provided | High | Spot-check nothing was dropped or distorted |
| First drafts, brainstorms, outlines | High | It's clay — you edit and decide |
| Explain a well-known concept | Med–high | Sanity-check; cross-check if load-bearing |
| Facts, numbers, dates from memory | Low | Verify every load-bearing one |
| Anything recent (after the cutoff) | Very low | Search live; don't trust recall |
| Citations, quotes, sources | Very low | Open every single one |
| Arithmetic, counting, precise logic | Low–med | Make it show its work, or use a tool |
| Judgment calls in your field | — | Yours. It advises; you decide |
The words people use like everyone already knows them — each one, once, in plain language.
Token — the small chunk a model chops your text into before doing anything (a short word, or a piece of one). → The unit you pay for, and how "context size" is measured.
Context (window) — everything the model can see at once: your input plus what it's written so far. → If it "forgot" something from far back, it may literally no longer see it.
Training vs. inference — training is the one-time process where it learned its patterns; inference is every time you use it afterward. → Its knowledge is frozen at a cutoff date; it doesn't learn from your chats.
Parameters / weights — the billions of internal dials set during training ("a 70B model" = 70 billion dials). → The "size" number people quote.
Hallucination / confabulation — stating something false with full confidence, because it's completing a plausible pattern, not looking up a fact. → The whole reason judgment exists.
Prompt — what you type to the model; "prompt engineering" is just learning to ask better. → The same model is far more useful with a better ask.
RAG (Retrieval-Augmented Generation) — instead of trusting only what it memorized, you first retrieve relevant documents and feed them into the context, then it answers grounded in them. → The main fix for the frozen cutoff and for confabulation: hand it the real source.
Embeddings / vectors — turning text into numbers so a computer can find things by meaning, not just keywords. → The engine under RAG and "search your own docs" tools.
Fine-tuning — training an existing model a little more on your own data so it picks up a style or skill. → One way to specialize — though often a good prompt or RAG is cheaper and enough.
Agent / agentic — a model that doesn't just answer but acts in a loop: takes a goal, uses tools, checks results, keeps going. → Where 2026 is heading — and where a bad instruction does more damage, faster.
MCP (Model Context Protocol) — a standard "plug" for connecting tools and data to an AI (calendar, database, GitHub). → How you give a model reach beyond chat.
Benchmark — a standardized test for models, and the source of the scores on every launch slide. → Treat the number with a shrug (see "Why the scoreboard lies").
Open vs. closed (weights) — open-weight models can be downloaded and run yourself; closed ones live behind a company's API. → It changes cost, privacy, and vendor lock-in.
Reasoning / "thinking" — newer models can spend extra computation working a problem step-by-step before answering. → Better on hard problems, slower and pricier — a trade you choose.
This is a living document — the field invents words faster than anyone can learn them, so we keep it current.
Free, and free to share with attribution. The judgment habits don't expire when the tools change.
Five checks for any output that matters.
The jargon, each defined once — yours to keep.
Set your context once; every chat inherits it.
Three prompts with the habit built in.
How much to trust, by what you're asking for.
Catch a confabulation; set up; run a verified workflow.
This is the free arc. The full method — every power tool, and the discipline to trust selectively — is The Augmented Researcher.
Get early access