The big idea
Large language models are fundamentally pattern-completion engines: they predict what text should come next, and at scale that produces something that looks like reasoning. That means they're fluent first and accurate second — hallucination isn't a bug to be fixed, it's a property of how the technology works, so your job is knowing when to trust an answer and when to verify it.
Deep dive
What a large language model actually is
ChatGPT, Claude, Gemini — these are all large language models (LLMs). Strip away the branding, and an LLM is a system trained on an enormous amount of text that learned one skill extraordinarily well: predicting what text should come next. When you ask "What's the capital of France?", the model isn't looking up a database entry — it's completing a pattern, because text starting with that question is overwhelmingly followed by "Paris" in everything it has read. Scale that up across trillions of words, and something remarkable emerges: the ability to reason, summarize, translate, write code, and hold a conversation.
Three practical consequences follow. First, **LLMs are fluent first, accurate second** — the model is optimized to produce plausible text, and usually plausible and true overlap, but sometimes they don't, and the model will state a wrong answer with exactly the same confident tone as a right one. This is called hallucination, and it's not a bug that will be fully "fixed" — it's a property of how the technology works.
Second, **LLMs don't "know" today's news by default** — models are trained up to a cutoff date, and anything after that requires web search or connected tools. Third, **quality in, quality out** — the model completes *your* text, so a vague prompt gets a generic completion and a prompt rich in context gets a completion shaped by that context.
Tokens, context windows, and why long chats get dumb
LLMs read and write in tokens — chunks of roughly ¾ of a word. Every model has a context window: the maximum amount of text it can pay attention to at once, including your conversation history, uploaded files, and its own replies. Think of it as the model's working memory or desk space.
Two things matter even with today's large windows. Everything competes for attention — if you paste a 90-page PDF and ask one question, that answer is fighting for attention with 89 irrelevant pages, so point the model at the relevant part. And long conversations degrade — after dozens of turns, contradictions and stale instructions pile up, and if a chat starts feeling confused, the fix is to start a fresh chat and paste in a short summary of where you got to. Rule of thumb: one chat, one task.
Models, modes, and reasoning
Inside each product you'll usually find multiple models or modes: fast/light models that are near-instant and great for rewriting or quick questions; frontier/flagship models that are slower but dramatically better at complex reasoning and nuanced writing; reasoning or "extended thinking" modes where the model thinks step by step before answering, best for math, planning, and multi-step analysis; and Deep Research modes where the model autonomously searches and reads dozens of sources over 5–30 minutes.
The practical rule: default to the best model you have access to for anything that matters. The cost difference is pennies; the quality difference is often the difference between usable and unusable.
When to trust, when to verify
Use a mental triage for every AI output. Brainstorming, drafts, and rewording deserve high trust — use directly. Summaries of documents you provided deserve high-medium trust — spot-check key numbers. General knowledge and stable facts deserve medium trust. Specific numbers, dates, prices, laws, and citations deserve low trust — always verify. Anything you'll publish, send to a client, or file with a government deserves low trust — verify every factual claim.
Two verification habits take seconds: ask for sources ("search the web and give me linked sources for each claim") and then click one or two, or ask the model to argue against itself ("what might be wrong or outdated in your answer above?"). Models are surprisingly good at catching their own errors when explicitly asked. Never file, sign, publish, or pay based on an unverified AI answer — AI is your analyst, not your accountant, lawyer, or doctor.
Chatbots vs. agents — the shift that changes everything
Until recently, AI was a chatbot: you talk, it talks back, you do the work. The big shift of 2025–2026 is toward agents: AI that can take actions — search the web, read and write files, use your calendar, run programs, browse websites, execute multi-step plans — and keep going until a task is done.
The same underlying model behaves completely differently depending on what it's connected to: Claude in a browser tab with no connections is a very smart text box; Claude connected to your Gmail, Calendar, and Notion via MCP is an assistant that can actually check and update things; Claude Code or Codex on your computer is an agent that can organize thousands of files or build you a working tool. This course walks you up that ladder deliberately: chat skills first, then agents, then connections, then full systems.
How to run it
- Tested the fluency-vs-accuracy gap. You verified at least one factual claim (a price, date, or number) against ground truth you independently knew.
- Checked for real-time awareness. You confirmed whether the model actually searched the web versus answering from training memory on a time-sensitive question.
- Practiced self-critique prompting. You asked the model what in its own answer deserved double-checking, and recorded a specific response.
- Compared modes on a real question. You ran the same multi-step question in both default and thinking/reasoning mode and noted a concrete difference.
- Applied the trust triage. You can name which category (brainstorm, summary, fact, publish-grade) your test question fell into and treated it accordingly.
In the field
A small-business owner asks ChatGPT for the current price of a competitor's software plan. The model answers confidently with a number that's six months stale, no citation attached. When she asks "search the web and confirm this price with a source," it returns a different, correct number with a link — a concrete demonstration that unprompted answers on volatile facts need a verification step, exactly as Module 1 warns.
When not to use it
This diagnostic approach is overkill for low-stakes, throwaway questions — if you're just brainstorming birthday party themes or rewording a sentence, running a full verification ritual wastes time for no benefit. The trust-triage habit from this module should scale with stakes: reserve source-checking and self-critique prompts for facts, numbers, and anything that will be published, filed, or acted on, not for every single AI interaction.
Pitfalls and takeaways
- Trusting confident-sounding answers on specific facts, numbers, dates, or citations without verifying
- Letting one chat run for dozens of turns until it gets confused instead of starting fresh
- Assuming the model knows today's news or prices without it actually searching the web
- Using a fast/light model for complex reasoning tasks that deserve the flagship model or a thinking mode
- Filing, signing, publishing, or paying based on an unverified AI answer
- LLMs predict text; they are fluent first and accurate second — hallucination is a property, not a bug
- One chat = one task; long messy conversations degrade quality
- Use the strongest model and reasoning modes for anything that matters
- Verify specific facts, numbers, and anything with real-world consequences
- The frontier has moved from chatbots (talk) to agents (act) — that's where the leverage is
Do the work
Goal: Run three real diagnostic conversations with an LLM to directly observe fluency-vs-accuracy, verification habits, and the chatbot-vs-agent distinction described in this module. (25 min)
- Test the context-window analogy. Ask the model: "Explain what a context window is, using an analogy from [your job/industry]." Read the analogy and judge whether it actually maps onto your work or is generic filler.
- Test real-time knowledge and verify it. Ask for the current price of a specific product or service you already know the real price of. Note whether it searched the web (cite a source/date) or answered from memory, then check if it's actually correct.
- Ask it to flag its own weak spots. In the same chat, ask: "What in your previous answer should I double-check, and why?" Write down what it flags.
- Run the same question through a reasoning/thinking mode. Pick a multi-step question relevant to your work (a planning or comparison question) and run it once in default mode and once in a thinking/extended-reasoning mode. Compare the two answers.
- Log your three observations. Write one sentence each on: how good the analogy was, whether the price answer was accurate and sourced, and what the self-critique revealed.
Deliverable: A short log (3-5 sentences) documenting what you learned about the model's fluency vs. accuracy, its real-time knowledge limits, and its ability to self-critique, based on three real tests.
Sources
- OpenAI, "GPT-4 Technical Report," 2023 (openai.com/research/gpt-4)
- Anthropic, "Core Views on AI Safety," anthropic.com
- Ji et al., "Survey of Hallucination in Natural Language Generation," ACM Computing Surveys, 2023
- Google DeepMind, "Gemini: A Family of Highly Capable Multimodal Models," 2023