Large Language Models (LLMs) — Foundations Lesson 2

Scenario

You've been assigned to use ChatGPT to help with your workload. Your manager says, "It's an LLM — it should be able to handle anything." But you realize you don't actually know what makes an LLM different from other AI. You've heard it mentioned that newer models are "smarter," but smarter at what? Does it matter which LLM you use? What are you actually talking to when you type into ChatGPT?

---

Learning Objectives

By the end of this lesson, you will be able to:

1. Define what an LLM is and how it's different from other AI systems

2. Understand the key characteristics that make LLMs useful (and limited)

3. Recognize the differences between popular LLMs (ChatGPT, Claude, Gemini, etc.)

4. Explain why context matters in how LLMs generate responses

5. Know when to choose different LLMs for different tasks

---

Think Before You Prompt

Before you start:

What's the difference between "AI" and "LLM"?

Does it matter which LLM I use?

What makes one LLM "better" than another?

How much does an LLM actually remember about previous conversations?

Why do LLMs sometimes sound confident when they're completely wrong?

---

What is an LLM?

Large Language Model (LLM) = An AI system trained on massive amounts of text to predict and generate language.

"Large" refers to the scale — billions of parameters (think: dial settings) that let it recognize subtle patterns in language. "Language Model" means it predicts what word comes next based on everything before it.

How LLMs Work (The Process)

1. Training Data: The LLM learns from billions of words (books, websites, articles, code)

2. Pattern Recognition: It learns statistical patterns (e.g., "after 'good morning,' people usually say something positive")

3. Token Prediction: When you write something, the LLM predicts the next word, then the next, building a response one piece at a time

4. Output: The response you see is generated token-by-token (often too fast for you to notice)

Critical understanding: The LLM is not retrieving information from memory. It's generating text based on patterns. This is why it can sound right and be completely wrong.

Knowledge Cutoff

Every LLM has a knowledge cutoff — a date after which it doesn't have training data.

ChatGPT (GPT-4): April 2024

Claude 3.5 (Sonnet): April 2024

Google Gemini: Varies (some have real-time access)

Why this matters: If you ask about events after the cutoff date, the LLM will either say "I don't know" or hallucinate. There's no way for it to access current information unless it's specifically designed to (like Claude with web access).

---

Key Characteristics of LLMs

What LLMs Are Good At

✅ **Pattern recognition across language** — Understanding relationships between words and concepts

✅ **Generating coherent text** — Writing that flows naturally and makes grammatical sense

✅ **Adapting tone and style** — Responding in different voices (formal, casual, technical, friendly)

✅ **Handling multiple languages** — Many LLMs work across dozens of languages

✅ **Few-shot learning** — Understanding patterns from a few examples you give it

✅ **Multi-turn conversation** — Remembering context across multiple exchanges (within that conversation)

What LLMs Struggle With

❌ **Math & precise calculation** — LLMs generate plausible-sounding numbers, not accurate math

❌ **Logical reasoning** — "If A then B" logic chains can break down

❌ **Current events** — No knowledge past training cutoff

❌ **Accessing your data** — Can't read your files, emails, or internal systems

❌ **Factual accuracy** — Will confidently state false information (this is called "hallucination")

❌ **Rare or specialized knowledge** — If something wasn't heavily represented in training data, the LLM may not know it

❌ **True creativity** — It remixes existing patterns, not genuinely invent

---

LLM Differences: Which One Should You Use?

Popular LLMs in 2024+

ChatGPT (OpenAI)

Strengths: Well-known, good at writing, handles code decently

Weaknesses: Older models are weaker; newer ones (GPT-4) are behind a paywall

Best for: General writing, brainstorming, quick answers

Claude (Anthropic)

Strengths: Strong reasoning, good at complex tasks, thoughtful outputs

Weaknesses: Slower than some competitors

Best for: Analysis, detailed work, handling sensitive/nuanced topics

Google Gemini

Strengths: Multimodal (text, images, video), real-time web access

Weaknesses: Younger, less proven track record

Best for: Image analysis, current events, visual content

Open-source Options (Llama, Mistral, etc.)

Strengths: Privacy, no external dependency, cheaper to run

Weaknesses: Smaller models may be less capable; requires more technical setup

