- Seven ways to use AI after it gets something wrong, built around the sixty seconds most people spend either retyping the question or closing the tab.
- Five different failures all look identical on screen, and each one has a different fix. Naming which one you're holding is the whole skill.
- Telling it "that's wrong" is the weakest move available. Asking it to find the error itself tells you whether more prompting will help at all.
- A citation that resolves to a real page can still be fabricated, so ask for the sentence rather than the link.
- The build item turns the checking into something that runs on every document, so every claim gets verified before you send it instead of after someone spots it.
Using AI after it gets something wrong is a skill with a shape, and almost nobody is taught it. You read a confident paragraph, something in it is false, and what happens next is one of two things: you retype the question in slightly different words, or you decide the tool is junk and close the tab. Both are guesses. There's a better sequence and it fits in about a minute.
Here's what makes it worth learning. Wrong answers aren't a bug being patched out from under you; they're a property of how these systems work. OpenAI's own researchers put it plainly in their paper on why models hallucinate: training and evaluation reward a confident guess over an honest "I don't know," so the models learned to guess. And the guessing isn't confined to sloppy work. GPTZero ran its citation checker over 300 papers submitted to ICLR 2026 and found 50 with at least one fabricated reference, every one already past three to five expert peer reviewers. One in six, at one of the most serious AI conferences on the calendar. If that's what slips by specialists reading in their own field, the question stops being whether you'll get a wrong answer and becomes what you do in the minute after.
Seven moves for that minute. None of them is "write a better prompt next time."
1. Name Which Kind of Wrong It Was
Every wrong answer looks the same on screen. Underneath there are five, and they take different repairs.
It invented something that doesn't exist. It misread material you gave it. It's working from knowledge that was true two years ago. It answered a nearby question instead of yours. Or it was right and you were wrong. Only the fourth is fixed by better wording. Invention is fixed by handing it the source instead of asking it to recall one. Staleness is fixed by making it search rather than remember. A misread usually means you gave it too much at once, and the fix is a shorter input, not a sterner instruction.
This is also why "how reliable is AI" is an unanswerable question. The 2026 AI Index reports a hallucination rate spanning 22% to 94% across 26 models on a single benchmark, depending on the model and the domain it's asked about. There is no one number. There's only reliable at what, and you find that out one failure at a time.
Start today: The next time you get a wrong answer, type one word to yourself before you type anything to the model: invented, misread, stale, off-target, or mine. Then pick the repair that matches. You'll be right about the category more often than you expect.
2. Re-Ask From the Fork Instead of Opening a New Chat
Yusuf runs a two-person consultancy and had spent forty messages teaching a model the shape of his client reports: the sections, the tone, the things his clients never want to see. On message forty-one it produced a summary with a number that was flatly wrong. He did what most people do. He wrote "that's incorrect, the figure is 18%," got an apology and a corrected paragraph, and spent the next hour noticing that everything after that point had gone subtly worse.
Appending a correction leaves the wrong answer sitting in the conversation, and the model keeps reading it. You now have a thread holding a confident falsehood, a retraction, and a fix, and every later response is written with all three in view. Opening a fresh chat solves that and throws away forty messages of setup that were working perfectly.
The move is the one in between. Edit the message that produced the bad answer and send it again. The thread branches from the last good point, the wrong text never becomes context, and everything you built before it survives. Every major chat tool ships this as a small pencil icon next to your own messages. It might be the most useful button in the interface that nobody clicks.
Start today: Open your last long thread and hover over one of your own messages until the edit icon appears. Click it once so you know where it lives. Next time, branch instead of stacking.
3. Ask for the Quote, Not the Link
A fabricated citation is rarely a broken link. That's what makes it dangerous. The model assembles a plausible author, a plausible journal, a plausible year, and often a real URL that goes to a real page which says nothing like what it was cited for. You click, the page loads, you feel reassured, you move on.
Change what you ask for and the trick stops working. Don't ask for sources. Ask for the sentence: the exact line that supports the claim, quoted, with where in the document it appears. A model that's working from a real source hands it over in seconds. A model that invented the reference produces a paraphrase, a hedge, or a quote that isn't in the document, and you have your answer without reading anything. One quote checked properly beats eight links glanced at.
Be honest about where this needs no AI at all. If the citation is an academic paper, searching Crossref by title takes ten seconds and tells you whether the thing exists, which catches the most common fabrication for free. Save the quote check for claims where the source is real and the question is whether it says what it was supposed to say. That check belongs in the pass a document gets before it leaves your desk, not in a panic after it's been read.
Start today: Find the last thing a model wrote for you that contained a factual claim with a source. Ask for the supporting sentence, quoted, plus its location. Check one. Notice how fast it goes.
4. Verify Every Claim in a Document Before It Goes Out
Items one through three are moves you make in the moment. This one is the move you stop making, because a person doing it by hand does it well on a Tuesday morning and badly at six on a Friday, and Friday is when documents get sent.
The checkable surface of a document is smaller than it looks: every statistic, source, link, date, and dollar figure. All of it can be tested mechanically. Does this URL resolve. Does this paper exist. Does the quoted line appear in the page it's attributed to. Does this number match the spreadsheet it came from. None of that needs judgment, which is why it's a terrible use of your evening and a good thing to hand to a workflow that checks every source before you send. What comes back is a list of flags, not a rewritten document. You keep the editing.
The underrated part: it catches your own mistakes too. The stale figure you copied from last quarter's deck gets flagged alongside anything a model invented.
Start today: Take the last report you sent out. Write down every claim in it a machine could check. That list is the spec, and it's shorter than you think.
5. Make It Find the Error Before You Name It
You spotted the mistake. Your instinct is to point at it. Hold that for one message and try this instead: "one of the five facts in that paragraph is wrong. Find it, and tell me how you'd verify it."
What comes back is diagnostic, and it decides your next half hour. If it lands on the right one and explains how to check it, the information was there and it picked badly, which means a correction will stick and the thread is worth continuing. If it picks a different fact each time you ask, or defends all five with equal confidence, it never held the information. More prompting will produce more confident wrongness. That's the signal to go get the source yourself and paste it in.
This is the same instinct behind using a model as a reviewer rather than a writer, turned inward on its own output. You're not asking it to be right. You're asking whether it knows.
Start today: Next wrong answer, don't say what's wrong. Say how many errors there are and ask it to find them. Compare what it names against what you already spotted.
6. Ask the Same Question Twice in Two Clean Windows
Marta is a grants officer at a housing charity, and she needed one number for a funding application: the current threshold for a scheme she'd applied to twice before. She asked, got a figure, and it looked right. That's the problem with this category of error. Nothing about it looks wrong.
The cheapest test here: ask the identical question in a second fresh window, nothing else in the context, and compare. Two matching answers prove nothing, since a model can be consistently wrong. But two different answers are proof of a guess, and that proof arrives in thirty seconds. Marta ran it, got a second number, and went to the funder's own page, which had a third. The application went out with the right figure.
Use it on claims you'd have no way of noticing: a threshold, a filing deadline, a version number, a rate. Skip it on anything you can verify at a glance.
Start today: Pick a factual answer you took on trust this week. Open a fresh window, paste the same question, and compare the two. If they disagree, you've learned something about that entire category of question.
7. Keep a Fumble List for the Model You Use Most
After a few weeks with the same model you start to notice repeats. It's confident about prices and wrong about them. It mangles dates in the current year. It quietly converts your regional spellings. It rounds when you needed exact. These aren't general facts about AI; they're habits of the specific system you use every day, and nobody else can write them down for you.
Keep a plain note with two columns. On the left, what it reliably fumbles. On the right, the correction that worked, in the exact words that worked. The right column is the valuable half. A phrasing that fixed a problem once will fix it again, and after a month you'll have a short standing instruction to paste at the top of any thread that matters, built from your own experience rather than a prompt guide written for somebody else's work.
The list tells you when to stop, too. If an entry keeps reappearing and no correction ever holds, you've found a job this model can't do, and knowing that beats another week of trying.
Start today: Open a note and write three entries from memory, one line each. You already know what they are; that's why you check those answers twice.
Pick One
Seven moves, and running all seven on every answer would cost more than the errors do. Take the one that matched something you've felt. If nothing jumped out, take number two, because branching instead of stacking costs you one click and quietly improves every long conversation you have from now on.
The thread underneath all of this: getting a wrong answer is not a verdict on the tool or on you. It's information about which jobs are worth handing over, and you only get that information by handing some over and watching what happens. If you're new here, Sunday covers the week's AI news, Wednesday takes one workflow apart and rebuilds it, and Monday is for ideas like these. When a check you're running by hand turns into a chore you repeat, the workflow directory shows what other people stopped doing manually.
Catch It Before the Client Does
Describe the checks you run by hand on everything you send, in plain words. BYOBot builds the agent that runs them every time, and you own it.
Frequently Asked Questions
- Sometimes, and the tell is which kind of wrong it was. If the model had the right information in front of it and picked badly, pointing at the mistake usually lands. If it never had the information, a correction just moves the guess somewhere else and you get a new confident answer that's wrong in a new way. Naming the failure comes before writing the correction, which is why that's item one rather than item five.
- Usually no. A new chat throws away the setup that was working along with the one answer that wasn't. Edit the message that produced the bad answer instead, so the thread branches from the last good point and the wrong text never enters the context. Start fresh only when the whole framing was off, or when a thread has grown long enough that the model is juggling three versions of your instructions.
- Ask for the sentence, not the link. A real citation comes with a quotable line and a location you can confirm in under a minute. For academic references, a title search on Crossref tells you instantly whether the paper exists, which catches the most common fabrication for free. The same habit applied to your own material is covered in the edition on using AI without generating text, where the model only ever hands back words you already own.
- Yes, and that's a real answer rather than a failure. If a job keeps producing errors you can only catch by doing the work yourself, the model isn't saving you anything. Keep it for jobs where checking is cheaper than producing, put the checking itself into a standing pre-send pass, and hand the rest back to yourself without feeling bad about it.
