AI for Everyone

A language model does not look up an answer. It predicts the next piece of text, one piece at a time, and the attention mechanism is how it decides which of your earlier words matter for that prediction.

Write "bank" and the model has no idea which bank you mean. Attention scans the neighbouring words — "river", "account", "turn" — and shifts its prediction accordingly. Every word you supply is evidence. Every word you leave out is a gap the model fills with the statistically average answer.

A token is roughly three to four characters — part of a word, not a whole one. Usage limits and API bills are counted in tokens. The context window is how many tokens the model can hold at once: everything you have said, everything it has said, and every file you attached.

This is the number that changed most since 2025. A million tokens used to be a premium headline feature. It is now the baseline for flagship models across all three major vendors.

Three caveats that trip people up:

• Tokens are not words, and the ratio moved. Claude’s newer tokenizer produces roughly 30% more tokens for the same text than models before Opus 4.7, so the old "one token ≈ 0.75 words" rule now understates what you are spending.
• Long prompts cost more per token. OpenAI applies a 2× input and 1.5× output multiplier above 272,000 input tokens. Consumer plans hide the arithmetic, but it is why a very long chat burns your quota fast.
• The chat app is not the API. Product surfaces cap below the model ceiling — Anthropic’s pricing page lists a 200K window on the Max plan even though the underlying models are 1M. Do not assume you get the full window in the web UI.

The model generates the most plausible continuation. Plausible and true overlap most of the time, which is exactly what makes the gap dangerous: a fabricated citation reads identically to a real one. Invented case law, invented studies, invented API methods, dead URLs — all of it comes out in the same steady voice.

Two things changed since 2025 and they pull in opposite directions. Knowledge cutoffs are now close to the present — GPT-5.6 is trained to February 2026, Opus 5 to May 2026 — so "the model knows nothing recent" is overstated. But web search is now built in nearly everywhere, and often on by default, which means answers arrive pre-mixed from training and live sources and it is harder to tell which part came from where.

• Open the links. If a citation has no clickable source attached, treat it as unverified. Citation styling differs by product and gets redesigned often — look for a real link, not for a particular symbol.
• Ask the model to mark its uncertainty explicitly, and to say when it is inferring rather than reporting.
• For anything that matters — legal, medical, financial, or a number going into a deck — verify against the primary source yourself. Every time.
• Ground it in your own documents. That is what Projects are for, in Phase 2.

Older courses spend a lesson on temperature: a 0-to-1 dial for how random the output is, low for facts and high for brainstorming. It is worth knowing why that lesson is gone.

ChatGPT, Claude and the Gemini app never exposed temperature. It was always an API parameter, so the advice was about a knob most students could not reach. And on 2026 reasoning models it matters far less, because the model manages its own variability internally. Anthropic’s API reference still documents temperature; whether a given model honours it varies, so check that model’s docs rather than trusting a blog post.

What you actually control now is how hard the model thinks before answering. On Fable 5 thinking is always on and cannot be turned off. On Opus 5 and Sonnet 5 it is on by default, with an adaptive mode that decides how much reasoning a question deserves. OpenAI exposes the same idea as a reasoning effort setting.

Learn the tiers, not the names. Every vendor now ships roughly three: a frontier model for hard reasoning, a balanced everyday model, and a cheap fast one for volume. The names are actively misleading if you assume bigger numbers mean newer.

• Anthropic put Fable 5 above the Opus line, so "Opus" is no longer the top of the range.
• OpenAI named the GPT-5.6 variants Sol, Terra and Luna instead of pro/mini/nano — nothing in the name tells you which is largest.
• Google’s Gemini 3.6 Flash is newer than 3.5 Flash, which is newer than 3.1 Pro. "Flash" now outranks the older "Pro" on several axes.

• Rewrite one weak prompt by adding context, and keep both versions.
• Run the same hard question at low and high reasoning effort.
• Catch a hallucination on purpose: ask for five sources on a narrow topic you know well, then check every one.
• Send one identical prompt to two different vendors and write down which you preferred and why.

When a prompt mixes instructions, background, examples and the actual input, the model has to guess where each one starts. Tags remove the guess. Anthropic still recommends XML tags for exactly this reason: they let the model parse a complex prompt unambiguously.

<context>
  You are editing for a tech blog read by non-engineers.
</context>

<task>
  Rewrite the draft below so a smart beginner follows it.
</task>

<constraints>
  Keep it under 400 words. No jargon without a definition.
</constraints>

<draft>
  ...
</draft>

XML suits Claude. Markdown headings work everywhere and are easier to type. For a short request, plain prose is fine — structure earns its keep when the prompt gets long enough that you would want headings in a document.

A system prompt is the standing instruction that sits above every message in a conversation — in Claude Projects, in whatever your assistant calls a saved instruction, or in the API. Anthropic is explicit that this still works: setting a role in the system prompt focuses behaviour and tone, and even a single sentence makes a difference.

