Apply to my task
arXiv:2507.05598 ★ 83 Jul 8, 2025

Re5: three-step self-review instead of a monolithic prompt

Key result

The model ignores your requirements not because it's bad, but because it's trying to write and track 10 rules at the same time. That's too much for one step. Re5 gets you an answer that meets every constraint, even from a weak model. Three stages: draft → self-check against a checklist ("met / not met" for each point) → targeted fixes. Splitting the roles into Doer → Checker → Editor gives you a reliable result where a single-prompt approach inevitably drops some of the conditions.

Self-Review Framework for Enhancing Instruction Following Capability ofLLM

Key Aspects of the Research:

The paper proposes the Re5 framework, which makes an LLM check and fix its own answers so it follows complex instructions better. Instead of trying to meet every requirement in one go, the model first produces a draft, then systematically checks it against each rule (format, length, content) and makes corrections.

Key Result: this self-correction approach lets even less powerful models reach a high level of instruction following, comparable to results from more advanced LLMs.


The Core Idea of the Method:

Adapted for everyday users, the essence of Re5 is to stop giving the LLM complex instructions as one monolithic order. Instead, you turn the prompt into a step-by-step process where the model plays two roles: first the Doer, then the Checker.

  1. Decomposing the instruction. Before writing the prompt, the user splits the task into two parts:

    • Main task: What needs to be done (write a text, draft a plan, answer a question).
    • Set of constraints: Clear, measurable rules the result must meet (for example: "no more than 500 characters", "use 3 bullet points", "tone: professional", "end with a question").
  2. The prompt as an algorithm. Instead of "Write me a post about X that will be...", you give the model a clear algorithm:

    • Step 1: Generation. "First, write a draft on topic X".
    • Step 2: Self-check. "Then, point by point, check your draft against the following criteria: [your list of constraints goes here]". The model must give a verdict on each point ("met" / "not met").
    • Step 3: Correction. "Based on your check, write the final, corrected version that meets all the criteria".

This works because it lowers the model's "cognitive load". It doesn't have to create and police itself on 10 parameters at the same time. It does simple tasks in sequence: first it generates the text, then it focuses on analyzing it against a clear checklist, and only then makes edits. It mirrors how people work: write, reread, fix.


Practical Applicability:

  • Direct applicability: Users can directly apply the adapted three-step prompt structure ("1. Draft -> 2. Self-check against a checklist -> 3. Final version") to any complex task. It requires no special tools, just the right prompt formatting.

  • Conceptual value: The paper gives users a key idea: an LLM becomes more reliable if you make it reflect on its own output. Instead of treating the LLM as a "black box", you start seeing it as a tool you can teach a quality-control process. It helps explain why the model so often "hallucinates" or ignores details: it tries to do everything at once and "forgets" some of the conditions.

  • Adaptation potential: The method adapts easily to any field. You only swap the self-check "checklist". A marketer will have one set of criteria (CTA, USP, tone of voice), a lawyer another (statute citations, no ambiguity), a student a third (essay structure, citations, word count). Adapting it is simple: identify the key requirements for the result and turn them into a clear checklist for Step 2 of your prompt.


A Practical Example:

You are an experienced social media manager. Your task is to create an engaging post for a travel Instagram account.

Follow this three-step algorithm strictly:

### Step 1: Write a draft of the post

Write a draft post on the topic "Three underrated but budget-friendly European destinations for a fall vacation".

### Step 2: Self-check the draft

Analyze the text you wrote in Step 1 and rate how well it meets each of the following criteria. Output the check results as a list.

*   **Criterion 1 (Style):** Is the tone light, friendly and engaging?
*   **Criterion 2 (Structure):** Does the text have a headline, three clearly separated destinations and a closing with a call to action? Are emojis used to improve readability?
*   **Criterion 3 (Content):** For each destination, does it briefly say why it's budget-friendly and what makes it interesting in the fall specifically?
*   **Criterion 4 (Constraints):** Is the total length no more than 1200 characters? Are there 3-4 relevant hashtags at the end?

### Step 3: Write the final version of the post

Based on the self-check results from Step 2, write the final, corrected and formatted version of the post that fully meets all the criteria.

Why It Works:

This prompt works by imitating the Re5 framework: it breaks a complex task into manageable stages and makes the model reflect:

  1. Lower cognitive load: In Step 1 the model focuses only on the creative task, generating ideas and text, without being distracted by strict formatting rules and constraints.
  2. Explicit constraint extraction: Step 2 is the equivalent of "Constraint Extraction" and "Content Evaluation" from the paper. We give the model a clear checklist. That forces it to focus its "attention" on each specific requirement separately (style, structure, length), which is far more effective than trying to hold everything in "memory" while generating.
  3. Structured self-correction: Step 3 is the equivalent of "Correction". The model gets not a generic "redo it" command but specific directions based on its own analysis. That leads to more precise, targeted fixes, keeping the good parts of the draft and fixing only the problem spots.

