Aiodic

Back to the table

41 Intermediate Rf Self-critique Prompting

Self-critique

Asking the model to review its own work.

What it is

Self-critique means asking an AI model to review its own work before you accept it. The model writes a draft, then reads that draft back as a reviewer would, lists what's wrong with it, and (if you ask) produces a corrected version. It's the AI equivalent of proofreading your email before you press send.

In practice it's a second message, or a second step in a larger process. The first prompt says "write the product description". The second says something like "Check that description against these five rules and list every place it breaks one." A third might say "Now fix only the problems you listed." Those three moves, draft, critique, revise, are the whole technique. Everything else is detail about how to ask well.

Why would a model find mistakes in something it just wrote? Because writing and checking are different jobs. When a language model writes, it produces text one small piece at a time, each piece chosen to follow on from what came before. It never stops to look at the whole. When you hand it the finished draft and ask a pointed question, such as "Is there a price anywhere in this?" or "Does every paragraph stay under 60 words?", it can look at the whole thing at once. Many problems that slip past during writing are easy to spot on a second read, for a model just as for a person.

The key word there is "pointed". Self-critique works best when the model knows exactly what to look for. "Is this good?" invites a polite yes. "List every sentence longer than 25 words" gets a real answer. The more a problem can be checked against a clear rule, the better a model is at finding it.

It also has a well-known limit, and it's important to know it from the start. A model reviewing its own reasoning uses the same knowledge and the same blind spots that produced the mistake. If it didn't know a fact when it wrote the draft, it usually doesn't know it when it reviews the draft either. Researchers have found that for maths, logic, and factual questions, simply asking "review your answer" often fails to fix errors and sometimes introduces new ones. Self-critique is a good checker for rules, format, and missing pieces. It is a weak checker for truth. The most reliable versions bring in something from outside the model: a test that runs, a document to check against, or a person.

The same idea is also used in training, not just in prompts. In December 2022 Anthropic described Constitutional AI, a method in which a model critiques its own responses against a written list of principles, rewrites them, and is then trained on the improved versions. So self-critique isn't a trick someone found. It's one of the ways AI companies shape their models. The alignment article covers that side of the story. This article is about the version you can use today, in a chat window.

Why it matters

It catches the boring mistakes that cost you most. Most failures in everyday AI use aren't dramatic. The blurb runs 30 words over the limit. The email forgets to mention the deadline. The product listing uses a word the marketplace bans. The summary skips the one point your boss cares about. These are exactly the kind of problems a checklist can describe, and exactly the kind a second pass catches well.

It's cheap. A self-critique pass is one extra message. You don't need new tools, a paid plan, or technical skill. For anything that will be read by a customer, a client, or the public, one extra message is a small price for fewer embarrassing errors.

It turns your standards into something reusable. To ask for a good critique, you have to write down what "good" means: under 150 words, no invented numbers, a clear call to action, the customer's name spelled right. Once that list exists, you can reuse it on every draft, hand it to a colleague, or turn it into a test set with evals. Many people find that writing the checklist improves their work more than the critique itself.

It's a building block for bigger systems. In prompt chaining, where one job is split into a sequence of prompts, a review step is one of the most common links in the chain. Agents, the AI systems that carry out multi-step tasks, often pause to check their own progress before moving on. Knowing how self-critique works, and when it fails, helps you judge those tools too.

Knowing its limits protects you. Believing that the AI checked its own work is a comfortable feeling, and sometimes a dangerous one. If you know that a model reviewing its own facts can confidently approve something false, you'll check the facts that matter yourself. That knowledge is as useful as the technique.

Real-world examples

Self-Refine: when feedback helps, and when it doesn't (March 2023)

In March 2023, a team led by Aman Madaan at Carnegie Mellon University, with co-authors from the Allen Institute for AI, the University of Washington, NVIDIA, UC San Diego and Google Research, published a paper called "Self-Refine: Iterative Refinement with Self-Feedback". The method is exactly the loop described above. The same model writes an output, gives itself feedback on it, then rewrites using that feedback. No extra training and no second model.

They tested it on seven tasks, including rewriting reviews to flip their sentiment, making up acronyms, making code run faster, writing dialogue replies, and removing toxic language, using GPT-3.5, ChatGPT and GPT-4. Across the tasks, people and automatic measures preferred the refined outputs, with an average improvement of about 20 percentage points.

Two details in the paper matter more for everyday users than the headline number. First, the quality of the feedback made a large difference. When the researchers replaced the model's specific feedback with generic feedback, results on one task dropped from 43.2 to 31.2. A critique that names exact problems beats "make it better". Second, on maths word problems the method barely helped: GPT-4 went from 92.9 percent to 93.1 percent. The authors explained that maths errors can hide in a single line, and a reasoning chain that looks consistent can fool the model into deciding everything looks good. Self-critique shone on writing and style tasks, where problems are visible on a reread, and struggled where the mistake was in the thinking.

