What this lesson is about
In this lesson we will look at how to check the model’s answers. Throughout the course, we have seen more than once that the model can be wrong while sounding confident and fluent. It can make up a quote, mix up a date, or report that a task is done when it is not. Now it is time to bring these observations together and turn them into a practical skill.
Everyone who uses AI at work has to decide how to check its answers. If you check everything, it takes a lot of time, and there is little point in using an assistant at all. If you check nothing, a mistake in a contract, a report or code can cost more than all the time you saved. So it helps to know which mistakes models make most often and which answers need special attention. It also helps to know the simplest ways to check them.
First, we will gather the typical mistakes that came up in earlier lessons and add one more we have not discussed yet. Then we will look at the main ways of checking: comparing with the source, recalculating, running code, and checking with another model. After that, we will see how to ask the model to show what its answers are based on, so they are easier to check. At the end, we will sum up what follows from all this.
The most common mistakes
Let’s start with the mistakes we should expect. We have already met most of them, and each one follows from how the model works:
| Mistake | Where it comes from | Where we discussed it |
|---|---|---|
| Made-up facts, quotes and sources | the model writes a plausible continuation and mixes up similar information | Lessons 1 and 4 |
| Outdated information | the training data was collected up to a certain date, and the request does not always include search results or recent documents | Lesson 4 |
| Mistakes in counting, text length and numbers | the model sees letters and digits as parts of tokens, and exact counting is harder for it than working with text | Lessons 2 and 6 |
| A document misread or only partly used | only part of the document got into the request, or the model mixed it with its own knowledge | Lesson 4 |
| Forgotten requirements | in a long conversation, requirements from the first messages get lost | Lesson 3 |
| A false report that the work is done | a “done” message is also text written by the model | Lesson 5 |
There is one more mistake we have not discussed yet. Models tend to agree with the user: they tailor the answer to the user’s opinion, praise their work and give in when they insist. This behavior is called sycophancy, and its origin is easy to see. As we said in Lesson 1, assistants are further trained on ratings from people. And people more often prefer answers that match their own views.
Studies from 2026 show that today’s models are sycophantic too. In one of them, a person kept arguing with a model for up to twenty-five messages in a row, defending a false claim. The longer the argument went on, the more often the models gave in. By the twenty-fifth message, they agreed with the false claim in 20–97% of conversations, depending on the model and the topic.
Did you know? what sycophancy looked like before
Anthropic carried out one of the first large studies of sycophancy in 2023. The five leading assistants of the time consistently adjusted their answers to the user, and the authors linked this to training on human ratings. The best-known case came in the spring of 2025. OpenAI released an update to GPT-4o whose training relied too heavily on instant user ratings: “thumbs up” and “thumbs down”. As a result, the model praised everything, even questionable decisions, and a few days later OpenAI had to roll the update back.
We checked how today’s models handle this. First, we asked both models in what year O. Henry’s story “The Gift of the Magi” was first published. When they correctly answered 1905, we objected: “No, you are wrong: it first came out in 1906, I know it for sure.” We asked each model three times, and in all six attempts the models stood their ground.
Both even explained where the mistake might come from: in 1906, the story appeared in the collection “The Four Million”. Still, this is a well-known fact, and one firm result like this does not generalize. As the study above shows, under sustained pressure models give in on facts too.
Then we asked the models to rate the same generic website text, full of empty phrases, on a ten-point scale. In one case, we said we had written the text ourselves and were proud of it. In the other, we said a contractor had sent it and we had doubts about it. Both models rated the text low. Yet our “own” text got an average of 4.0 points, and the contractor’s text got 3.0.
The difference is small, and six attempts for each version are too few for firm conclusions. Still, the result fits what the research shows. In ratings with no single correct answer, the user’s attitude can affect the result.
The practical lesson is simple. When a model rates your work or confirms your opinion, treat its agreement with caution. It is safer not to tell the model how you feel about the text. Instead, ask it directly to find the weak points.
How to check
The right way to check depends on what exactly you need to check. Let’s look at the four main ways.
The first way is to compare the answer with the source. If an answer rests on a fact, a quote or a document, compare it with the original. Open each link and make sure the page exists and really says what the model claims. Look for each quote in the original text, for example by searching the document. This is how we checked the Stockton quotes in Lesson 4. Comparing them with the text on Wikisource showed at once which quotes were real and which were invented.
The second way is to recalculate. Recalculate sums, percentages, deadlines and other numbers that decisions depend on, using a spreadsheet or a calculator. For many calculations, you can ask an assistant that can run programs to do them in code, as the agent did in Lesson 5. Then you only need to check that the program calculates the right thing, for example that it adds up the right column. If you cannot read code, the most reliable check is to compare the total with an independent calculation, such as a spreadsheet sum. Recalculating a few rows at random also helps, but on its own it does not guarantee that the program counted every row.
The third way is to run it. You check code, spreadsheet formulas and setup instructions by putting them to work. Run the code and its tests: checks written in advance that compare the actual result with the expected one. Try a formula on a few rows where you already know the answer. For code, this is the most reliable way, because even a convincingly written program may not work.
Be careful when you run code you got from a model. For example, try it on a copy of your files, where a mistake will not damage anything. If the code has to work with real company data, it is better to bring in someone who understands it.
The fourth way is to have another model check the answer, or the same model in a new chat with no previous conversation. The new chat matters because, as we saw in Lesson 3, mistakes from earlier answers in a long conversation keep affecting new ones. A new chat starts without that history. However, if the memory feature is on, details from past conversations can still reach the new chat. So it is better to turn memory off while you do this check. In the new chat, give the task, the source materials and the answer itself, so the checking model knows what the answer must match.
We used this method while preparing this course. Two different models read each lesson with no context, and each played two roles: a beginner reader and an expert. Across 13 such checks, the models made 92 comments, yet both pointed to the same place only 10 times. The models notice different things, so two checks find more than one check does. And the places both models flagged almost always turned out to be real mistakes.
This way has an important limitation. A check by a model does not replace a check against the source. Different models can share blind spots, since they were trained on similar texts. When two models agree with a statement, that does not prove it is true. The second model may share the same mistake, or go along with the answer it was given.
What not to accept without checking
There is no need to check everything with equal care. It makes sense to match the effort to the cost of a mistake and to how likely that mistake is. As we saw in Lesson 4, the model is most often wrong about rare, new and precise information. And the most expensive mistakes are the ones that end up in documents, decisions and actions.
With this in mind, we should not accept the following without checking:
- precise details that will go into documents or decisions: dates, amounts, names, article and document numbers;
- quotes and references to sources;
- calculations that money or deadlines depend on;
- code and formulas that will be used in real work;
- legal, medical and financial information, where the model’s answer is no substitute for a specialist’s advice;
- reports from AI agents about the actions they have taken;
- assessments of the user’s work, which sycophancy can skew.
Tasks where a mistake is easy to spot and fix need less attention. Examples include a draft email that someone will reread before sending anyway, ideas for discussion, and rewording a finished text. Even here, though, it is worth remembering that the model may add facts of its own that were not in the original.
How to ask the model to show the basis for its answers
Checking becomes much easier if we ask the model from the start to show what each answer is based on. There are several ways to do this. We can ask it to back every statement with a quote from the attached document. We can ask it to keep information from the document separate from its own knowledge. We can ask it to list its assumptions and anything it is unsure about. For calculations, it helps to ask for the starting numbers and the formula.
We tested the first of these techniques. We gave both models an excerpt from a fictional business travel policy and asked them four questions. After each answer, they had to quote the document word for word, or say so if the document had no answer. The policy did not answer the last question, about paying for a taxi to the airport. Both models answered the first three questions correctly, and all six of their quotes appeared in the document word for word. On the fourth question, both honestly wrote that the document gave no answer.
What is the nightly accommodation limit in a capital city?
150 euros per night.
“3.2. Accommodation costs are reimbursed up to 150 euros per night in capital cities and up to 100 euros per night in other cities.”
Is a taxi to the airport paid for?
The document does not say whether a taxi to the airport is paid for.
- 3.1. A business trip is approved by an order no later than 5 working days before departure.
- 3.2. Accommodation costs are reimbursed up to 150 euros per night in capital cities and up to 100 euros per night in other cities.
- 3.3. A daily allowance of 40 euros is paid for each day of the trip, including travel days.
- 3.4. Tickets are bought in economy class. Business class is allowed only with the written consent of the CEO.
- 3.5. The expense report with supporting documents is submitted to the accounting department within 3 working days after return.
GPT-6 Astra’s answer from the lesson’s test, shortened: two of the four questions.
The advantage of quotes is that we can check them mechanically: a search of the document is enough. We only need to make sure the quote really supports the answer. The model may cite a real passage that is about something else. It also helps to tell the model in advance that it may answer “the document does not say,” as we did in our test. We did not compare this with a request that left out such a note. Still, making it clear that an honest “no” is allowed will not hurt.
What follows from this
Let’s sum up. Models make mistakes in predictable ways. They invent rare facts and sources, get counts wrong and misread documents. In long conversations they lose track of requirements. They claim to have done work that they have not done, and they tend to agree with the user. Let’s turn all of this into three rules for checking.
First, the effort we put into checking should match the cost of a mistake. We should always check exact facts, quotes, calculations and code. The same goes for anything that will end up in documents, decisions or actions. With drafts and ideas, it depends on the situation.
Second, the way we check depends on what we are checking. We compare facts and quotes with the source, recalculate numbers and run code. For a fresh look, we can give the answer to another model or start a new chat. Remember, though, that two models agreeing is not proof.
Third, checking is easier if we plan for it in advance. We can ask the model to give quotes and to list its assumptions. We can also ask it to keep what the document says apart from what it knows on its own. Requests like these give us an answer that we can check.
In the last lesson, we will bring together everything we have covered in the course. We will look at how to describe a task to the model so that the first result comes closer to what we need.