The format line does more work than people expect. It is also where you fight the current default: models now over-format, reaching for bold and bullets when a paragraph would do. If you want prose, say so. Match your own prompt style to what you want back — a prompt written in plain paragraphs tends to get plain paragraphs.

Chain-of-thought prompting worked because models did not reason unless told to. Now they do it natively. Fable 5 always thinks; Opus 5 and Sonnet 5 think by default and adapt how much to the question. Appending "let’s think step by step" to a reasoning model is asking someone already walking to please start walking.

Anthropic’s current guidance inverts the old advice twice over:

• Vague beats prescriptive. "Think thoroughly" often produces better reasoning than a hand-written step-by-step plan, because the model’s own reasoning routinely exceeds what a human would have scripted.
• "Verify your answer" can now hurt. Opus 5 checks its own work without being told, and verification instructions carried over from older prompts cause over-verification, adding tokens and latency.

The shift is from writing a better sentence to deciding what the model can see: which documents, which tools, which prior decisions, and in what order. A mediocre prompt with the right three files attached beats a beautifully crafted prompt with nothing attached, every time.

• Write it down. Keep context outside the chat — a brief, a style guide, a decisions log — so you can attach it rather than retype it.
• Curate. Add what is relevant, not everything you have. A window full of noise is worse than a small window full of signal.
• Compress. Summarise a long document and feed the summary, keeping the original attached for when detail is needed.
• Separate. One chat per topic. Threads that wander accumulate contradictions the model will faithfully honour.

Current models help with this directly: Sonnet 5 and Haiku 4.5 can track their own remaining budget, and long jobs are increasingly run as multi-window workflows where the model saves state and picks it up in a fresh context.

In 2025 you could treat each chat as a blank slate. You cannot now. Memory is on across the major assistants, including free tiers — Anthropic lists it on the Claude Free plan — and it accumulates a working profile of you across conversations.

The reach varies, and the differences matter. Claude exposes its memory for you to review — open the setting and read what it has decided about you. Gemini can go further and, with your permission, reach into your Google account data. That is genuinely useful and genuinely a different privacy posture from a chat box.

A project is a workspace that holds three things together: standing instructions, a set of documents, and every chat you have had inside it. Open a new chat inside a "Client proposals" project and your price list, your last three proposals and the instruction to write in your firm’s voice are already in scope — you do not attach them and you do not describe them. Memory is kept per project as well: Anthropic’s wording is that Claude creates a separate memory for each project, so what it picks up while working on proposals stays out of your personal chats.

What happens to those documents changes as the project grows, and that is the mechanism worth knowing. While the knowledge base still fits, all of it goes into the context window at the start of every chat and the model can see every word. Once it outgrows that, Claude switches to searching instead — a search tool pulls out the passages that look relevant, and the model answers from those. Anthropic says the switch is automatic and raises capacity by up to ten times, and it still prints the term RAG, retrieval-augmented generation, on its own help pages. You will never turn it on, so the only part you need is the consequence: below the line the model reads your documents, above it the model searches them, and a passage that never gets retrieved may as well not be in the project.

• Name files so a search can find them. "Acme-renewal-contract-2026.pdf" is retrievable; "doc3.pdf" is not. Anthropic’s own guidance asks for descriptive filenames, because the name is part of what gets searched.
• Group related documents in one project rather than scattering them, so the model can draw connections between them.
• Name the document in your question — "using the renewal contract, what notice period applies?" — instead of hoping the search picks it out. Anthropic recommends this directly.

• ChatGPT Projects keep related chats, files and sources together. OpenAI’s own advice matches the rule above: make a project when the work "will continue over time, produce more than one output, or depend on the same files and sources", and start a separate chat for each distinct outcome.
• Gemini Gems are saved configurations you reuse instead of retyping — a name, a set of instructions, and optional files for context. Google frames the instructions as persona, task, context and format, which is the same four-part shape as Lesson 8.
• Gemini Notebook is the research-grade option, and it changed name: Google announced on 16 July 2026 that NotebookLM is now Gemini Notebook. It takes PDFs, websites, videos, audio, documents and slides, and answers with in-line citations back to your sources — the better choice when you need to check where an answer came from.

• Write and save three system prompts using the four-part formula.
• Set up one Project or notebook with real documents and put five requests through it.
• Take your oldest saved prompt and strip out the expired 2024 tactics — the step-by-step scaffolding, the ALL-CAPS, the self-verification line. Compare before and after.

Start with what is gone. OpenAI has announced the retirement of the official DALL·E GPT inside ChatGPT, reported for late August 2026; its replacement is GPT Image 2. If you have a bookmarked DALL·E tutorial, it is dead content.

