# LLM as Study Partner

Using a language model as an interactive tutor — explaining, questioning and generating practice — rather than banning it from learning.

**Rests on:** Chat Format Templates, Conversational Agents

*Business, Career and Human Factors · AI and Society*


## Why learn this

This concept changes how you study from this point forward. Instead of memorising facts on your own, you will learn to use a language model — the same kind of technology behind ChatGPT — as a personal tutor that explains things, questions you, and generates practice problems. This unlocks everything else in this course: the mathematics of numbers and patterns, testing whether a result is real or just chance, and the mechanics behind artificial intelligence. The skill you build here — verifying what a model tells you against trusted sources — is exactly the skill you need for every later topic, because every later topic will invite you to ask the model for help. Master this now, and every future page becomes faster and deeper.


## The intuition

Imagine you are learning to cook a new dish. You have a recipe book, but the recipe assumes you know what 'julienne' means, and it skips steps. A good cook standing next to you would watch you chop, point out that your knife grip is wrong, ask you what you would do next, and give you a practice vegetable to try again. That cook is what an LLM study partner is like. You ask it to explain the step you do not understand, and it answers in plain words. You ask it to test you, and it gives you a question and checks your answer. It never gets tired, never judges, and it has read an enormous number of books. But like any cook who learned from books rather than from a kitchen, it sometimes tells you confidently how to do something that would ruin the dish. So the rule is: use the cook to practise and to clarify, but check the recipe book for anything that matters. The cook is a partner in your learning, not the authority on it. The point of having this partner is not to make learning easier by doing it for you — it is to make learning harder in a useful way, by forcing you to explain, to answer, and to practise, all with someone responding to each thing you say.


## An analogy

Think of an apprenticeship. In a traditional apprenticeship, a young craftsperson learns by working alongside a master. The master demonstrates a technique, then hands the apprentice the tool and says 'try it'. The apprentice tries, gets it wrong, and the master points at the exact moment of the mistake: 'You released the chisel there — that is why the cut jumped.' The apprentice tries again with the correction. This cycle — demonstrate, attempt, diagnose, correct — is the heart of learning. An LLM study partner runs the same cycle, but it plays the master imperfectly. It can demonstrate an idea in many different ways, which a human master sometimes cannot. It can generate practice problems by the hundred, each slightly different, which a human master could not do on the spot. And it can diagnose your answer, zooming in on the specific line of your reasoning where you went wrong. But where the analogy breaks is crucial: the human master has physical knowledge and has made mistakes themselves, so they know when you are about to cut yourself. The LLM has no body, no hands, and no memory of making mistakes. It cannot see you struggling, and it cannot know for certain whether what it is telling you is true. It will sometimes state a falsehood with complete confidence. So the apprentice in this relationship has a new duty that a traditional apprentice did not have: verify everything that matters against a trusted source. The LLM is the practice partner, not the master. The books are the master. This difference is not a flaw in the model — it is a property of how it works. It predicts the next word based on patterns in its training data, so it can generate a sentence that sounds true without having checked it against a fact database.


## Definition

Using a language model as a study partner means treating it as an interactive tutor that explains concepts, asks you questions, and generates practice material, while you take responsibility for verifying everything it says against trusted sources.


## How it connects

You have not studied anything in this course yet, so this is your first concept. But you have almost certainly used a search engine, and you have almost certainly used a calculator. A search engine gives you a list of links; the study partner gives you a direct answer. A calculator computes a number; the study partner computes a sentence. The skill you build here — treating a generated text as a hypothesis to be checked, not as fact to be accepted — is the same skill you will use when you evaluate whether a statistic is trustworthy, and in understanding how numbers are summarised when you ask the model to condense a dataset and then check its arithmetic against your own. Two key points that this page is built around: explicitly building the model into teaching beats pretending students will not use it; and verification is the skill being taught alongside the subject. Both are reflected in how you will work.


## From scratch, in Python

```python
students = [
    "Ananya",
    "Rohan",
    "Priya"
]

# A list of questions the model might ask, stored as a list of strings.
questions = [
    "What does the p-value mean in your own words?",
    "Why do we use a sample instead of the whole population?",
    "What is the difference between mean and median?"
]

# A dictionary that maps each question to a list of example answers.
# A dictionary looks things up by name, not by position.
example_answers = {
    "What does the p-value mean in your own words?": [
        "The probability of getting the observed data if the null hypothesis is true",
        "The chance that my result is a fluke",
        "The probability that the alternative hypothesis is true"
    ],
    "Why do we use a sample instead of the whole population?": [
        "Because it is cheaper and faster",
        "Because the population is too large to measure",
        "Because samples are always accurate"
    ],
    "What is the difference between mean and median?": [
        "The mean is the average, the median is the middle value",
        "The mean is always larger than the median",
        "They are the same thing"
    ]
}

# A list of questions where the correct answer is the first one.
correct_first_question = "What does the p-value mean in your own words?"

# A loop that goes through each question in the questions list.
for question in questions:
    print("Question:", question)
    # Get the list of example answers for this question.
    answers = example_answers[question]
    # Go through each answer and print it with a number.
    for index, answer in enumerate(answers):
        print(f"  {index + 1}) {answer}")
    print()
```