Another Practical Example

You are an executive assistant. You need to write a short, polite follow-up email to a partner who hasn't responded to our business proposal.

Follow this algorithm strictly:

### Step 1: Write a draft of the email

Write a draft email to John Miller at Brightline Inc., to whom we sent a proposal for Project Alpha last week.

### Step 2: Self-check the draft

Analyze the draft from Step 1 and check it against the following criteria. Present the result as a list.

*   **Criterion 1 (Tone):** Is the email written in a polite, low-pressure, professional tone? Is there no hint of blame or impatience?
*   **Criterion 2 (Clarity):** Does the email clearly state which proposal and project it refers to?
*   **Criterion 3 (Call to action):** Is there a soft, clear call to action at the end (for example, "We'd appreciate your feedback" or "Could you let me know if you've had a chance to review it?")?
*   **Criterion 4 (Brevity):** Is the email concise, no more than 3-4 sentences?

### Step 3: Write the final version of the email

Based on your check, write the final, polished version of the email, ready to send.

Why This Example Works.

The success mechanism of this prompt is identical to the previous one and rests on the key principles of the Re5 research:

  1. Separating roles: In Step 1 the LLM acts as a "copywriter" sketching out the core message. In Step 2 it becomes an "editor-checker" impartially going down the checklist. This keeps the creative flow from getting tangled up with strict rules.
  2. Focused evaluation: The checklist in Step 2 makes the model check, one by one, the aspects that are critical for a business email: tone, context, purpose and brevity. It's much easier for an LLM to evaluate an abstract notion like "politeness" as a separate item than to try to be polite "on the fly" while writing.
  3. Reliable result: The final version in Step 3 is very likely to meet all the requirements, because it's the product of not one but two operations: generation and then targeted verification. That significantly increases the reliability and consistency of the result compared with a single-step request.

Usefulness Score: 83

02

Main Evaluation Criteria

  • A. Relevance to prompting techniques: Low directly, but very high conceptually. The paper describes a framework for fine-tuning models, not ready-made prompts. But the framework's logic itself (decomposition, self-evaluation, correction) is an extremely powerful prompting meta-technique.
  • B. Better conversational answers: High. The paper's goal is to improve instruction following, which directly raises the quality and relevance of answers in chat scenarios.
  • C. Direct practical applicability: Low. Users can't implement the Re5 framework (which requires fine-tuning and external scripts) in a regular chat. But the principles can be adapted as a multi-step prompt.
  • D. Conceptual value: Very high. The work brilliantly explains why LLMs "forget" complex instructions and offers a systematic way to solve the problem. It gives users a mental model for complex tasks: don't just give an instruction, build a checking mechanism into it.
  • E. New useful practice: The work falls into several clusters at once:
    • Cluster 1 (Phrasing techniques): Offers an advanced form of task decomposition and self-correction.
    • Cluster 3 (Structure optimization): Shows the importance of structured feedback for the model.
    • Cluster 7 (Reliability and stability): The main goal is to make instruction following more reliable and reduce errors.