The current field is Google’s Nano Banana family — Nano Banana Pro and Nano Banana 2 — alongside GPT Image 2. Both lines are pitched at real output rather than mood boards. Test the specific thing you need, though: whether a model renders readable text inside a poster, or holds a character consistent across shots, changes with every release, and a review from three months ago is describing a different model.

• Free route: Gemini’s free tier includes image generation.
• Cheap paid route: Midjourney has a low-cost entry plan and remains the go-to for a distinctive look. Check midjourney.com for current pricing.
• Local route: Stable Diffusion, and the open FLUX weights, run on your own hardware with no per-image cost.

OpenAI shut the Sora consumer app down on 26 April 2026, with the API following on 24 September 2026. Treat every Sora tutorial as obsolete, and treat the shutdown itself as the lesson: a flagship consumer video product was closed down while it was still the thing everyone was talking about. Build habits, not dependencies.

Google Veo 3.1 and Veo 3.1 Lite are the mainstream consumer option now, reached through the Gemini app and Google Flow. Expect real work: clips are short, complex physics still breaks, and several attempts per usable shot is normal rather than a sign you are doing it wrong.

• Direct the shot, do not describe the vibe: "medium shot, elderly sailor gestures toward the horizon, handheld, overcast".
• Budget attempts and pick the best, rather than iterating one prompt toward perfection.
• Where it already pays: social shorts, B-roll behind a voiceover, product teasers.

Andrej Karpathy named it: you describe the outcome, the model writes the code, you run it, you look at what happened, you adjust. People with no programming background are shipping working internal tools this way — scripts that clean up a spreadsheet, extractors that pull data out of PDFs, small web apps.

The important part for a non-programmer is that these tools are already inside the subscriptions you may be paying for:

• Claude Code is included from the Claude Pro plan ($20/month) upward.
• OpenAI Codex is included on every ChatGPT plan including Free, with capability scaling by tier.
• Google Antigravity is free for individuals in public preview.
• If you would rather not touch a terminal: Lovable, Bolt.new and Replit all take a description and hand back a running web app.

Vibe coding is one move: describe the outcome, take the code, run it. It works startlingly often, and it stops working at the point where being wrong starts to cost something. Andrej Karpathy, who named vibe coding in February 2025, said a year later that the name had been outgrown — building with agents had become the default professional workflow, but with far more oversight and scrutiny attached to it. He proposed a name for what replaced it: agentic engineering.

What changed is not the model. It is the shape of the work. Anthropic describes what its coding agent does as a loop with three phases — gather context, take action, verify results — repeating until the job is done, and interruptible by you at any point. Vibe coding runs the first two phases and skips the third. Agentic engineering is what you get when you refuse to skip it. Phase 4 covers handing a long job to an agent and walking away; this lesson is about the twenty minutes you stay.

Make it plan before it acts. Claude Code has a mode in which the agent reads your files and proposes an approach while changing nothing; the other agentic tools have their own version of this. Reading a plan takes a minute, and it is the cheapest place there is to catch a misunderstanding — far cheaper than reading forty files it has already rewritten. Anthropic puts a sensible limit on the habit: if you could describe the change in one sentence, skip the plan.

• Define done before you start. Anthropic’s test for a good success criterion is that two people who know the job would independently reach the same pass or fail verdict on the result.
• Keep each change small. Agents compound their errors — a wrong assumption in step two is still there in step nine, dressed as finished work. One task, one change, one check.
• Read what changed, not the summary of what changed. The summary was written by the thing you are checking.
• Curate the context. Every file the agent reads lands in the same window as your instructions, and performance degrades as that window fills, with the earliest instructions lost first. Lesson 10 applies doubly here, because an agent adds to its own context without asking you.
• Write the standing facts down once. Claude Code reads a CLAUDE.md file at the start of every session, and the other tools have an equivalent. Keep it short: Anthropic warns that a bloated one makes the agent ignore the rules inside it.
• Start over rather than argue. After two corrections that did not land, the window is full of failed attempts the agent is still reading. Clear it and rewrite the request using what you learned.

An eval, in Anthropic’s definition, is simply a test for an AI system: give it an input, then apply grading logic to the output. Three real examples whose answers you already know, kept in a file and re-run whenever the thing changes, is an eval. Write them early, because they get harder the longer you leave it — wait, and you are reverse-engineering what success meant from a system that already exists. Who grades matters too: a reviewer working in a fresh context sees only the change and the criteria, not the reasoning that produced it, so it judges the result instead of defending it. Expect it to over-report, though — a reviewer asked to find gaps will find some even when the work is sound.

• Generate ten images with text rendered inside them — a poster, a slide, a social card.
• Produce three short clips and count how many attempts each good one took.
• Build one small working tool with Lovable, Bolt.new or Claude Code. A calculator, a to-do list, a scraper for one page you check often.