Critique and Refinement Prompting

Introduction

Critique and refinement prompting is a method of improving an AI-generated response through structured review and revision.

Instead of accepting the first response as final, the user asks the model to:

1. Generate an initial draft.
2. Evaluate the draft using clear criteria.
3. Identify weaknesses and missing information.
4. Prioritise the required improvements.
5. Revise the draft.
6. Verify that the revised version is better.

This approach is useful because the first output produced by a language model may be correct but incomplete, unclear, poorly organised, repetitive, or unsuitable for the target audience.

Critique and refinement prompting turns content generation into an improvement cycle rather than a one-time request.

Chapter Overview

A basic critique and refinement process follows this flow:

Generate Draft
Review Draft
Identify Problems
Rank Improvements
Revise Content
Compare Versions
Verify Final Output

The method can be used for:

• Articles
• Emails
• Reports
• Business proposals
• Technical documentation
• Software code
• SQL queries
• Marketing content
• Study notes
• Interview answers
• Project plans
• Data analysis reports
• AI-generated summaries

The quality of the final response depends heavily on the quality of the critique criteria. A vague request such as “Improve this” may produce unpredictable changes. A clear request such as “Improve clarity, technical accuracy, structure, and practical usefulness” gives the model measurable goals.

Learning Objectives

After completing this chapter, you should be able to:

• Generate a suitable initial draft.
• Define clear critique criteria.
• identify weaknesses in generated content.
• Detect missing information and contradictions.
• Evaluate clarity, accuracy, and relevance.
• Rank improvements by importance.
• Create effective revision prompts.
• Compare original and revised outputs.
• Use multiple refinement passes.
• Design reusable critique prompt templates.
• Build complete refinement workflows.

Key Terms

Core Concept of Critique and Refinement

A normal prompt asks the model to produce an answer.

A critique and refinement prompt asks the model to produce, evaluate, and improve an answer.

Basic generation prompt:

Explain dependency injection in Java.

Critique and refinement prompt:

Write an explanation of dependency injection in Java.
Review the explanation for technical accuracy, clarity, completeness, and practical usefulness.
Identify weak or missing parts.
Revise the explanation based on the critique.
Return only the improved final version.

The second prompt creates a controlled improvement process.

The user can also divide this process into separate prompts:

Step 1: Generate the first draft.
Step 2: Critique the draft.
Step 3: Revise the draft.
Step 4: Verify the revised version.

Separate prompts provide more control because the user can inspect the critique before revision.

Why Critique and Refinement Prompting Is Important

Critique and refinement prompting improves output quality in several ways.

• It reduces unclear explanations.
• It reveals missing details.
• It detects inconsistent statements.
• It improves logical structure.
• It removes irrelevant content.
• It helps match the target audience.
• It improves technical accuracy.
• It reduces repetition.
• It improves formatting.
• It creates more reliable final outputs.

However, critique does not guarantee factual correctness. A language model can confidently approve incorrect information. Important facts should still be checked using trusted documentation, reliable sources, tests, calculations, or domain experts.

Generating an Initial Draft

The initial draft is the first version of the requested content. It provides the material that will later be reviewed and improved.

A weak initial draft can still be refined, but a well-defined first prompt reduces unnecessary revision work.

Requirements of a Good Initial Draft Prompt

A useful initial draft prompt should define:

• The task
• The topic
• The target audience
• The required detail level
• The output format
• The tone
• The constraints
• The expected result

Example:

Write a beginner-friendly article explaining Java exception handling.
Target readers are students with basic Java knowledge.
Explain checked exceptions, unchecked exceptions, try, catch, finally, throw, and throws.
Include one practical example for each major concept.
Use simple language and Markdown headings.
Keep the article between 1200 and 1500 words.
Do not include unrelated Java topics.

Each instruction appears on a separate line, making the prompt easier to read and follow.

Initial Draft Prompt Structure

Task: State what must be created.
Topic: Define the exact subject.
Audience: Identify the intended reader.
Coverage: List the required concepts.
Format: Define the output structure.
Constraints: State limits and exclusions.
Success condition: Define what makes the draft acceptable.

Example

Create an initial project proposal for an employee attendance system.
The proposal is for a small software company.
Include the business problem, proposed solution, features, technology stack, timeline, risks, and expected benefits.
Use clear business language.
Use Markdown format.
Keep each section focused.
Do not include pricing information.