The repeated draft-and-revise loop that Self-Refine uses is the subject of its own element, iterative refinement. What belongs here is the lesson about the critique step: specific feedback works, vague feedback doesn't, and reasoning errors are hard to see from the inside.

"Cannot self-correct reasoning yet" (October 2023)

In October 2023, researchers from Google DeepMind and the University of Illinois Urbana-Champaign, led by Jie Huang, published a paper with a blunt title: "Large Language Models Cannot Self-Correct Reasoning Yet". It was later presented at ICLR 2024, one of the main machine-learning conferences.

They tested what they called intrinsic self-correction, meaning the model reviews its own answer with no outside help. The model answered a question, was asked to review its answer and report any serious problems, then was asked to give an improved answer. They ran this on grade-school maths problems (a test set called GSM8K), multiple-choice common-sense questions (CommonSenseQA), and questions that need several facts combined (HotpotQA).

The results went the wrong way. With GPT-3.5, maths accuracy slipped from 75.9 to 75.1 percent after one round of self-correction. On the common-sense questions it fell from 75.8 to 38.1 percent, because the review prompt nudged the model into swapping a correct answer for one of the plausible-looking wrong options. GPT-4 dropped as well, from 95.5 to 91.5 percent on the maths set after one round. When the model did change its mind, it more often turned a right answer wrong than a wrong answer right.

The paper also explained why earlier studies had looked so positive. Some had quietly used the correct answers to decide when to stop correcting, so the model was never allowed to spoil a right answer. Take that help away and the gains vanished. For anyone using a chatbot, the lesson is simple. "Review your answer" is not a fact-checker, and on questions with one right answer it can make things worse.

Chain-of-Verification: checking facts one question at a time (September 2023)

Researchers at Meta AI, led by Shehzaad Dhuliawala, took a different approach in a September 2023 paper, "Chain-of-Verification Reduces Hallucination in Large Language Models". Instead of asking the model to judge its whole answer, they had it break the answer into small checkable questions and answer each one separately.

The paper's opening figure shows the idea with a question that tripped up ChatGPT: name some politicians who were born in New York. The first answer listed Hillary Clinton and Michael Bloomberg, among others. The method then plans verification questions ("Where was Hillary Clinton born?", "Where was Michael Bloomberg born?") and answers each one on its own. Asked directly, the model knows that Clinton was born in Chicago and Bloomberg in Boston, so both are dropped from the final list.

The important design choice was answering the verification questions without the original draft in view. The researchers found that when the model could see its earlier answer, it tended to repeat the same mistakes. Kept apart, the short questions were answered more accurately than the long original. With Meta's Llama 65B model, the method roughly doubled precision on list questions, from 0.17 to 0.36, and raised a standard factual score for written biographies from 55.9 to 71.4.

It's a real improvement, and it's worth being clear about what it does and doesn't do. It works because a model is often better at a narrow question than at a long answer that mixes many facts. It can't find a fact the model never knew. That's why the hallucination problem still needs checking against real sources, and why grounding an answer in a document you trust is stronger still.

Outside feedback changes everything (2023 to 2024)

A fourth line of research shows when self-critique really does work. In March 2023, Noah Shinn and colleagues published "Reflexion", presented at NeurIPS 2023. Their AI agents wrote short notes to themselves about why an attempt failed and used those notes on the next try. On a standard set of programming problems, their approach solved 91 percent on the first attempt, against 80 percent for GPT-4 alone.

The detail that matters is where the failure signal came from. For code, the agent wrote its own tests, ran them, and saw which failed. The verdict came from the computer running the code, not from the model's opinion of itself. In other tasks the signal came from the environment saying whether an answer was right.

In 2024 Ryo Kamoi and colleagues at Penn State and the University of Illinois pulled this research together in a survey, "When Can LLMs Actually Correct Their Own Mistakes?", published in the journal Transactions of the Association for Computational Linguistics. Their conclusion lines up with everything above. Self-correction using only the model's own prompted feedback hadn't been shown to work in general, except on tasks that suit it unusually well. It works when reliable outside feedback is available, such as a test, a search result, or a tool, and it can be built in through large-scale training. They also found that some earlier studies had overstated the benefits.

An everyday scenario: the listing that broke its own rules

Imagine Tomás, who sells handmade leather wallets online and uses a chatbot to write product listings. His marketplace has rules: titles under 140 characters, no words like "best" or "guaranteed", and the materials must be named. His own rules are that every listing mentions the free engraving and ends with care instructions.

The chatbot's listings read well, but about one in three breaks something. Usually it's "best-quality leather", or the engraving is forgotten. So Tomás changes his routine. He pastes each new listing into a fresh chat with his five rules as a numbered checklist and asks for a pass or fail on each rule, quoting the text that breaks it. Within a week the checklist catches a banned word, two missing engraving mentions, and a title 12 characters too long, all in seconds. It never catches that one listing said "full-grain" when that wallet was actually top-grain leather. Only Tomás knew that, which is why he still reads every listing before it goes live.

