Draft-critique-revise writer

What you'll build

Step-by-step build

1. 1

   Define the rubric as data

   Write the quality criteria as a structured list, for example clarity, structure, specificity, and tone, each with a one-line definition. Making the rubric data rather than prose means the critic can address each criterion explicitly and you can display scores against it later.

2. 2

   Generate the first draft

   Prompt the model as a writer with the brief and the rubric, asking for a complete first draft. Keep this prompt focused purely on producing content; do not ask it to self-evaluate in the same call, because mixing the roles weakens both.

3. 3

   Critique in a separate role

   In a new call, prompt the model as a strict editor: given the draft and the rubric, produce specific, actionable critique for each criterion, pointing at concrete sentences. Ask it to be genuinely critical rather than congratulatory, since a soft critique produces no improvement.

4. 4

   Revise from the critique

   Prompt the model as a reviser with the current draft and the critique, asking it to apply the feedback and return an improved draft. Instruct it to make the specific changes the critique called for, not to rewrite from scratch and lose what worked.

5. 5

   Close the loop with a stop condition

   Wrap critique and revise in a loop that runs until a maximum iteration count or until the critique reports no meaningful issues left. A hard cap is essential so the loop cannot run forever or burn your free quota. Two or three iterations usually captures most of the gain.

6. 6

   Add numeric scoring

   For a stronger stop condition, have the critic also emit a score per rubric criterion. Stop when the total stops rising between iterations. This turns 'looks better' into a number you can show and reason about.

7. 7

   Surface the whole history

   Render every draft, its critique, and its score in sequence so a user can watch the piece improve. Seeing draft one next to the final version, with the critiques between, is the clearest possible proof the loop works.

8. 8

   Test that later drafts beat earlier ones

   Run several briefs and confirm the final draft genuinely improves on the first against the rubric, not just changes. If the loop is not helping, sharpen the critic prompt to be harsher and more specific. Ship once improvement is consistent.

Done when

• ✓For several briefs, the final draft is clearly better than the first against the rubric, not merely different.
• ✓The critic produces specific, actionable notes tied to the rubric, not vague praise.
• ✓The loop always terminates via the max-iteration cap or a no-issues-left signal.
• ✓With numeric scoring on, the score rises across iterations and the stop triggers when it plateaus.
• ✓The live URL shows the full draft, critique, and revision history for a fresh brief.

Ship it

Deploy the Next.js app to Vercel on the free tier with your Groq key in the environment. Ship a live URL and a README that puts the first draft beside the final draft for one brief, with the critiques in between, so the quality lift is obvious at a glance. Note the rubric and stop condition as the mechanism.

What it proves: You understand self-improving generation loops: separating generation from evaluation, driving revision with an explicit rubric, and controlling an agentic loop with a real stopping condition, which is the core idea behind reflection and agentic quality patterns.

Paste this into Cursor, Claude, or ChatGPT and build it step by step.

You are my senior AI engineer pair. Help me build "Draft-critique-revise writer" step by step. The idea is a self-improvement loop: the model drafts, then acts as a critic scoring the draft against a rubric (an explicit list of quality criteria), then revises from that critique, repeating under a stop condition. Separating the generation role from the evaluation role is what makes it work. Stack: Next.js (UI + API route), Groq (Llama 3.3 70B) for all three roles, a rubric defined as structured data, a max-iteration and score-plateau stop condition, Vercel hosting.

Requirements:
1. Define the rubric as data, each criterion with a short definition.
2. Generate a first draft from the brief and rubric in a focused writer prompt.
3. Critique in a separate call as a strict editor, giving specific per-criterion notes and a score.
4. Revise from the critique, applying the changes rather than rewriting wholesale.
5. Loop critique and revise until max iterations or the score plateaus, and display every draft, critique, and score.

Work in this order: define the rubric, then the draft prompt, then the critic prompt, then the revise prompt, then the loop and stop condition, then numeric scoring, then the history UI. Give me the commands and code for each step and STOP after each so I can test. Do not write the whole app at once.