Course: AI Capabilities and Limitations
Mirrors: Anthropic Academy — AI Capabilities and Limitations · https://anthropic.skilljar.com/ai-capabilities-and-limitations Audience: Everyone. No technical background needed — a mental model, not math. · Time: ~60 min + project Prereqs: Helpful to have met Claude first (claude-101). · Backing notes: claude-overview, model-family, anthropic-safety Project: p03-ai-fluency-delegation-audit
To use AI well, you need a realistic picture of what it can and can't do. This course builds an accurate, jargon-light mental model: how large language models work at a high level, where they genuinely shine, where they reliably fail, and how to match tasks to capabilities. It's the foundation for the Discernment competency in the 4D Framework — you can't judge AI output without knowing where it tends to break.
Learning objectives
After this course you can:
- Explain, in plain terms, how an LLM produces text (next-token prediction over patterns learned from training data).
- List genuine strengths: language fluency, summarization, reasoning over provided text, synthesis, coding, translation.
- List real limits: hallucination, knowledge cutoff, weak exact math/counting, no persistent memory, phrasing sensitivity, bias.
- Explain the context window and why it matters.
- Decide whether a task is appropriate or inappropriate for AI, and why human verification and good inputs matter.
- Connect all of this back to Discernment in the 4D Framework.
Module 1 — How LLMs actually work (high level)
🎞 Frame 1 · A very good next-word guesser · ⏱ ~3 min
🎬 Scene — A sentence appears word by word: "The capital of France is ___." The model fills in "Paris" — by predicting the most likely next piece of text.
🧠 Concept — A large language model is, at heart, a next-token prediction engine. Given the text so far, it predicts the next chunk ("token"), then the next, building a response one piece at a time. It has no beliefs or database lookups — it produces statistically likely continuations of patterns it learned.
🖼 On screen
Input: "Roses are red, violets are ___"
Model: predicts → "blue" (because that pattern is overwhelmingly common)
⚠️ Gotcha — "Most likely next word" is usually right and sometimes confidently wrong. That single fact explains most limitations in this course.
✅ Checkpoint — In one sentence, what is an LLM fundamentally doing when it answers?
🎞 Frame 2 · Trained on text, frozen in time · ⏱ ~3 min
🎬 Scene — A vast library of text flows into the model during training; then the doors close. Today's newspaper never makes it in.
🧠 Concept — The model learns patterns from a huge body of training text, then training stops. After that it has a knowledge cutoff — it doesn't know events after that date and has no live web access unless a tool explicitly gives it one. Its "knowledge" is baked-in patterns, not a current, queryable database. (Models and their cutoffs: model-family.)
🖼 On screen
Training text (up to a cutoff date) → patterns baked into the model
│
No live knowledge ──────────────────────┘ (unless a tool fetches it)
✅ Checkpoint — Why might an LLM confidently get yesterday's news wrong?
🎞 Frame 3 · The context window · ⏱ ~3 min
🎬 Scene — A sliding window frames a stretch of text — the conversation, an uploaded doc — and everything inside it is what the model can "see" right now.
🧠 Concept — The context window is the amount of text (your prompt + uploads + the conversation so far) the model can consider at once. It's the model's working memory for this request. Text that doesn't fit, or that ended a previous session, isn't available. This is why uploading a source document is so powerful — it puts the facts inside the window. (See claude-overview for Claude's large context window.)
🖼 On screen
[ system instructions | your prompt | uploaded files | chat history ]
└──────────────── the context window (what the model can use now) ───┘
Outside the window → invisible to the model.
✅ Checkpoint — Why does putting a document in the context window reduce made-up answers?
🎞 Frame 4 · No memory between sessions · ⏱ ~2 min
🎬 Scene — A new chat opens the next day; the model doesn't recall yesterday's conversation unless something carries it forward.
🧠 Concept — By default an LLM has no persistent memory across sessions. Each conversation starts fresh; it only "remembers" what's in the current context window (or what a feature like Projects or a memory tool deliberately re-supplies). Continuity is engineered, not innate.
🖼 On screen
Session 1: you explain your project in detail.
Session 2 (new chat): the model knows none of it —
unless you re-provide it (e.g., a Project's knowledge files).
✅ Checkpoint — How can you give a model "memory" of context from a previous day?
Module 2 — Genuine strengths
🎞 Frame 5 · Language fluency and rewriting · ⏱ ~2 min
🎬 Scene — A clumsy paragraph becomes crisp; the same idea is re-cast as a tweet, an email, and a poem.
🧠 Concept — Because LLMs are trained on enormous amounts of language, they are genuinely excellent at producing and transforming text: drafting, rewriting, changing tone, adjusting reading level, and adapting one idea to many formats. This is their home turf.
🖼 On screen
| Great at | Example |
|---|---|
| Drafting | "Write a friendly out-of-office reply." |
| Rewriting | "Make this paragraph plainer." |
| Re-formatting | "Turn these notes into a bulleted agenda." |
✅ Checkpoint — Name two language-transformation tasks an LLM does reliably well.
🎞 Frame 6 · Summarizing and reasoning over text you give it · ⏱ ~3 min
🎬 Scene — A 30-page contract is dropped in; back comes a clean summary with the clauses that matter, grounded in the document.
🧠 Concept — LLMs excel at summarization and at reasoning over provided text — pulling out key points, answering questions about a document, comparing passages. When the source is in the context window, the model is working from real material rather than baked-in patterns, which makes it far more trustworthy.
🖼 On screen
Strong pattern: give the AI the text → ask about THAT text
"Summarize the attached report in 5 bullets."
"Which section discusses refunds? Quote it."
🔗 This is exactly why the 4D Framework leans on product description + uploading sources — see ai-fluency-framework-foundations.
✅ Checkpoint — Why is "answer from this document" more reliable than "answer from memory"?
🎞 Frame 7 · Synthesis, coding, and translation · ⏱ ~3 min
🎬 Scene — The model weaves three sources into one brief, writes a working script, and translates a message into Spanish — all in seconds.
🧠 Concept — Beyond rewriting, LLMs are strong at synthesis (combining ideas/sources into something coherent), coding (generating, explaining, and debugging code), and translation between languages. These build on the same pattern-fluency, applied to structured domains.
🖼 On screen
| Strength | Use it for |
|---|---|
| Synthesis | "Combine these 3 reviews into one summary of themes." |
| Coding | "Write a Python script to rename these files." |
| Translation | "Translate this email into formal Japanese." |
⚠️ Gotcha — Strong ≠ infallible: generated code can have bugs and translations can miss nuance. Strengths still need discernment.
✅ Checkpoint — Give one synthesis task and one coding task you'd trust an LLM to draft.
Module 3 — Real limitations
🎞 Frame 8 · Hallucination / confabulation · ⏱ ~3 min
🎬 Scene — Asked for a citation, the model produces a perfectly formatted reference — to a paper that doesn't exist.
🧠 Concept — Because it predicts likely text, an LLM can hallucinate (also called confabulate): produce fluent, confident, plausible-sounding content that is simply false — invented facts, fake quotes, nonexistent citations. There's no built-in "I'm unsure" flag, so fluency cannot be read as truth.
🖼 On screen
Risk zones for hallucination:
• Specific facts, names, dates, statistics
• Citations and quotes
• Anything outside the training data or after the cutoff
✅ Checkpoint — Why does confident, polished phrasing tell you nothing about accuracy?
🎞 Frame 9 · Math, counting, and character-level tasks · ⏱ ~3 min
🎬 Scene — "How many 'r's are in strawberry?" trips the model up; a long multiplication comes out slightly wrong.
🧠 Concept — LLMs are weak at exact arithmetic, precise counting, and character-level tasks (counting letters, reversing strings) because they operate on tokens and patterns, not on a calculator or a literal character-by-character view. They approximate. For exact numbers, use a real tool or have the model call one.
🖼 On screen
Shaky: "What is 48,271 × 9,933?"
"How many words are in this paragraph?"
Better: let it write/run code, or verify with a calculator.
✅ Checkpoint — Why is exact counting surprisingly hard for an LLM?
🎞 Frame 10 · Knowledge cutoff and no live data · ⏱ ~2 min
🎬 Scene — Asked about a product released last month, the model either says it doesn't know or — worse — guesses.
🧠 Concept — Revisiting Frame 2 as a limit: the model doesn't know recent events and has no live data without a tool. Treat anything time-sensitive (news, prices, current people-in-roles, "latest version") as suspect unless you supply the current facts.
🖼 On screen
Time-sensitive question?
→ Provide the current info yourself, OR
→ Use a tool/feature that fetches live data, OR
→ Verify before trusting.
✅ Checkpoint — Name a category of question you should never trust to memory alone.
🎞 Frame 11 · Phrasing sensitivity and bias · ⏱ ~3 min
🎬 Scene — Two near-identical prompts get noticeably different answers; another answer quietly reflects a stereotype from its training data.
🧠 Concept — LLMs are sensitive to phrasing — small wording changes can shift the output — and they can reflect biases present in their training data. Patterns in equals patterns out. This is why clear inputs and critical review both matter. (Anthropic's mitigations and safety approach: anthropic-safety.)
🖼 On screen
Phrasing: "List risks" vs "Are there any risks?" → different depth.
Bias: outputs can echo skews in training text → review for fairness.
✅ Checkpoint — Give one reason the same question, worded two ways, might get different answers.
Module 4 — Matching tasks to capabilities
🎞 Frame 12 · Appropriate vs. inappropriate use · ⏱ ~3 min
🎬 Scene — A sorting table: tasks slide into "great fit" or "wrong tool" based on the strengths and limits you just learned.
🧠 Concept — Fluency means matching the task to the capability. Lean on AI where its strengths apply (language, summarizing provided text, drafting, synthesis); be cautious or avoid it where its limits bite (exact math, current facts from memory, high-stakes truth with no source).
🖼 On screen
| Appropriate (plays to strengths) | Inappropriate without help |
|---|---|
| Draft, rewrite, summarize a doc | Cite exact statistics from memory |
| Brainstorm, synthesize ideas | Do precise arithmetic unaided |
| Translate, explain code | Report today's news from memory |
| Reason over text you provide | Be the sole authority on a high-stakes fact |
✅ Checkpoint — Sort two of your own tasks into "appropriate" vs. "needs verification/avoid."
🎞 Frame 13 · Good inputs in, better outputs out · ⏱ ~2 min
🎬 Scene — A vague ask yields mush; the same ask with context, a source document, and a clear format yields gold.
🧠 Concept — Many "AI failures" are really input failures. Provide context, supply the source material, specify the format — put what the model needs inside the context window. Good inputs both improve quality and shrink the room for hallucination. (Craft: prompt-engineering-basics.)
🖼 On screen
Weak input → guesses, generic, more hallucination.
Rich input → grounded, specific, easier to verify.
(context + source doc + clear format)
✅ Checkpoint — Name two things you can add to an input to make the output more trustworthy.
🎞 Frame 14 · Verify — and tie back to Discernment · ⏱ ~3 min
🎬 Scene — Recap loop: strengths, limits, context window. Then the 4D word Discernment lights up — the habit of checking the output, the reasoning, and the behavior.
🧠 Concept — Knowing capabilities and limits is why the 4D Framework demands Discernment. You verify facts, numbers, and citations (product discernment), check the reasoning (process discernment), and watch for inappropriate confidence or bias (performance discernment). Human verification isn't optional polish — it's how you use a powerful, fallible tool safely.
🖼 On screen
Capabilities & Limits ──drive──▶ Discernment (4D Framework)
hallucination? → verify facts/citations (product)
bad reasoning? → ask it to show its work (process)
overconfident? → check stance & bias (performance)
🔗 Full competency: ai-fluency-framework-foundations.
✅ Checkpoint — Without looking, map three limits from this course to the discernment check that catches each.
🛠 Project
Complete p03-ai-fluency-delegation-audit — The Delegation Audit. As you audit your real tasks, use this course's strengths/limits map to decide which tasks are appropriate to delegate, and write down the verification (Discernment) step each AI output needs before you act on it.
🧪 Self-check quiz
- In one sentence, what is an LLM fundamentally doing when it generates text?
- What is a "knowledge cutoff," and what does it imply about recent events?
- Define the context window in your own words.
- List three genuine strengths of LLMs.
- List three real limitations of LLMs.
- Why are LLMs surprisingly bad at counting letters or doing exact arithmetic?
- What is hallucination (confabulation), and why can't you detect it from fluency alone?
- How do this course's capabilities and limits connect to Discernment in the 4D Framework?
- Predicting the next token/chunk of text based on patterns learned from training data. 2. The date training data stops; the model doesn't know events after it and has no live web unless a tool provides one. 3. The amount of text (prompt + uploads + conversation) the model can consider at once — its working memory for this request. 4. Any three: language fluency/rewriting, summarization, reasoning over provided text, synthesis, coding, translation. 5. Any three: hallucination, knowledge cutoff/no live data, weak exact math/counting, no persistent memory across sessions, phrasing sensitivity, bias. 6. It works over tokens and patterns, not a literal character view or a calculator, so it approximates. 7. Producing fluent, confident, false content; fluency reflects likely phrasing, not truth, and there's no built-in uncertainty flag. 8. They're the reason discernment is required — you verify output (product), reasoning (process), and behavior (performance) precisely because of these limits.
🎓 Certificate criteria
You've "passed" AI Capabilities and Limitations when you can:
- Explain next-token prediction, knowledge cutoff, and the context window in plain language.
- List the core strengths and the core limitations from memory.
- Sort a set of tasks into appropriate vs. inappropriate AI use and justify each.
- State, for a given AI output, what you'd verify and why (Discernment).
- Complete p03-ai-fluency-delegation-audit with a verification step recorded per delegated task.
Tick this course off in progress and record the date you earned Anthropic's official certificate.
🔗 Sources & deeper notes
- Official course: https://anthropic.skilljar.com/ai-capabilities-and-limitations
- Vault notes: claude-overview, model-family, anthropic-safety, prompt-engineering-basics
- Foundation for: Discernment in ai-fluency-framework-foundations
- Pairs with: ai-fluency-for-students · ai-fluency-for-educators
- Previous course: ai-fluency-framework-foundations · Next track: track-2-effective-prompting