Practicality checklist (+15 points): * Provides ready-made phrases/constructions for prompts? (No) * Explains where to place important information in the prompt? (No) * Shows how to structure complex requests? (Yes, conceptually) * Reveals non-obvious LLM behavior? (Yes: why they struggle to follow many instructions and how iterations can degrade quality) * Reveals effective text summarization methods (No) * Offers ways to improve answer consistency/accuracy? (Yes, that's the core of the method)

On top of a base score of 68 points (interesting, but needs adaptation), 15 points are added for high conceptual value and for revealing non-obvious aspects of LLM behavior.

03

Numerical Usefulness Score

Arguments for a score of 83: The paper provides an extremely valuable conceptual model for any LLM user: "the model handles multitasking within a single request poorly, so make it do the work first and check it afterward". It's a fundamental principle you can adapt to solve complex tasks in a regular chat. Understanding that an LLM should be explicitly split into a "generator" and a "checker" instantly levels up a user's prompt engineering. The work explains why simple "do X, Y and Z" prompts so often fail.

Counterarguments (why the score could be lower): The score could be lower (around 60-65), since the paper is entirely focused on the technical implementation of a framework for fine-tuning models (DPO, RLAIF). None of the methods can be used by a regular user out of the box. All the practical takeaways require creatively adapting a complex technical concept into a simple step-by-step prompt. An unprepared user who reads the abstract will probably decide this paper isn't for them.

Counterarguments (why the score could be higher): The score could approach 90+, because "self-correction against a checklist" is one of the most powerful and universal advanced prompting techniques. A user who masters this approach can get consistently strong results from an LLM on tasks of any complexity. It's not just "one more trick" but a fundamental change in how you interact with the model.


Research digest

Key result

The model ignores your requirements not because it's bad, but because it's trying to write and track 10 rules at the same time. That's too much for one step. Re5 gets you an answer that meets every constraint, even from a weak model. Three stages: draft → self-check against a checklist ("met / not met" for each point) → targeted fixes. Splitting the roles into Doer → Checker → Editor gives you a reliable result where a single-prompt approach inevitably drops some of the conditions.

Principle

The standard approach is to dump everything into one prompt: "write X in style Y, no longer than Z words, with three bullet points and a call to action". The model tries to juggle it all at once and usually drops something. Re5 splits the work into three separate roles: Writer, Checker, Editor. Step one is pure creativity, no constraints. Step two is pure checklist analysis, no new text. Step three is only targeted fixes based on specific notes. Each step is simple. Together they're reliable.

Why it works

The model has a limited "attention budget" per call. When it has to generate and quality-check against 5-10 criteria at the same time, something inevitably falls through. That's not a bug of one model, it's physics: two competing processes in one window. Splitting the work into stages removes the conflict: at each step the model has one simple goal, and it handles it well. The research showed that weak models with Re5 catch up to stronger ones running in single-prompt mode. Not because they got smarter, but because they stopped trying to do everything at once.

When to apply

Any complex text with several hard requirements: business emails (tone + brevity + call to action), social posts (length + structure + hashtags), legal texts (citations + no ambiguity), coursework (structure + length + citations). The more constraints, the bigger the payoff from the three-step approach. NOT suited for simple tasks without hard constraints: three steps will just slow things down.

Mini recipe

1. Build the checklist before the prompt: write down every requirement for the result: tone, length, structure, must-have elements. At least 3-4 concrete points. Without a clear list, step two doesn't work. 2. Set the role and the algorithm: open the prompt with experienced social media manager / executive assistant / legal editor, then "Follow this three-step algorithm strictly". 3. Step 1, generation only: "Write a draft of [task]". No constraints here, just let the model write. 4. Step 2, point-by-point self-check: "Check the draft against each criterion and give a verdict: met / not met". List your checklist, each item on its own line. 5. Step 3, fixes: "Based on the check, write the final version, fixing everything that wasn't met". Not "rewrite from scratch" but "fix the specific mismatches".

Examples

[BAD]: `Write an Instagram post about a budget vacation in Europe. Light tone, three destinations, no longer than 1200 characters, hashtags at the end` [GOOD]: `You are the social media manager of a travel Instagram account. Follow this three-step algorithm strictly. Step 1: Write a draft post about three budget-friendly European destinations for a fall vacation. Step 2: Check the draft against each criterion and write a verdict: - Criterion 1 (Tone): light and engaging? Met / Not met - Criterion 2 (Structure): three clear destinations and a call to action? Met / Not met - Criterion 3 (Length): no more than 1200 characters? Met / Not met - Criterion 4 (Hashtags): 3-4 relevant hashtags at the end? Met / Not met Step 3: Write the final version of the post, fixing every mismatch from Step 2.`

In plain words

The thing is, modern models often act like hyperactive interns: they rush into the task without reading the instructions to the end, and then botch the details. The Self-Review (Re5) framework fixes this with forced reflection. Instead of blurting out an answer right away, the model is made to work through a chain: first extract the requirements, then make a plan, generate a draft and, most importantly, run a self-check against a checklist. This isn't just "think again", it's a rigid structure that makes the LLM spot its own screwups before the user does.

It's like asking an impulsive teenager to assemble an IKEA wardrobe. Usually they toss the instructions, hammer in a couple of extra nails and end up with a lopsided nightstand. But with the Re5 method you make them first list every part on paper, sketch an assembly plan, build the frame and at the end check every screw against the list. Technically it's more work, but what comes out is a wardrobe, not a pile of firewood. The model stops "hallucinating" success and starts actually comparing its result to what you asked for.

At the core are five concrete steps, with constraint analysis playing the key role. The model writes out all the conditions (for example, "don't use the word 'innovative'" or "stay within 50 words") in a separate block. Then comes draft generation and a critical Self-Review, where the model grades itself on meeting each point. If the score is low, it has to do iterative refinement. This loop turns ordinary output into a polished result, because the model literally gets its nose rubbed in its own logic or formatting mistakes.

The method was tested on complex chatbot instructions, but the principle is universal and applies anywhere precision matters: from writing code to legal summaries. Any task with more than three conditions is a perfect candidate for Self-Review. It works even in simple prompts: add "check yourself against points A, B and C" at the end and answer quality takes off. Prompt engineering is moving from coaxing to systematic control, and that's the only way to make AI play by complex rules.

Bottom line: stop hoping the model gets you on the first try, make it check itself. The Re5 method shows that the model's self-control beats endless prompt tweaking by a human. You just give it a self-check algorithm, and it stops tripping over nothing. Either you build these reflection loops into your workflows, or you keep getting garbage out and wasting time on manual edits.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Re5: three-step self-review instead of a monolithic prompt arXiv:2507.05598

Sign in to apply this study New accounts get 50 free credits.

Get the week’s best papers by email

One email on Sundays with the highest-rated new techniques. Unsubscribe with one click.