The initial draft should not always be treated as incorrect. It is a working version that becomes the input for the critique stage.

Defining Critique Criteria

Critique criteria are the rules used to evaluate the initial draft.

Without clear criteria, the model may focus on minor writing changes while ignoring important technical or factual problems.

Common Critique Criteria

A response can be evaluated for:

• Accuracy
• Completeness
• Clarity
• Relevance
• Logical consistency
• Structure
• Tone
• Grammar
• Practical usefulness
• Audience suitability
• Instruction compliance
• Formatting
• Evidence quality
• Safety
• Conciseness

Example of Vague Critique

Review this response and improve it.

This prompt does not define what “improve” means.

Example of Clear Critique

Review the draft using the following criteria.
Check whether all required topics are covered.
Check whether the technical statements are accurate.
Check whether the explanation is easy for beginners.
Check whether examples support the explanation.
Identify repeated or irrelevant content.
Identify unclear terms.
List each issue with its importance level.
Do not rewrite the draft yet.

This prompt separates evaluation from revision.

Criteria-Based Evaluation Table

A model can be asked to use a structured table:

Weighted Critique Criteria

Not every criterion has equal importance.

Example:

Evaluate the draft using these weighted criteria.
Technical accuracy: 35 percent
Completeness: 25 percent
Clarity: 20 percent
Practical usefulness: 10 percent
Formatting: 10 percent
Give a score from 0 to 100.
Explain each deduction briefly.

Weighted criteria help the model focus on high-value improvements.

Identifying Weaknesses

A weakness is any part of the draft that reduces its quality, usefulness, correctness, or readability.

Weaknesses may include:

• Unclear explanations
• Weak examples
• Poor organisation
• Repetition
• Unsupported claims
• Incorrect terminology
• Missing transitions
• Excessive detail
• Insufficient detail
• Unclear conclusions
• Inconsistent formatting
• Failure to follow instructions

Weakness Identification Prompt

Analyse the draft and identify its weaknesses.
Separate major weaknesses from minor weaknesses.
Explain why each weakness affects the reader.
Quote only the minimum text needed to identify the issue.
Suggest the type of correction required.
Do not rewrite the full draft.

Major and Minor Weaknesses

Major weaknesses affect correctness or task completion.

Examples:

• Incorrect technical information
• Missing required sections
• Contradictory statements
• Wrong calculations
• Invalid code
• Misunderstanding of the requested task

Minor weaknesses affect presentation but not the central meaning.

Examples:

• Awkward wording
• Repeated sentences
• Weak transitions
• Inconsistent punctuation
• Poor heading names

Example

Original statement:

Java automatically handles every runtime exception, so developers do not need to manage them.

Critique:

• The statement is technically misleading.
• Java may propagate runtime exceptions, but it does not automatically resolve them.
• Developers must prevent, handle, log, or intentionally allow such exceptions based on application requirements.
• This is a major weakness because it teaches an incorrect concept.

A useful critique explains both the problem and its effect.

Identifying Missing Details

A draft may appear correct while still being incomplete.

Missing details are required facts, examples, steps, conditions, limitations, or explanations that were not included.

Types of Missing Details

• Missing definitions
• Missing examples
• Missing steps
• Missing assumptions
• Missing edge cases
• Missing limitations
• Missing prerequisites
• Missing evidence
• Missing error handling
• Missing conclusions
• Missing required fields
• Missing audience-specific explanations

Missing Detail Prompt

Compare the draft with the original requirements.
List every required detail that is missing or underdeveloped.
Separate completely missing details from partially explained details.
Explain where each detail should be added.
Do not add unrelated information.

Requirement Coverage Matrix

A coverage matrix helps verify whether the draft satisfies the prompt.

Example

Original request:

Explain REST API authentication using Basic Authentication, API keys, JWT, and OAuth 2.0.

Draft coverage:

• Basic Authentication: Included
• API keys: Included
• JWT: Included
• OAuth 2.0: Missing
• Security comparison: Missing

The critique should identify both missing topics and missing relationships between topics.

Detecting Contradictions

A contradiction occurs when two statements in the same response cannot both be true under the same conditions.

Contradictions reduce trust and may lead readers to incorrect conclusions.

Common Types of Contradictions

