And somewhere, buried in that output, is an error you didn’t catch. Or a gap you didn’t notice. Or an assumption that quietly shaped the entire response in a direction you didn’t intend.
Most of the time, you’ll never know. The output gets used, the work moves forward, and the issue either surfaces later — or it doesn’t, and you got lucky.
There’s a better approach. And it takes about 90 seconds.
The problem: AI doesn’t know what it doesn’t know
AI is extraordinarily good at producing confident-sounding output. That confidence is a feature — it’s part of what makes these systems useful. You get direct answers, clear recommendations, structured thinking.
But that same confidence can mask real limitations.
AI doesn’t flag its own uncertainty well. It doesn’t always tell you when it’s inferring rather than knowing, when it made an assumption you never made explicit, or when there was a better approach it simply didn’t explore.
This isn’t a bug. These models are built to generate coherent, fluent responses — that’s the design goal. They’re not built to stop and interrogate their own reasoning in real time.
The result: you often don’t know what you’re missing about the response you just received. The error is invisible because nothing called your attention to it.
The technique: ask it to look twice
After you get an AI output, add a second prompt. Something like this:
Review what you just wrote. Where might you have been wrong, made an assumption I didn’t ask you to make, missed something important, or oversimplified? Be specific.
What happens next is often illuminating.
Good AI systems will catch real issues — logical gaps, missing edge cases, places where the output assumed context that wasn’t there. Sometimes they’ll identify the most significant weakness in their own response unprompted, once you’ve given them permission to do so.
The act of asking shifts something. Instead of producing, the model is now evaluating. It’s a genuinely different mode of operation, and it tends to surface different information. You’re not running the same process twice — you’re running a different process on the same material.
Why it works
Think of it this way. When you write something and then read it back with a critical eye, you catch things you missed while writing. You’re not smarter in that second pass — you’re applying a different kind of attention.
The same principle applies here. AI models can evaluate text critically. They do it every time you ask them to review someone else’s work. You’re redirecting that same capacity toward their own output.
There’s a reason human experts build review into their workflows. Surgeons have checklists. Pilots have pre-flight procedures. Engineers have code review. Lawyers have proofreaders. The insight isn’t that review matters — everyone knows that. The insight is that AI-assisted workflows have a review step available that most people simply aren’t using.
The model is right there. You just have to ask.
What the self-review catches — and what it doesn’t
The self-review prompt is genuinely useful for:
Logical inconsistencies. Places where the reasoning doesn’t hold up, or where the conclusion doesn’t follow from the premises.
Baked-in assumptions. Things the model assumed about your intent, context, or constraints that you never stated explicitly.
Missing considerations. The moments that a thoughtful second reader would raise.
Overconfident claims. Statements that should have been presented as uncertain, estimated, or context-dependent.
Oversimplification. Complex issues presented with more certainty than the situation warrants.
What the self-review won’t catch:
Factual errors the model doesn’t know about. If the model has incorrect information, the self-review won’t surface it.
Things that require real-world verification. Statistics, current events, specific technical details — those still need checking.
Knowledge cutoff limitations. The model doesn’t know what it doesn’t know from after its training.
The self-review is a quality layer, not a replacement for judgment. It reduces error rates. It doesn’t guarantee accuracy.
Building it into your workflow
The simplest version: before you use any AI output for something that matters, add one more prompt. Ask it to find its own mistakes.
Some teams we’ve worked with have made this an explicit step in their AI usage guidelines — not something left to individual judgment, but a standard part of the process. It adds 90 seconds. It has caught meaningful errors.
A more structured version: ask the AI to rate its own confidence on specific claims, or identify which parts of its response it was least certain about. Both work well for high-stakes outputs.
The right implementation depends on the stakes. For low-stakes drafts, a quick self-review catches the obvious issues. For consequential decisions, a more structured approach is worth the investment.
The principle behind the technique
The responsibility for output quality doesn’t disappear when AI is involved — it shifts. You’re no longer doing the work yourself, but you’re still responsible for the quality of the result. That means actively managing quality throughout the workflow, not just at the start.
Asking AI to review its own work is a concrete expression of that. It treats the model as a collaborator with real limitations — not an oracle you accept unquestioningly. And it keeps the human in the role that matters: the person who ultimately decides whether the output is good enough.
That’s not a limitation on what AI can do. It’s what makes AI genuinely useful over time.
You don’t need a new tool, a different model, or a longer prompt to catch more of the errors AI produces. You need one habit: close the loop.
After the output, before you use it, ask: What did you get wrong?
You might be surprised how often the answer is useful.
