When your AI cuts corners: five techniques to get more out of every answer

An AI rarely delivers the best it holds on its own. Even a well-considered answer can be raw, a convincing-sounding plan brittle. In this piece I go through five techniques with which you bring answers up to working quality, find hidden weaknesses in your ideas, and do not stop at the first variant that looks good. At the end it is about how these techniques can be linked into chains.

Self-refine: the AI edits itself

The simplest grip, and yet many do not use it. The reason lies in an expectation. We treat an AI like a program that immediately outputs a finished result. If there are errors, the program counts as unfinished. If it looks good, more seems not to be in it.

But an AI is not a program, it is a non-deterministic system. Ask it the same question three times, and each answer comes out a little differently. On top of that, a model concentrates heavily on the task set. If it is to deliver an answer, it writes with all its force at that answer. If, on the other hand, you ask it to check and improve itself, it attends to exactly that.

A year ago I would categorically not give serious tasks to an AI without self-checking. Meanwhile the models are more reliable, and in agent systems like Claude Code the self-check runs on its own. Still, self-refine remains useful. The AI takes its answer apart like an editor, lays the logic open and shows the load-bearing parts.

An example prompt:

Read your answer again. Assess it by three criteria: 1) correctness of the facts, 2) completeness, that is whether something important is missing, 3) clarity, that is whether someone without prior knowledge understands it too. Suggest changes that should flow into the text.

Many have the model rewrite the answer right away. I prefer to look at the list of changes and decide myself which to adopt. That takes longer, but I understand the logic of the answer better.

The prompt above is a starting point. The exact form depends on the model and the task. On current top models a terse “double-check the last answer” often suffices for me, and that is enough to catch gross errors. If I need a deeper check, I write a detailed prompt with varying criteria. Language models are trained on text and struggle with the real world. For fictional texts I therefore add: “Check the logic of the main events and the correct chronological order.”

Chain-of-verification: the complete check cycle

Fact-checking is laborious even in a cleanly written text. A statement can be right or wrong. But it can also be incomplete, outdated, or reflect only one of several views. And sometimes it is not a fact at all but an interpretation of the model, which turns out helpful in one case and disruptive in another.

We like to criticize language models for hallucinations. With the right prompt, though, they are well suited for fact-checking. The following prompts serve not only for AI answers but for the fact-check of any texts.

I work in several steps. First I separate facts from the model’s fantasy:

Read the text above again. Separate factual statements from your own interpretation and compile two lists.

The first list can be gone through by eye, to check whether the model really included everything important. Then the second prompt:

Check all factual statements from the list and assign each a category: correct (backed by sources), false (contradicts the sources), outdated (was correct, the situation has changed), incomplete (fact is right, without important context the statement tips over), one of several views (there are alternative positions not named), not checkable (manual check needed). Give a source and a short quote for each point. If a statement can be corrected, suggest how.

After that the model’s interpretations take their turn. In itself there is nothing bad about them, because a model often delivers interesting ideas and conclusions. But the text is published under your name, and you bear the responsibility. A second look is worth it:

Check all interpretations from the list. For each:

1. The author’s reading in one sentence: what he claims at the core.
2. Strongest counter-argument, phrased the way a smart reader of a different opinion would say it, not as a straw man.
3. Verdict from a category: justified (follows from the source, the alternative is weaker), overreach (plausible but does not follow from the source), presented as fact (presented as a statement about reality without an opinion marker, highest priority for a correction), open alternative (a strong counter-reading is not named and not refuted), not falsifiable (rhetoric instead of argument), imputed motive (an intention is stated that is missing in the source), false generalization (the conclusion reaches further than the basis), inappropriate emotion (the fact is right, the tone is not).
4. What would have to be in the source for the reading to be uncontroversial, and whether it is there.
5. Smallest correction that fixes the flaw without losing the author’s voice. At the end as a separate block: which of the points presented as fact are riskiest for publication and why. Do not suggest new text, only the analysis.

The analysis of the interpretations you should absolutely read yourself. In my experience, models often overdo it here and become too strict with their own ideas. The note at the end to mark the riskiest points is a guide. The decision you make better yourself.

A good fact-check can cost more resources than the answer itself. Many models have a cap on tokens per answer. If the AI stops too early, split the fact list into several parts and check each on its own. If your license offers a deep-research function, the check also runs through it. That takes time but delivers better results.

Techniques that uncover hidden problems