• Factual contradictions
• Numerical contradictions
• Timeline contradictions
• Requirement contradictions
• Logical contradictions
• Terminology contradictions
• Recommendation contradictions

Example of a Factual Contradiction

Statement 1:

A Java interface cannot contain implemented methods.

Statement 2:

Java interfaces can contain default and static methods with implementations.

These statements conflict because modern Java interfaces can contain certain implemented methods.

Example of a Numerical Contradiction

Statement 1:

The project will take eight weeks.

Timeline table:

Planning: 2 weeks
Development: 5 weeks
Testing: 2 weeks
Deployment: 1 week

The detailed timeline totals ten weeks, not eight weeks.

Contradiction Detection Prompt

Review the draft for contradictions.
Compare definitions, numbers, dates, recommendations, and conclusions.
List the conflicting statements together.
Explain whether the conflict is real or depends on different conditions.
Suggest the minimum correction required.
Do not rewrite unrelated sections.

Avoiding False Contradiction Reports

Two statements may look different but apply to different situations.

Example:

Caching improves response time for repeated requests.
Caching may increase response time when cache invalidation is complex.

These statements are not necessarily contradictory. They describe different conditions.

A good contradiction review should consider context before reporting a conflict.

Evaluating Clarity

Clarity measures how easily the target reader can understand the content.

A technically correct response may still be ineffective if it uses undefined terms, long sentences, weak structure, or vague references.

Clarity Evaluation Questions

• Are important terms defined?
• Are sentences direct and understandable?
• Does each paragraph explain one main idea?
• Are examples connected to the concept?
• Are vague words avoided?
• Are steps presented in the correct order?
• Is the language suitable for the target audience?
• Are pronouns and references clear?
• Are unnecessary technical terms removed or explained?

Unclear Example

The system processes it before sending it there, which improves it.

Problems:

• “System” is not defined.
• “It” is unclear.
• “There” has no clear destination.
• “Improves” does not explain the measurable result.

Clearer version:

The API gateway validates the request before forwarding it to the authentication service, reducing invalid requests sent to the service.

Clarity Evaluation Prompt

Evaluate the draft for clarity.
Identify vague statements, undefined terms, long sentences, and confusing transitions.
Consider the knowledge level of a beginner.
Explain why each selected section may be difficult to understand.
Suggest a clearer direction for each issue.
Preserve correct technical terms.

Readability Improvement Rules

During refinement:

• Replace vague words with specific terms.
• Break long sentences into shorter sentences.
• Define specialised terms at first use.
• Use examples after difficult concepts.
• Arrange steps in execution order.
• Keep paragraphs focused.
• Use headings that describe the content.
• Avoid unnecessary filler phrases.

Clarity does not mean removing all technical terms. It means explaining technical ideas in a way that the intended audience can follow.

Evaluating Accuracy

Accuracy measures whether facts, calculations, technical statements, examples, and conclusions are correct.

Language models can produce confident but incorrect information. Therefore, accuracy evaluation should use reliable references whenever possible.

Areas Requiring Accuracy Checks

• Definitions
• Dates
• Statistics
• Calculations
• Code behaviour
• API usage
• Security recommendations
• Legal statements
• Medical information
• Financial information
• Product specifications
• Version-specific features

Accuracy Evaluation Prompt

Review the draft for factual and technical accuracy.
Identify claims that are incorrect, misleading, outdated, or unsupported.
Distinguish verified facts from assumptions.
Mark claims that require external verification.
Explain each issue briefly.
Do not invent sources or evidence.

Code Accuracy Example

Draft code:

public class Calculator {
    public int divide(int a, int b) {
        return a / b;
    }
}

Possible critique:

• The method works for valid integer values.
• It throws ArithmeticException when b is zero.
• Integer division removes the decimal part.
• The method does not explain or handle these behaviours.

Improved code:

public class Calculator {
    public double divide(double a, double b) {
        // Prevent division by zero
        if (b == 0) {
            throw new IllegalArgumentException("Divisor must not be zero");
        }
        return a / b;
    }
}

Accuracy Verification Methods

Use appropriate verification methods:

• Run code and tests.
• Recalculate numerical results.
• Check official documentation.
• Compare with trusted references.
• Validate syntax.
• Review version compatibility.
• Test edge cases.
• Ask a qualified expert for high-risk subjects.