Best for: Sensitive data, specialized company deployments

The Truth About "Smarter"

When someone says a new model is "smarter," they usually mean:

Better reasoning on complex tasks

Fewer hallucinations

Better at following detailed instructions

Faster responses

Broader knowledge (larger training data)

But "better" is task-dependent. Claude might be better for analysis; ChatGPT might be better for creative writing. There's no universal "best" LLM.

---

Context Window: Why It Matters

Every LLM has a context window — how much text it can "see" at once.

Older models: 2,000-4,000 tokens (roughly 1,500-3,000 words)

Modern models: 100,000+ tokens (roughly 75,000+ words)

Why this matters: If you paste a 50-page document but your LLM's context window is only 10,000 tokens, it might miss important information in pages it "forgot."

In practice: For most administrative work, context window isn't a constraint. But if you're asking an LLM to analyze a full contract or synthesize multiple lengthy documents, context window matters.

---

Mission: Exploring Different LLMs

The Task

You'll test 2-3 different LLMs (free versions are fine) with the same prompt and compare results.

The Prompt You'll Use:

`

Imagine you're an administrative assistant at a tech company.

A manager needs a 2-paragraph email to external clients explaining

a 2-week project delay due to resource constraints.

Write the email in a professional but warm tone.

`

Document Your Findings:

For each LLM you test:

1. Which LLM? (ChatGPT, Claude, Gemini, etc.)

2. How did it respond? (Copy the first paragraph)

3. Tone assessment: Did it match "professional but warm"?

4. What worked? What did the LLM do well?

5. What didn't work? What could be better?

---

Deliverables

Create a simple comparison table:

`

| LLM | Tone Match? | Strengths | Weaknesses |

|-----|-----------|-----------|-----------|

| | | | |

`

Add a paragraph: "Based on this test, I'd use [LLM name] for [task type] because [reason]."

This isn't about finding the "best" LLM — it's about understanding that different LLMs have different strengths. You'll choose based on the task.

---

AI Coach: Tokens, Not Words

Here's what confuses most people: LLMs think in tokens, not words.

A token is roughly 4 characters or 0.75 words. When an LLM generates a response, it's producing tokens one at a time. This is why:

1. Responses can be inconsistent — An LLM doesn't plan the whole response; it predicts the next token. Sometimes this leads to rambling or contradictions.

2. Length matters — Asking for "a short email" is less precise than "2 paragraphs, 150 words total." The LLM needs clear length guidance.

3. Context window is a real limit — If you exceed the token limit, older information gets "forgotten."

Key insight: Understanding tokens helps you write better prompts. If an LLM's response is too long or repetitive, you're not dealing with a "dumb" AI — you're dealing with an AI that didn't have a clear stopping point.

---

Reflection: What Type of Task Do You Want to Delegate?

Think about your current work:

1. What task takes you the most time?

2. Does it fit LLM strengths (writing, adaptation, summarization, brainstorming)?

3. Or does it require LLM weaknesses (math, real-time data, internal knowledge)?

4. Based on what you've learned, which LLM would you try first?

Write 3-4 sentences: What's one task you're now confident you could delegate to an LLM? Why?

---

Portfolio Check

Like Lesson 1, this is a foundation lesson. The portfolio piece comes when you use what you've learned. But here's the thinking you're building:

Portfolio principle: Any AI output in your portfolio must include a note on:

Which LLM you used

Why you chose that LLM

How you verified the output (Lesson 4)

Right now, you're just learning to think about LLM choice intentionally.

---

Bonus Challenge

Go technical: LLMs are built on transformer architecture. Watch a 10-minute explainer on transformers (YouTube: "How Transformers Work"). You don't need to understand the math, but understanding that LLMs process text in parallel chunks (not sequentially) explains why they can miss context and generate plausible-sounding nonsense.

---

Key Takeaways

LLMs are trained on massive text datasets to predict the next word

Different LLMs have different strengths; choose based on task, not on "best"

Every LLM has a knowledge cutoff and context window

LLMs generate text token-by-token, which is why they can sound confident while being wrong

Understanding LLM limitations helps you verify output and design better prompts

Next: Lesson 3 teaches How Prompting Works — the specific techniques to get better results from LLMs.