Improving a finished answer is one half. The following three techniques search for what stays invisible at first glance: hidden risks, inconspicuous causes of failure and blind spots in your own logic.

Pre-mortem: pretend everything has already failed

When we plan something, from the holiday trip to the business idea, we mostly ask “what can go wrong?” and get a list of abstract risks. In project management there is the pre-mortem for this. The idea behind it: imagine the venture has already failed, and reconstruct the chain of events that led there. Plus the early signals by which you could have recognized it.

A pre-mortem has another advantage. It lets you play through the situation of failure once, gauge how bad it would really be, and consider what to do then.

The prompt:

I’m planning [description of the project or idea]. Ask me questions first, to understand the context better. When you have everything, imagine a year has passed and the project has failed completely. Do a post-action review: what exactly went wrong, in what order, and which early signals were recognizable? Also suggest concrete measures in the planning phase that would have prevented every mistake in this chronology.

Pre-mortem fits well with red team, the deliberate attack on an idea that searches for its gaps. Where red team attacks the idea, the pre-mortem tells the story of the failure, with chronology, with cause and effect and with the concrete moments in which it began to tip.

Adapt the prompt to your situation. In my version the model delivers only one scenario, but you can request several. The questionnaire at the start is dispensable if the concept already stands. Then you send it directly and have the AI write the failure scenario right away.

Inversion: how to guarantee you botch everything

Pre-mortem shows how a project can fail. Inversion comes from the other side. Instead of “how do I succeed?” you ask “how do I guarantee I botch this?”.

That sounds like a joke but works. When we consider how something turns out well, we often get stuck in the abstract: more effort, a good strategy, consistency. Ways to ruin something, on the other hand, come to us easily and concretely. Formulating five pieces of advice for a good text is hard. Naming five ways to a terrible text is trivial.

The technique has a twist that makes it much stronger. First the inversion itself:

I want to [goal]. Ask me questions first, to gather the necessary context. When you have enough, flip my task around: write a guide on how I guarantee I mess this up. What must I do or not do so the result turns out as bad as possible?

Even the answers to this give good material to think about. In the next step you flip everything back around:

Now flip every point back: turn “how to fail” into a concrete list of actions that protect against exactly these mistakes.

One more observation. Every model has its own habits. Without instruction one writes seven points, another ten. Here only trying helps. Set the number of points in the prompt that you can work with well. Or have the model check after the answer whether it included everything. Often the behavior changes with a new version within the same series, so keep an eye on it.

Five whys: let the AI risk offbeat hypotheses too

This technique comes from Toyota. When something does not run smoothly or has already failed, you ask yourself “why?” five times and answer it, from the obvious to the deep.

At first glance this does not fit AI, since you direct the questions at yourself. Over time I flipped the approach, and it became one of my favorite prompts. First the prompt, then the explanation:

[Describe the idea and expectation]. [Describe the current result]. Let’s apply five whys: you ask the question “why does the result not match the expectation?” and answer it yourself with a hypothesis. If needed, I comment, then we go to the next “why?”. Do not stick to five questions. We dig until we have found the real cause.

The core is the dialogue. The AI effectively becomes the outside expert who forms its own hypotheses. You comment on whether a hypothesis hits or not. Some are banal, some far-fetched. After a few rounds, though, the AI may bring you to thoughts that would never have come to you alone.

This recalls the trick of bringing in an experienced outsider who asks naive questions from the basics up. That way you see your own idea from outside, without the expert’s operational blindness. With an AI this works without inviting anyone. A cheap license is enough.

Prompt chaining: linking techniques into chains

Every prompt serves on its own. For a serious task, though, you link them into chains. A few variants I use:

Writing and checking a text: raw draft, then self-refine for criticism and corrections, then chain-of-verification for the fact-check with sources.

Assessing an idea before the start: pre-mortem for the story of the failure, then inversion for the guaranteed sabotage, then five whys to dig to the root risks.

Making a difficult decision: red team and steelmanning for attack and defense of a position, then what-if to fan out risks into scenarios, then pre-mortem for the chosen variant.

Getting into a new topic without making mistakes: first the onboarding, then chain-of-verification to check whether you understood it correctly.

A long chain is not needed every time. For a simple task, one or two techniques suffice. If something bigger is at stake, you attach further links. Between the links always stands your judgment. You read the result and decide what comes next. The AI does the heavy work, you set the direction.

Prompts are not magic formulas but a way of communicating. The better you understand how a model works, the less often you need ready-made phrasings and the more often you develop your own.