## What the code does

First, we make a list of students. A list keeps things in order and can be changed. Here it holds three names, as strings — words in quotes. Then we make a list of questions. These are the questions the tutor might ask. Next, we make a dictionary. A dictionary looks things up by a name (called a key) rather than by position. We map each question to a list of possible answers. The first answer in each list is the correct one (for teaching purposes); the others are plausible but wrong. Then we start a loop. A loop repeats a block of code once for each item in a collection. The line `for question in questions:` means: take the first question, run the block, then take the second, and so on. Inside the loop, we print the question. Then we look up the list of answers in the dictionary using `example_answers[question]`. We print each answer with a number, using another loop and `enumerate`, which gives each item a number starting from 0. The `f"..."` is an f-string — a way to build a sentence with variables inside it. The `{index + 1}` puts the number, and we add 1 so it shows 1, 2, 3 rather than 0, 1, 2. Run this and you see the tutor's script. A real study partner does exactly this, but with an LLM generating the questions and answers dynamically rather than a static list.


## Common misconceptions

**The model knows everything and is always right** — The model reads the whole internet, so if it says something, it is true.

The model does not read the internet at query time. It was trained on text, and it generates the most plausible next word, not a checked fact. It can be confidently wrong, especially on statistics details. In fact: The model is a language generator. Treat every claim as a first draft and verify it against a trusted book or a primary source.

**The model is a replacement for my own thinking** — Why should I solve this problem myself? The model can just give me the answer and I will remember it.

Research and ordinary experience both show that being handed an answer does not build the mental connections you get from arriving at it yourself. The model can generate a correct-sounding sentence, but your brain has not practised the path to it. In fact: Use the model to quiz you, to ask you 'why', and to ask you to explain back. That is what builds understanding.

**Using AI is cheating** — My teacher said students should not use AI, so any use of it is cheating.

The library notes and the book 'Statistics and Data Foundations for AI' explicitly build the model in as a study partner. The distinction is not whether AI is used, but whether the learner is doing the thinking. A model that answers for you is cheating only if your goal is to demonstrate your own skill; a model that questions you and checks your answers is a workout. In fact: Use the model as a coach. Let it ask the questions; you do the answering.

**The model can assess my answer accurately every time** — I will write something and the model will tell me if it is right or wrong, and it will be right about that.

The model judges plausibility, not truth. It can praise a vague answer or reject a slightly unconventional but correct one. It has no ground truth. In fact: For exercises, the model's judgement is a signal, not a verdict. Cross-check with the textbook solutions or a teacher.

**The model will know what I know and adapt perfectly** — I can ask the model for a practice question and it will be exactly at my level because it knows me.

The model has no memory of your past unless the app stores it; by default it sees only the current conversation. It might start too easy or too hard. In fact: Tell the model where you are: 'I have just learned the difference between mean and median, quiz me at a beginner level.'


## In short

An LLM study partner is a tutor that explains, quizzes and generates practice — but you must verify everything it says. Build it into your study deliberately rather than pretending it does not exist. The model is a practice partner, not the authority. The skill to master is verification.


## Where this is used

This concept is used in teaching and learning settings that build on AI systems. In large language models such as ChatGPT or Gemini, the model is called as an API from a study app. A developer writes a request that says 'Give me a practice question about hypothesis testing' and the model returns a string. The app then presents that string to the learner. The same model can evaluate a learner's answer: the developer sends the learner's response along with the question, and the model returns a judgement like 'correct' or 'you missed the role of the null hypothesis', often with a hint. This is applied in tools such as Khan Academy's Khanmigo, which acts as a tutor that does not give away answers but asks guiding questions instead. In retrieval-augmented generation (RAG), the study partner is connected to a specific textbook: the developer stores the book's text in a database, and when the learner asks a question, the system first finds the most relevant passages, then sends those passages to the model along with the question, so the answer is grounded in the book rather than in the model's general training. This matters because the model alone might hallucinate a statistic; with the book retrieved, it can quote it. In agentic systems, a study partner agent can plan a revision session: it decides which topic to quiz first based on the learner's past mistakes, generates questions, checks answers, and then chooses the next topic. The model calls the study database as a tool. In small models running on a phone, such as on-device tutoring apps, the same interaction happens but with a smaller model that must be lightweight; the developer trades some answer quality for speed and privacy. In everyday applied machine learning, a data scientist might use an LLM study partner to learn a new library: they paste an error message and ask 'what does this mean and how do I fix it?' — and then verify the fix against the documentation. What a developer actually writes is a function that takes a prompt and returns a response, often using a library like OpenAI's Python client: they create a request with `model`, `messages`, and `temperature`, call the API, and handle the returned text. What breaks when done badly is verification: if the developer (or the learner) treats the model's output as truth, errors propagate. A badly built study partner gives answers directly instead of asking questions, which trains the learner to depend on it rather than think.


---

Read this on the web: https://basavapurushottam.com/learn-ai/llm-as-study-partner