Self-critique alone is not enough for high-stakes accuracy.

Evaluating Relevance

Relevance measures whether the response directly supports the user’s goal.

A response may be accurate and well written but still include content that does not help complete the requested task.

Relevance Problems

• Unrelated background information
• Excessive history
• Repeated explanations
• Examples outside the requested domain
• Sections that do not support the objective
• Additional advice not requested
• Long introductions that delay the answer
• Details intended for the wrong audience

Relevance Evaluation Prompt

Evaluate the relevance of every section.
Identify content that does not support the requested objective.
Identify repeated ideas.
Identify useful content that receives too little attention.
Recommend what should be removed, shortened, expanded, or moved.
Preserve necessary context.

Example

User request:

Explain how to create a Spring Boot REST controller.

Irrelevant content may include:

• A long history of the Java language
• Detailed information about frontend frameworks
• A comparison of cloud providers
• General career advice

Relevant content includes:

• Required dependencies
• Controller annotation
• Request mapping
• Input handling
• Response handling
• Validation
• Exception handling
• Testing

Relevance and Completeness

Relevance does not mean making every response extremely short.

A complete response can include background information when that background helps the reader understand the main task. The goal is to remove unnecessary content without removing useful context.

Prioritising Improvements

After identifying problems, the next step is to rank them.

Without prioritisation, the model may spend effort changing minor wording while leaving major accuracy or completeness problems unresolved.

Suggested Priority Levels

Prioritisation Prompt

Rank the identified issues by importance.
Use Critical, High, Medium, or Low priority.
Prioritise correctness and task completion over style.
Explain the impact of each issue.
Recommend the order in which the issues should be fixed.
Do not revise the draft yet.

Recommended Improvement Order

A practical order is:

1. Safety problems
2. Incorrect facts
3. Invalid calculations or code
4. Contradictions
5. Missing requirements
6. Poor logical structure
7. Unclear explanations
8. Weak examples
9. Repetition
10. Grammar and formatting

Effort and Impact Matrix

Improvements can also be ranked by impact and effort.

This method is useful when the revision must be completed within a limited time or word count.

Revising the Draft

Revision applies the accepted critique to the original draft.

The revision prompt should define what must change and what must remain unchanged.

Effective Revision Instructions

A revision prompt should specify:

• Which issues must be fixed
• Which content must be preserved
• Whether new information may be added
• Whether the structure may change
• The required output format
• The required length
• Whether explanations of changes are needed

Revision Prompt

Revise the draft using the approved critique.
Correct all factual and technical errors.
Add the missing required details.
Remove repeated and irrelevant content.
Improve the logical order of the sections.
Simplify unclear sentences.
Preserve accurate examples and useful explanations.
Keep the response suitable for beginners.
Return only the revised draft.

Controlled Revision Prompt

Revise only the introduction and conclusion.
Preserve all technical sections exactly as written.
Make the introduction shorter and more direct.
Make the conclusion summarise the main lessons.
Do not add new claims.
Return the complete document.

Controlled revision is useful when most of the draft is already acceptable.

Revision with Change Notes

Revise the draft based on the critique.
Return the revised draft first.
After the draft, provide a short change log.
List only meaningful changes.
Do not describe minor punctuation corrections.

Risks During Revision

Revision can create new problems.

For example:

• A corrected paragraph may conflict with another section.
• New content may exceed the word limit.
• Simplification may remove important technical meaning.
• Reorganisation may break references.
• A new example may be incorrect.
• Formatting may become inconsistent.

The revised output should therefore be checked again.

Comparing Original and Revised Output

Comparison helps confirm whether the revision produced a real improvement.

The comparison should focus on measurable differences rather than simply stating that the new version is better.

Comparison Criteria

Compare the two versions for:

• Accuracy
• Completeness
• Clarity
• Relevance
• Structure
• Conciseness
• Practical usefulness
• Instruction compliance

Comparison Prompt

Compare the original draft and revised draft.
Evaluate both versions using the same criteria.
Identify specific improvements in the revised version.
Identify any useful content that was accidentally removed.
Identify any new errors introduced during revision.
Give a final recommendation on which version should be used.

Example Comparison Table

Before-and-After Example

Original:

Dependency injection is when Spring creates everything automatically and puts it where required.

Revised:

Dependency injection is a design technique in which an object receives its required dependencies from an external source. In Spring, the IoC container creates managed objects and supplies their dependencies based on the application configuration.

The revised version is better because it:

• Defines dependency injection independently of Spring.
• Explains Spring’s role accurately.
• Uses the correct term, IoC container.
• Avoids the vague word “everything.”

Multi-Pass Refinement

Multi-pass refinement improves a response through several focused review cycles.

Instead of asking the model to check everything at once, each pass examines a different quality area.

Example Multi-Pass Process

Pass 1: Check requirement coverage.
Pass 2: Check factual and technical accuracy.
Pass 3: Check logic and contradictions.
Pass 4: Check clarity and audience suitability.
Pass 5: Check relevance and repetition.
Pass 6: Check formatting and final compliance.

Why Multiple Passes Are Useful

A single review prompt may cause the model to:

• Miss less obvious errors.
• Focus mainly on grammar.
• Ignore contradictions.
• Make broad and unsupported claims.
• Mix evaluation and revision.
• Overlook formatting rules.

Focused passes reduce these problems.

Multi-Pass Refinement Prompt

Perform a multi-pass review of the draft.
Pass 1: Check whether every original requirement is satisfied.
Pass 2: Check factual and technical accuracy.
Pass 3: Check contradictions and logical gaps.
Pass 4: Check clarity for the target audience.
Pass 5: Check relevance, repetition, and structure.
Pass 6: Create a final revision plan.
Keep the findings from each pass separate.
Do not rewrite the draft until all passes are complete.

Revision Pass

Revise the draft using the final revision plan.
Fix higher-priority issues before lower-priority issues.
Preserve correct and useful content.
Do not introduce claims that were not required.
Return the improved draft.

Verification Pass

Verify the revised draft against the original requirements.
Confirm whether each required topic is present.
Check whether the revision introduced new contradictions.
Check whether the output follows the required format.
List any remaining issues.
Return Approved only when no important issue remains.

Stopping Condition

Multi-pass refinement should have a stopping rule.

Possible stopping conditions:

• All critical and high-priority issues are resolved.
• The output satisfies every original requirement.
• The quality score reaches a defined threshold.
• Further edits would only change personal style preferences.
• The output passes code, schema, or calculation validation.
• The maximum number of refinement passes is reached.

Example:

Stop refining when all critical and high-priority issues are resolved.
Do not continue making style changes after the content meets the requirements.

Without a stopping condition, repeated refinement may create unnecessary changes or make the response worse.

Critique Prompt Templates

The following templates can be reused for different tasks.

General Critique Template

Review the provided draft.
Evaluate accuracy, completeness, clarity, relevance, structure, and instruction compliance.
Identify strengths.
Identify weaknesses.
Identify missing details.
Identify contradictions.
Rank each issue by priority.
Suggest a specific correction for each issue.
Do not rewrite the draft.

Beginner-Friendly Content Critique Template

Review the explanation for a beginner audience.
Identify undefined technical terms.
Identify sentences that are difficult to understand.
Check whether concepts are introduced in a logical order.
Check whether examples support the explanation.
Identify missing basic information.
Preserve necessary technical terminology.
Do not oversimplify the concept.
Return a structured critique.

Technical Article Critique Template

Review the technical article.
Check the correctness of definitions and technical claims.
Check whether version-specific information is clearly identified.
Check whether code examples match the explanation.
Check whether limitations and edge cases are included.
Check whether the article follows the requested structure.
Mark claims that require external verification.
Rank all issues by importance.
Do not rewrite the article.

Code Critique Template

Review the provided code.
Check syntax and compilation issues.
Check logical correctness.
Check error handling.
Check input validation.
Check security risks.
Check performance problems.
Check readability and maintainability.
Identify edge cases.
Suggest focused corrections.
Do not rewrite the full code unless necessary.

Java Code Review Template

Review the Java code.
Check whether it compiles.
Check null handling.
Check exception handling.
Check resource management.
Check thread-safety when applicable.
Check collection and stream usage.
Check naming and class design.
Check time and space complexity.
List issues by severity.
Provide corrected code after the critique.

SQL Critique Template

Review the SQL query.
Check syntax correctness.
Check join conditions.
Check filter conditions.
Check handling of null values.
Check duplicate row risks.
Check index usage.
Check performance for large tables.
Check whether the query matches the business requirement.
Suggest an improved query.
Explain each important change.

