Reflexion and Self-Critique Prompting

TL;DR: Self-critique prompting means asking a model to grade its own draft against a rubric and revise it, which is genuinely useful for structure and clarity. Reflexion is a different, specific 2023 research method built on verbal reflection stored in memory and reused across multiple attempts. Neither one can catch a fact the model already believes is true.

What is self-critique prompting, actually?

Self-critique prompting is a single-response, or single-follow-up, technique: generate a draft, then ask the model to evaluate that draft against stated criteria, then revise based on its own evaluation. It works because re-reading a draft against an explicit checklist is a different cognitive operation than writing the draft in the first place. The model is looking for gaps between what was asked for and what it produced, not generating fresh content from nothing.

Part of why this gets confused with Reflexion is marketing shorthand: "self-reflecting AI" sounds like it should describe one thing, so vendors and how-to posts use "reflexion" as a general label for any prompt that asks a model to reconsider its own output. That collapses a specific, tested research method with a strong external-feedback requirement into a much looser everyday habit. Both are useful. They are not interchangeable, and the rest of this post keeps them apart on purpose.

A useful version of the everyday habit names the rubric instead of asking for a vague quality pass:

Here is my draft: [paste draft]

Grade it against this rubric, one line per criterion, with a
short reason:
1. Does every claim follow logically from what came before it?
2. Does the structure match what I actually asked for?
3. Is anything stated as fact that should be flagged as
   uncertain or unverified?
4. Does the tone match the intended audience?
5. Is there an unstated assumption a reader would need to know?

Then revise the draft to fix only what you flagged. Do not
introduce new claims while revising.

That last line matters more than it looks. A revision pass without a constraint against adding new material tends to "improve" a draft by making it longer and more confident, not more accurate. The model has just as much room to invent something new in the revision as it did in the original draft, and an unconstrained revision pass gives it a second, unsupervised chance to do exactly that.

A worked example, showing the delta

Take a short draft answering "explain why our onboarding drop-off is high" with no supporting data attached:

Draft: Our onboarding drop-off is high because the sign-up flow has too many steps and users lose patience. Reducing the flow to two steps would likely fix most of the churn.

Run it through the rubric above. A useful self-critique pass flags exactly two things: the claim that the flow "has too many steps and users lose patience" is asserted with no data behind it, and the claim that shortening it "would likely fix most of the churn" is a prediction dressed as a conclusion. Structure and tone pass cleanly.

Revised: Onboarding drop-off could be driven by several factors. Flow length is one candidate, but so are unclear value framing, a slow first load, or a confusing first screen. Without funnel data showing where users actually leave, shortening the flow is a reasonable experiment, not a confirmed fix.

Nothing about that revision required outside information. It required the model to notice that its first draft asserted a cause it had not actually established, exactly the class of error self-critique is good at catching. It could not have caught a wrong number in the same draft, because nothing in the rubric checks a number against reality. It only checks the draft's logic against itself.

A second example makes the boundary sharper. Ask a model to review a short function and it drafts: "This function has a bug: it doesn't handle the empty-list case, and the variable name tmp is unclear." A self-critique pass against a "did I actually verify this" rubric can catch the model asserting a bug it never traced through the code, and can push it to either show the failing case explicitly or soften the claim to "worth checking." What it cannot do is confirm the bug actually reproduces, because that requires running the code, not re-reading a description of it. Self-critique improves the claim's honesty. It does not substitute for the external check that would settle it.

What Reflexion actually is, and why it is not a synonym

Noah Shinn, Federico Cassano, Edward Berman, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao published "Reflexion: Language Agents with Verbal Reinforcement Learning" on arXiv in March 2023, last revised in October 2023, and it was published at NeurIPS 2023. The paper's own summary of the mechanism is precise: Reflexion agents "verbally reflect on task feedback signals, then maintain their own reflective text in an episodic memory buffer to induce better decision-making in subsequent trials."

Unpack that sentence and four things stand out that a single self-critique prompt does not have:

1. A task feedback signal. Reflexion needs something to react to: code that passes or fails a test, a game outcome, a task marked complete or not. A single-turn self-critique prompt has no such signal. The model is only checking its draft against a rubric it was handed, not against an outcome from the world.
2. Multiple trials. Reflexion runs a task, reflects, and tries again, sometimes several times, with each attempt informed by the last. A rubric-graded revision is one pass, not a sequence of attempts.
3. A persisted memory buffer. The reflection is stored and carried into the next trial, not discarded after the current response. A chat that does not save its own critique between separate tasks has nothing equivalent to this.
4. Reinforcement without updating weights. The paper states its contribution as reinforcing an agent's behavior "not by updating weights, but instead through linguistic feedback." The model itself stays the same. What changes is the text it conditions on next time.

The paper reports a striking headline result on one benchmark: 91% pass@1 accuracy on HumanEval, ahead of the GPT-4 baseline's 80% at the time of publication. That number belongs to a specific coding benchmark, a specific model generation, and a specific evaluation setup in a 2023 paper. Cite it as exactly that, not as a general claim about how much "reflection" improves any task you might try it on.

Why this distinction is worth keeping straight

Calling a single rubric-and-revise prompt "Reflexion" borrows credibility from a result, 91% on a specific benchmark, under a specific multi-trial setup with an external evaluator, that a one-shot prompt was never built to reproduce. It is not that self-critique prompting is fake or useless. The worked examples above show it catching real, common errors. It is that the two techniques solve different problems, and the harder problem, genuinely learning from an outcome across attempts, needs parts a single prompt does not have: an evaluator outside the model's own judgment, and somewhere to keep what it learned.

If you want to get closer to Reflexion's actual shape without building a full agent harness, the closest approximation is deliberate rather than automatic. Keep a short, running note of what went wrong on a past attempt at a similar task, in your own words or the model's, and hand that note back in as context on the next attempt:

Before you answer, here is what I learned from the last
attempt at a similar task: [paste your saved note, e.g.
"last time the summary buried the deadline in paragraph 3;
put deadlines in the first two sentences"].

Apply that lesson to this new task: [new task]

That reintroduces a rough form of persisted memory across attempts. It still will not have Shinn and colleagues' external feedback signal unless you attach one: a test suite, a scored result, a human's actual yes-or-no, something outside the chat that can say "wrong" independent of what the model believes about its own output.

Two more techniques people fold into "reflexion" that are also not it

Self-critique and Reflexion are not the only two points on this map, and two neighboring techniques are worth naming so you can tell them apart too.

Self-consistency asks a model to solve the same problem multiple times independently, then takes the answer most of the attempts agree on, rather than asking the model to critique any single draft. It catches a different failure: a reasoning path that goes wrong in one run but not in most others. It says nothing about a fact every run gets wrong the same way, because agreement across attempts is not the same thing as agreement with reality.

Tree-of-thought goes further still: instead of one linear draft, the model explores several partial solutions in parallel and can backtrack away from a branch that looks unpromising part-way through. It is closer in spirit to Reflexion's idea of learning across attempts, but it operates within a single problem-solving session rather than across separately scored trials with a stored memory buffer.

Neither one substitutes for the other three concepts in this post, and none of the four (self-critique, Reflexion, self-consistency, tree-of-thought) gives a model access to a fact it was never trained on. They differ in how they organize the model's existing reasoning, not in what the model is allowed to know.

The limit neither technique escapes

Self-critique and Reflexion both operate on reasoning, structure, and stored experience. Neither one is a source of new knowledge the model did not already have, which means neither reliably catches a fabricated fact the model is confident about. The clearest evidence for this is not academic. It is a real court record. In Mata v. Avianca (S.D.N.Y., June 22, 2023), a lawyer asked ChatGPT, in the same conversation, whether the fake cases it had cited were real. It said yes, twice. That is a model critiquing its own prior output and failing in exactly the way a rubric cannot fix, because the rubric only checks a draft's internal consistency. It has no way to check a case number against a court's actual docket.

We go through that case, and what verification prompting can and cannot do about it, in more detail in verification prompting: make the model check its own work, and cover the practical, human-side workflow in how to fact-check what ChatGPT tells you. If you are deciding whether to trust a model's tone or a model's facts more, see does emotional prompting actually work for a related case where the honest answer, in our view, depends entirely on which one you are asking about. For a lower-stakes place to practice a rubric pass before using it on anything that matters, writing your own performance review with AI is a good low-risk test case: feedback on tone and structure is exactly what self-critique is built for.