Try it yourself

This exercise uses a checklist to critique a short piece of writing: a draft email, a product blurb, a book description, or a bio. You need any chatbot. Allow 15 minutes.

  1. Get a draft. Use something you've already written with AI, or make one now. For example, paste this into any chatbot: “ Write a 120-word description for my online workshop "Budgeting for Freelancers", a 90-minute live session on 14 November. It covers setting aside tax money, handling irregular income, and a simple monthly budget. Price: $39. Audience: freelancers who hate spreadsheets. “
  2. Write your checklist before you read the draft. Five to eight yes-or-no rules, each one something you could check in ten seconds. For the example above: under 120 words; mentions the date, length, and price exactly as given; names all three topics; no invented facts such as testimonials, statistics, or a guarantee; no words from this list: "revolutionary", "ultimate", "unlock"; ends with a clear next step. Writing it first stops you adjusting your standards to fit whatever the draft says.
  3. Open a fresh chat. Start a new conversation rather than asking the chat that wrote the draft. A model reviewing text it has just written in the same conversation tends to go easy on it, and it can see the reasoning that led to each choice, which makes those choices look right. A fresh chat sees only the draft and your rules, which is how a real reader sees it too.
  4. Ask for a rule-by-rule check, not an opinion. Paste this, filling in the brackets: “` You are reviewing a draft against a checklist. Do not rewrite it yet. For each rule, answer PASS or FAIL. For every FAIL, quote the exact words that break the rule. If a rule can't be checked from the text alone, say "CAN'T CHECK" instead of guessing. Do not add rules of your own or comment on style. Rules:
  5. [rule]
  6. [rule]
  7. [rule] Draft: [paste the draft] Facts the draft must match exactly: [paste the details you gave the first time] “` Giving it the original facts matters. Without them the model can check format but not accuracy, because it has nothing to check against.
  8. Check the checker. Look at each FAIL and each PASS yourself. Count the words if it says it's under the limit, since models are unreliable at counting. If you find a problem the review missed, note it. This is how you learn which rules the model checks well for you and which it doesn't.
  9. Ask for a targeted fix. In the same review chat, paste: “ Fix only the items marked FAIL. Change as little as possible and keep everything that passed exactly as it is. Then list what you changed. “ Asking for small, listed changes stops the model rewriting the whole thing and introducing new problems.
  10. Run the checklist once more on the fixed version, in another fresh chat. One round of fixes is usually enough. If you find yourself going round several times, the problem is probably the original prompt, and iterative refinement is the better tool.
  11. Save the checklist. Keep it in a note with the review prompt. Next time, paste both and you have a two-minute quality check for every draft.

One more experiment. In a fresh chat, ask a factual question you already know the answer to, such as the year a well-known book was published. When it answers correctly, reply "Review your answer carefully and correct any mistakes." Watch whether it keeps the right answer or starts hedging. That's the limit from the research above, in your own chat.

Common mistakes and misunderstandings

Asking "Is this good?" A vague question gets a vague, usually approving, answer. Ask the model to check named rules and quote the problems. Specific feedback was the difference between success and failure in the Self-Refine study, and it's the difference in your chat too.

Trusting it to fact-check itself. A model reviewing its own facts uses the same knowledge that produced them. If it believed something false while writing, it often still believes it while reviewing. For anything that matters, such as names, dates, prices, quotes, or legal and medical details, check against a real source, or give the model the source document and ask it to match every claim to a quote.

Pushing back with "Are you sure?" Challenging a model doesn't make it more careful. It often makes it agreeable. In November 2023, researchers at Salesforce tested ten models by asking "Are you sure?" after they answered. The models flipped their answers 46 percent of the time on average, and every model ended up less accurate. The RLHF article explains why: training on human preferences teaches models that agreeing with the person is usually rewarded. Ask for a check against rules or evidence, not for reassurance.

Reviewing in the same chat. The chat that wrote the draft can see its own reasoning and tends to defend it. A fresh chat, given only the draft and the checklist, is a more honest reviewer.

Letting the critique turn into a rewrite. If you ask for a review and a new version at once, the model often rewrites everything, fixes the listed problems, and creates new ones you didn't ask about. Critique first, then ask for minimal fixes, then check again.

Going round and round. One or two rounds usually catch what self-critique can catch. After that, models tend to make changes for the sake of change, or undo earlier fixes. If the draft is still wrong after two passes, change the original prompt or bring in outside information.

Thinking a clean review means the work is correct. "All rules pass" means all your rules pass. It says nothing about problems your checklist didn't cover. A human in the loop is still the final check for anything that reaches a customer.

Confusing self-critique with thinking modes. Some chatbots now think before answering, a feature called extended thinking, and part of that thinking can involve checking work. That helps, but it's the same model reviewing itself, with the same limits. A checklist you wrote, and facts you supplied, still add something the thinking can't.

Related elements