Business Proposal Critique Template

Review the business proposal.
Check whether the business problem is clearly defined.
Check whether the proposed solution addresses the problem.
Check whether benefits are measurable.
Check whether assumptions are stated.
Check whether risks and dependencies are included.
Check whether the timeline is realistic.
Identify unsupported claims.
Rank improvements by business impact.
Do not rewrite the proposal yet.

Email Critique Template

Review the email.
Check whether the purpose is clear.
Check whether the requested action is specific.
Check whether the tone is suitable for the recipient.
Check whether important dates and details are included.
Remove unnecessary repetition.
Identify wording that may sound rude or unclear.
Suggest a concise revision.
Preserve the original meaning.

Marketing Content Critique Template

Review the marketing content.
Check whether the target audience is clear.
Check whether the main benefit is specific.
Check whether the claims are believable.
Check whether the call to action is clear.
Identify generic or repeated wording.
Check tone consistency.
Check whether the content avoids misleading promises.
Suggest improvements without changing the brand message.

Data Analysis Critique Template

Review the data analysis.
Check whether the conclusion follows from the data.
Check whether assumptions are stated.
Check whether correlation is confused with causation.
Check whether important variables are missing.
Check whether calculations and percentages are consistent.
Check whether uncertainty and limitations are explained.
Identify unsupported conclusions.
Recommend additional validation steps.

Refinement Template

Revise the draft using the approved critique.
Fix all critical and high-priority issues.
Correct inaccurate statements.
Add missing required details.
Remove irrelevant and repeated content.
Improve clarity and logical structure.
Preserve correct information.
Follow the original format and length constraints.
Return only the revised version.

Critique and Revision Combined Template

Create an initial response for the requested task.
Review the response for accuracy, completeness, clarity, relevance, and structure.
Identify the most important weaknesses internally.
Revise the response to correct those weaknesses.
Verify that the revised response follows every instruction.
Return only the final improved response.

This combined template is efficient, but separate stages provide more visibility and control.

Refinement Workflow Examples

Workflow Example 1: Technical Article

Task:

Create an article about Java multithreading.

Step 1: Generate the Draft

Write a beginner-friendly article about Java multithreading.
Explain threads, the Thread class, the Runnable interface, thread lifecycle, synchronisation, race conditions, and deadlocks.
Include practical Java examples.
Use Markdown format.
Keep the language simple and technically accurate.

Step 2: Critique the Draft

Review the article against the original requirements.
Check technical accuracy.
Check whether every requested topic is covered.
Check whether the code examples are correct.
Check whether difficult terms are explained.
Identify missing risks and limitations.
Rank issues by priority.
Do not rewrite the article.

Step 3: Revise the Draft

Revise the article using the critique.
Correct technical errors.
Add missing explanations.
Improve code comments.
Explain thread safety clearly.
Preserve the beginner-friendly style.
Return the full revised article.

Step 4: Verify the Revision

Verify the revised article.
Confirm that every requested topic is included.
Check the code for syntax and logical errors.
Check for contradictions.
Check Markdown formatting.
List any remaining issues.

This workflow separates creation, critique, revision, and verification.

Workflow Example 2: Java Method Refinement

Initial code:

public class UserService {
    public User findUser(List<User> users, String email) {
        for (User user : users) {
            if (user.getEmail().equals(email)) {
                return user;
            }
        }
        return null;
    }
}

Critique prompt:

Review the Java method.
Check null handling.
Check input validation.
Check time complexity.
Check whether returning null is safe.
Check readability.
Rank issues by severity.
Provide an improved version.

Possible improved code:

import java.util.List;
import java.util.Objects;
import java.util.Optional;
public class UserService {
    public Optional<User> findUser(List<User> users, String email) {
        // Validate required method inputs
        Objects.requireNonNull(users, "Users list must not be null");
        Objects.requireNonNull(email, "Email must not be null");
        return users.stream()
            .filter(Objects::nonNull)
            .filter(user -> email.equals(user.getEmail()))
            .findFirst();
    }
}

Key improvements:

• Validates the method inputs.
• Avoids calling equals on a possibly null user email.
• Ignores null list elements.
• Returns Optional instead of null.
• Makes the search intention clear.

