Introduction to the course

This course explains how large language models turn a prompt into a response, how training shapes their behavior, and how developers use them in applications. Text generation, code explanation, and humor provide the first examples. Later lessons cover retrieval, tools, and ethical considerations.

Large language models let us ask for work in ordinary language: explain a program, draft a paragraph, or continue a conversation. Using them well requires more than knowing which API to call. You need to understand how a model produces an answer and how to judge that answer.

The course develops that understanding from first principles, so that practical choices about prompts, applications, and responsible use have a technical basis.

You will work through four connected questions: how tokens, embeddings, and attention represent language; how a prompt passes through the model; how prompting, retrieval-augmented generation (RAG), and function calling support an application; and how to choose among these techniques while considering their ethical implications.

• Explain why tokens, embeddings, and attention are needed.

• Follow a prompt from input to output.

• Use prompting, RAG, and function calling to address different application needs.

• Evaluate a technique’s tradeoffs before adopting it.

The aim is to make these choices explainable. When an application fails, you should be able to ask which part of the process needs attention instead of treating the model as an unexplained source of answers.

A glimpse of what’s possible

The next lesson defines a large language model. The examples here introduce its capabilities through a shared idea: a model learns patterns in data and uses them to produce plausible outputs.

Use the examples to compare the task requested in a prompt with the response the model produces.

Generating creative text

LLMs can generate both creative and structured text. Training on material such as books, articles, and poems exposes a model to patterns of rhythm, style, and structure that it can use in a new response.

For example, a request for a poem about the ocean can lead to imagery about waves, breath, and rhythm. The model combines learned patterns of language; it does not need to experience the ocean to produce the following verse.

The ocean’s breath, a gentle sigh,

A vast expanse beneath the sky,

Waves that dance with endless grace,

A rhythm time cannot erase.

Writing and explaining code

The same approach applies to programming languages. Training on code, including material from repositories such as GitHub, gives a model examples of syntax, program structure, and common patterns in Python, JavaScript, and other languages.

A model can use those patterns to generate a function from a description or explain a block of code. In the following example, compare the short request with the behavior documented in the generated function.

Prompt: “Write a Python function that checks if a given string is a palindrome.”

import re

def is_palindrome(s: str) -> bool:
    """
    Checks if a given string is a palindrome, ignoring case and
    characters other than ASCII letters and digits.

    A palindrome is a word, phrase, or sequence that reads the same backward as
    forward.

    Args:
        s: The input string to check.

    Returns:
        True if the string is a palindrome, False otherwise.
    """
    # Normalize the string: keep ASCII letters/digits and convert to lowercase.
    # The regex pattern '[^a-zA-Z0-9]' matches any character that is not a
    # letter (a-z, A-Z) or a digit (0-9).
    normalized_s = re.sub(r'[^a-zA-Z0-9]', '', s).lower()

    # Compare the normalized string with its reverse.
    # The slice [::-1] creates a reversed copy of the string.
    return normalized_s == normalized_s[::-1]

# --- Example Usage ---
if __name__ == "__main__":
    test_strings = [
        "racecar",
        "A man, a plan, a canal: Panama",
        "hello world",
        "No 'x' in Nixon",
        "12321",
        "not a palindrome",
        "Was it a car or a cat I saw?"
    ]

    print("Checking for palindromes:")
    for text in test_strings:
        result = "is" if is_palindrome(text) else "is not"
        print(f"'{text}' {result} a palindrome.")

Understanding nuance and humor

LLMs can also generate jokes by combining familiar patterns such as puns, misdirection, and absurdity. The example below uses the ambiguity of "space" to connect a relationship joke with computing.

Prompt: “Tell me a joke about AI.”

Response: Why did the AI break up with the computer? It said it needed more space.

Try the prompts yourself

Try the following prompts in an LLM environment available to you. Observe the response as well as whether it satisfies the request.

Each prompt tests a different behavior:

1. Test its creativity: Ask it to “Write a haiku about a coffee cup.” Notice the structure it follows.

2. Test its knowledge: Ask it, “Explain the concept of recursion in a simple way.” Does it use an analogy?

3. Test its conversational ability: Start with a question, then ask a follow-up question that refers to its previous answer. Does it maintain context?

Model-generated responses can be inaccurate, biased, or offensive. Treat them as material to examine rather than as statements you can accept without review.

Intended audience

The course is for readers with technical curiosity who want to understand how language models work. The examples are practical, but the emphasis is on developing an explanation you can apply across models and tools.

The intended readers include:

• Software developers integrating LLMs into applications.

• Data scientists and analysts studying model mechanics.

• Product managers and technical leaders evaluating AI applications.

• Students and researchers studying language models.

• Hobbyists with a Python background.

How this course is structured

The first part follows five stages. These establish the LLM mechanics used again in the later generative AI and system examples:

1. The foundations define an LLM and introduce the ethical questions that accompany its use.

2. The inference lessons follow a prompt through the model to its generated response.

3. The training lessons explain pretraining and alignment at a conceptual level.

4. The application lessons introduce prompting, retrieval, and tools.

5. The final LLM overview lessons discuss emerging directions and further study.

Prerequisites and setup

The only technical prerequisite is a working knowledge of Python. You do not need any prior experience with machine learning or AI. We expect you to be comfortable with:

• Writing functions and using variables.

• Working with basic data structures, especially lists and dictionaries.

• Installing and importing third-party libraries using a tool like pip.

You do not need a background in advanced mathematics or machine learning frameworks like PyTorch or TensorFlow. Our code explorations will use simple, high-level libraries to illustrate concepts.

The next lesson starts with the model’s basic task: predicting how a sequence of text can continue.