The linear time complexity remains O(n), which is acceptable for a list search. For frequent lookups, a map indexed by email may be more efficient.

Workflow Example 3: SQL Query Refinement

Original query:

SELECT *
FROM orders o, customers c
WHERE o.customer_id = c.id
AND YEAR(o.order_date) = 2026;

Critique prompt:

Review the SQL query.
Check join style.
Check index usage.
Check whether all selected columns are required.
Check date filtering performance.
Suggest a more maintainable version.
Explain the important changes.

Improved query:

SELECT
    o.id AS order_id,
    o.order_date,
    o.total_amount,
    c.id AS customer_id,
    c.name AS customer_name
FROM orders AS o
INNER JOIN customers AS c ON c.id = o.customer_id
WHERE o.order_date >= '2026-01-01'
    AND o.order_date < '2027-01-01';

Key improvements:

• Uses an explicit INNER JOIN.
• Selects required columns instead of using SELECT *.
• Uses a date range instead of applying a function to the date column.
• Makes the query easier to read.
• May allow better use of an index on order_date.

Workflow Example 4: Business Email Refinement

Initial draft:

Hi,
We have many issues with the project and things are getting delayed. Please do something quickly because the customer is asking us again and again.
Thanks.

Critique:

• The email does not identify the specific issues.
• The required action is unclear.
• No owner or deadline is mentioned.
• The tone may sound blaming.
• The customer impact is vague.
• The message does not provide a next step.

Revised version:

Hello Team,
The API integration and test-data setup are currently blocking the planned release.
The API issue has delayed system testing by two days, and the customer has requested an updated completion date.
Please confirm the owner and resolution date for each blocker by 3:00 PM today.
After receiving the updates, I will prepare the revised release plan for the customer.
Thank you.

The revised version is more useful because it states:

• The exact blockers
• The impact
• The requested action
• The deadline
• The next step

Workflow Example 5: Interview Answer Refinement

Question:

Tell me about a production issue you resolved.

Initial answer:

We had a production issue where the application was slow. I checked it and found a database problem. I fixed the query, and then it worked properly.

Critique:

• The situation lacks context.
• The business impact is missing.
• The investigation steps are unclear.
• The exact database problem is not explained.
• The candidate’s individual contribution is vague.
• The result is not measurable.

Refined answer:

During a high-traffic period, one of our patient-search APIs started taking more than eight seconds to respond, which affected the operations team’s ability to process records.
I reviewed the application logs and database execution plan and found that the query was performing a full table scan because a frequently filtered column was not indexed.
I worked with the database team to add the required index and changed the query to avoid an unnecessary function on the filter column.
After deployment, the average response time decreased from more than eight seconds to approximately 900 milliseconds.
We also added query-time monitoring and an alert to detect similar performance problems earlier.

The refined answer is stronger because it explains the situation, investigation, action, result, and prevention.

Workflow Example 6: Project Plan Refinement

Initial plan:

Week 1: Design
Week 2: Development
Week 3: Testing
Week 4: Release

Critique:

• Requirements analysis is missing.
• Development may require more than one week.
• No dependency is identified.
• No owner is assigned.
• Security testing is missing.
• No buffer is included.
• Release approval is not mentioned.

Refined plan:

The refined plan includes dependencies, realistic phases, validation, and risk allowance.

Complete Critique and Refinement Workflow

The following workflow can be applied to most complex tasks.

Step 1: Define the Desired Outcome

State what the final output must achieve.

Example:

The final article must teach beginners how JWT authentication works in a Spring Boot application.

Step 2: Define Success Criteria

Create measurable conditions.

Example:

The article must define JWT.
The article must explain token generation and validation.
The article must explain the authentication filter.
The article must include a working request flow.
The article must discuss token expiry and security risks.
The article must use beginner-friendly language.

Step 3: Generate the Initial Draft

Use a complete prompt containing the task, audience, format, constraints, and required coverage.

Step 4: Evaluate Requirement Coverage

Check whether every requested item appears in the draft.

Step 5: Evaluate Correctness

Review facts, code, calculations, examples, and conclusions.

Step 6: Evaluate Communication Quality

Check clarity, structure, tone, and audience suitability.

Step 7: Identify and Rank Problems

Separate critical, high, medium, and low-priority issues.

Step 8: Create a Revision Plan

State exactly what must be corrected, added, removed, preserved, or reorganised.

Step 9: Revise the Draft

Apply the revision plan without introducing unnecessary changes.

Step 10: Compare the Versions

Confirm that the revised version is more accurate, complete, clear, and relevant.

Step 11: Verify the Final Output

Check the revised version against the original prompt and success criteria.

Step 12: Stop Refining

Stop when all important requirements are satisfied and further edits would add little practical value.

Complete Reusable Prompt

Create an initial draft for the task described below.
Follow every requirement and constraint.
After creating the draft, evaluate it for accuracy, completeness, clarity, relevance, logical consistency, and practical usefulness.
Identify missing details, contradictions, unclear statements, unsupported claims, and instruction violations.
Rank the identified issues as Critical, High, Medium, or Low.
Correct all Critical and High-priority issues.
Correct Medium-priority issues when they improve usability.
Preserve accurate and useful content.
Remove unnecessary repetition.
Verify the revised output against the original requirements.
Return only the final improved version.
Task: [Describe the task]
Target audience: [Describe the audience]
Required topics: [List the topics]
Output format: [Define the format]
Constraints: [List the constraints]
Success criteria: [Define measurable conditions]

Best Practices

• Define the expected outcome before requesting a critique.
• Use clear and measurable evaluation criteria.
• Separate critique and revision for important tasks.
• Prioritise correctness before writing style.
• Compare the draft with the original requirements.
• Ask for missing details and contradictions separately.
• Preserve content that is already correct.
• Use focused review passes for complex outputs.
• Verify code by running it when possible.
• Verify calculations independently.
• Check important facts using trusted sources.
• Define a stopping condition.
• Avoid endless revision cycles.
• Request concise explanations instead of hidden internal reasoning.
• Use structured output for large critiques.
• Review the revised version for newly introduced errors.

Common Mistakes

Using Vague Improvement Instructions

Weak prompt:

Make this better.

Better prompt:

Improve technical accuracy, beginner readability, logical structure, and example quality.
Preserve the original meaning.
Remove repeated information.
Return the revised version.

Asking for Too Many Changes Without Priority

When every issue is treated equally, the model may focus on grammar instead of correctness.

Use severity levels to guide the revision order.

Revising Before Understanding the Problems

Immediate rewriting may hide the cause of poor quality.

For important tasks, critique first and revise second.

Trusting Self-Critique as Proof

A model may fail to identify its own incorrect claims.

Use external tests, documentation, calculations, or expert review when accuracy matters.

Allowing Uncontrolled Rewriting

A broad revision request may change correct content.

Define what must be preserved and what may be changed.

Refining Without a Stopping Rule

Repeated revisions may introduce new errors or make the content unnecessarily long.

Stop when the output satisfies the agreed success criteria.

Focusing Only on Grammar

Grammar is only one part of quality.

A grammatically correct response may still be inaccurate, incomplete, irrelevant, or logically inconsistent.

Ignoring the Original Prompt

The critique must compare the draft with the original requirements. Reviewing the draft alone cannot reveal whether required sections are missing.

Final Checklist

Before accepting a refined response, verify the following points:

• The original task is correctly understood.
• Every required topic is included.
• Important facts are accurate.
• Calculations are correct.
• Code is valid or tested.
• No major contradictions remain.
• Missing details have been added.
• Irrelevant content has been removed.
• The structure is logical.
• The target audience can understand the content.
• Examples support the explanation.
• The requested format is followed.
• Length limits are respected.
• Important assumptions are stated.
• Unsupported claims are removed or marked.
• The revised output is better than the original.
• No new errors were introduced.
• All critical and high-priority issues are resolved.
• The final output satisfies the defined success criteria.

Conclusion

Critique and refinement prompting is a practical method for producing higher-quality AI responses. It changes the workflow from simple generation to controlled improvement.

The process begins with an initial draft. The draft is then reviewed using clear criteria such as accuracy, completeness, clarity, relevance, and logical consistency. Weaknesses, missing details, and contradictions are identified and ranked. The draft is revised based on those findings and checked again against the original requirements.

The most effective refinement workflows use specific criteria, focused review passes, clear priorities, controlled revision instructions, and measurable stopping conditions.

Critique improves awareness of problems. Refinement corrects those problems. Verification confirms whether the final result is ready to use.

Frequently Asked Questions