Make an AI Draft Critique Itself

Build an n8n loop that critiques and rewrites AI drafts until they pass.

Introduction

30 Second Summary

A first draft can sound convincing while still missing the rules that matter. Catching every weak point by hand gets repetitive.

In this project, you will build an n8n workflow that improves an AI-written draft through a reflection loop. You will cap the loop so each run stops after a passing score or a fixed number of attempts.

What You'll Build

You run your own writing through a visual workflow where each visible pass raises the score before the loop stops safely.

By the end of this project, you'll have:

A workflow that turns your writing prompt into a visible first draft you can inspect in the node output.
A critic that grades each draft against an explicit checklist. You can inspect its score plus the problems it finds.
A rewrite loop that lets you compare versions across passes. A score threshold plus a pass cap stops the workflow safely.
Secret Mission: An optional challenge to push your reflection workflow skills further.

Are there any prerequisites?

You need access to an n8n instance through self-hosting or the free trial. You also need a model API key for the workflow's draft, critique, and rewrite calls.

Before We Start

A reflection loop needs a live n8n canvas before it can run. The canvas makes each draft visible as it moves through the workflow.

The loop also needs access to an AI model. A short prompt gives every pass the same starting point.

In this step, get ready to:

Start an n8n Cloud workspace in your browser.
Add an API credential for your chosen model provider.
Prepare a short writing prompt for the first draft.

Start your n8n workspace

n8n Cloud hosts your instance for you. You can reach the workflow editor in a browser without installing anything locally.

How does the free trial work?

Starting a trial can feel like a commitment. The n8n Cloud free trial lasts 14 days.

The trial expires automatically without charges if you do not upgrade.

Open the official n8n Cloud guide in a new browser tab.
Select Start free trial.
Enter your account details in the signup form.
Complete any account verification that n8n requests.
Wait for your workspace to load in the browser.

You'll see the n8n Overview page with the Create control available. This confirms that your instance is running.

You're in. Your browser now has the canvas that holds the entire reflection loop.

Can't reach your workspace?

Check that you completed the account verification step. Return to the n8n sign-in page if your session expired.

Confirm that your browser allows the n8n Cloud page to load. Disable any extension that is blocking the page.

help me troubleshoot access to my n8n Cloud workspace. If the issue depends on your account, ask the n8n community.

Add an AI provider credential

An API credential lets n8n authenticate with your model provider. n8n encrypts the credential data it stores.

Keep your API key private

A live API key can authorize model calls that consume provider credits. Paste it only into the n8n credential form.

Never enter the key into this project page. Keep it out of screenshots.

Do you already have an API key from a model provider?

✔️ I already have an API key

Keep your provider API key ready in its secure storage.
Leave the key hidden until the n8n credential form asks for it.

ⓧ I need an API key

Each model provider has its own account requirements. Use the provider-specific instructions linked from n8n's documentation.

Open the n8n credentials library.
Select the model provider you want to use.
Follow the linked provider instructions to create an API key.
Copy the key when you are ready to paste it into n8n.

Return to the n8n Overview page from earlier.
Select Create in the upper-right corner.
Select Credential.
Choose your model provider from the available services.
Enter the authentication details requested by your provider.
Save the credential.

n8n tests the credential when you save it. You'll see a confirmation when the provider accepts the authentication details.

That sensitive setup is complete. n8n can now authenticate model calls without placing your key inside a workflow node.

Credential test not passing?

Check that the credential type matches your model provider. Paste the key again if it contains an accidental space.

Review the provider's account requirements if the key is valid but model access remains unavailable.

help me troubleshoot my n8n model credential. If the problem depends on your provider account, ask the n8n community.

Prepare a sample writing prompt

Your first model node needs one repeatable writing request. A focused prompt makes later drafts easier to compare.

What makes a useful sample?

A concrete writing task gives the draft node a clear job.
A named audience gives the critic a standard for judging clarity.
A requested tone gives the rewrite node a measurable target.

Choose a short writing situation from work or study.
Name the intended audience in your prompt.
Specify the tone you want the model to use.
Enter your finished prompt in the checkpoint below.

Before you check, do you think your setup now covers a place to run the loop, a way to call a model, and a stable input?

Return to the n8n Overview page from earlier.
Confirm that your saved credential appears in your personal space.
Close any credential form that could show a sensitive field.

You'll see your n8n workspace with the saved credential available. Your sample writing prompt is recorded in the checkpoint above.

Your workspace, model access, and sample prompt are ready. Next, you'll build the first draft node and inspect what the model produces.

Generate a First Draft

Every improvement loop needs a baseline. In n8n, that baseline is the untouched first response from an AI model.

Here, you'll build the starting path of the workflow. A Manual Trigger sends your sample writing prompt to Draft Writer so you can inspect the draft before any critique changes it.

In this step, get ready to:

Create a workflow named AI Draft Critique and Fix Itself with a Manual Trigger.
Configure a Draft Writer model node with your saved credential plus your sample writing prompt.
Run the workflow to inspect the generated first draft.

Create the workflow start

A manual trigger keeps every test run under your control. This gives you a repeatable starting point for the reflection loop.

Return to the n8n browser tab from earlier.
Select Create in the upper-left side menu.
Select workflow.
Select the workflow name in the editor header.
Enter AI Draft Critique and Fix Itself in the workflow title field.
Select Add first step... on the empty canvas.
Search for Manual Trigger.
Select Manual Trigger from the results.

Good start. Your canvas now shows one Manual Trigger node beneath the workflow name you entered.

Can't find Manual Trigger?

Clear the node search field. Search for Manual Trigger again.

Choose the trigger designed for workflows that run when you select Execute Workflow.

Help me find the Manual Trigger node in n8n.

Configure the Draft Writer

Draft Writer is the first model pass. Its prompt pairs a drafting instruction with your sample request.

Close the Manual Trigger details panel.
Select the Add node connector on the Manual Trigger node.
Search for your model provider.
Select the text-generation action for your model provider.

The model node opens on the canvas with a line from Manual Trigger. That line fixes the execution order.

Select your existing model credential in the credential selector.
Choose a text-generation model available to that credential.

The node now shows the saved credential. It also shows the selected model.

Enter an instruction that asks the model to produce a clear first draft in the prompt field.
Paste your sample writing prompt beneath that instruction.

The prompt field now contains your drafting instruction above your sample request.

Close the model node details panel.
Open the model node's context menu.

The context menu includes the Rename node action.

Select Rename node.

The node label becomes editable.

Type Draft Writer as the new node name.
Press Enter.

You should now see Manual Trigger connected directly to Draft Writer on the canvas.

Can't configure the model node?

Choose a model node that accepts a text prompt. It must return generated text.

Confirm that the saved credential belongs to the same provider as the model node.

Help me configure my n8n model node for text generation.

Inspect the first draft

A manual execution lets you test the full path from the trigger to the model. The output panel shows exactly what Draft Writer returned.

Before you run the workflow, make a quick prediction about the first draft you expect from the sample prompt.

Select Execute Workflow at the bottom of the editor.
Select the Draft Writer node after the execution finishes.
Open the OUTPUT section in the node details.

You should see generated first-draft text that responds to your sample writing prompt.

That is your baseline captured. Draft Writer now produces text that the next model step can critique.

What does this run prove?

Manual Trigger starts the workflow on demand.
Draft Writer sends your prompt through the configured model credential.
The output panel preserves the generated text for inspection.

No draft in the output?

Confirm that a connection line runs from Manual Trigger to Draft Writer.
Return to the Draft Writer node from earlier.
Confirm that its saved credential matches the model provider.
Check that the prompt field contains your drafting instruction above your sample request.

Help me troubleshoot an empty Draft Writer output in n8n.

Your first draft now has a visible starting point. Next, you'll add a critic that scores this text against a checklist.

Critique the Draft

Your n8n workflow now produces a first version to improve. The output from Draft Writer proves the opening model pass works.

A first draft still needs a consistent test. In this step, a Critic node grades it against four writing rules before identifying specific problems.

In this step, get ready to:

Duplicate Draft Writer to create Critic.
Configure a four-part checklist for evaluating the draft.
Run the workflow to inspect the structured critique.

Add the Critic node

The Critic uses the same model setup as the writer. Duplicating Draft Writer preserves that setup while giving the new node a separate job.

Hover over Draft Writer on the workflow canvas.
Open the Node context menu.
Select Duplicate node.

You should see a second model node beside Draft Writer.

Select the copied model node.
Press F2 to rename it.
Type Critic.
Press Enter.

The canvas now shows separate Draft Writer and Critic nodes.

Connect the output of Draft Writer to the input of Critic by dragging between their connectors.

You should see one connection running from Manual Trigger to Draft Writer. A second connection should run from Draft Writer to Critic.

Connection missing?

Make sure the line starts at the output connector on Draft Writer. It must finish at the input connector on Critic.

If the nodes overlap, move Critic to the right before drawing the connection.

help me connect these n8n nodes

Configure the critique checklist

A useful critic needs explicit standards. It also needs a predictable JSON structure so later nodes can read the result without guessing.

Open Critic by double-clicking the node.
Select the same AI-model credential used by Draft Writer.
Replace the copied writing prompt by pasting this critique prompt:

You are a strict writing critic.

Evaluate the draft against this checklist:
- Clarity: The writing is easy to understand.
- Correctness: The claims are accurate and internally consistent.
- Completeness: The draft includes the information needed to fulfil its purpose.
- Concision: Every sentence earns its place.

Give the draft a score from 0 to 100. Higher scores represent stronger writing.
List every concrete problem that should be fixed.
Return only valid JSON.
Use exactly these keys:
{
  "score": 75,
  "problems": [
    "The opening sentence is vague."
  ]
}

Draft:
{{ $json.draft }}

What makes this critic useful?

Clarity checks whether a reader can follow the writing easily.
Correctness checks the draft for inaccurate claims or contradictions.
Completeness checks whether the draft fulfils its purpose.
Concision finds sentences that add little value.
The score turns overall quality into a numeric value.
The problems list gives the next model specific issues to fix.

Check the final line of the prompt for the {{ $json.draft }} expression.
Return to the workflow canvas.

The expression pulls the incoming draft value into the checklist prompt during each execution.

Draft value not resolving?

Check that Draft Writer outputs a field named draft. The field name is case-sensitive.

Make sure the prompt ends with {{ $json.draft }}. A missing brace prevents the expression from resolving.

help me fix the draft expression

✔️ Awesome, I've got everything!

Your workflow now has Manual Trigger connected to Draft Writer. Draft Writer is connected to Critic.

ⓧ I'd like to double check the full setup

Confirm that Draft Writer generates draft from the sample writing prompt. Confirm that Critic uses the same configured AI-model credential.

The complete Critic prompt should match this reference:

You are a strict writing critic.

Evaluate the draft against this checklist:
- Clarity: The writing is easy to understand.
- Correctness: The claims are accurate and internally consistent.
- Completeness: The draft includes the information needed to fulfil its purpose.
- Concision: Every sentence earns its place.

Give the draft a score from 0 to 100. Higher scores represent stronger writing.
List every concrete problem that should be fixed.
Return only valid JSON.
Use exactly these keys:
{
  "score": 75,
  "problems": [
    "The opening sentence is vague."
  ]
}

Draft:
{{ $json.draft }}

Run and inspect the critique

The node is ready to judge a fresh draft. A full manual execution proves that data crosses both connections before the Critic produces its result.

Before you run the workflow, which checklist category do you expect to uncover the most problems?

Select Execute Workflow on the workflow canvas.

You should see Manual Trigger, Draft Writer, and Critic complete in sequence.

Open the completed Critic node.
Select JSON in the OUTPUT panel.

You should see a numeric score. You should also see a problems list containing specific weaknesses from the draft.

Critique missing or unstructured?

If Critic has no input, inspect the connection from Draft Writer on the canvas.

If the response includes extra commentary, check that the prompt says to return only valid JSON. Run the workflow again after correcting the prompt.

help me fix the Critic output

That is the second model pass working. Your workflow can now turn a draft into a measurable critique with specific problems.

Your workflow can now judge its own first draft. Next, you will add a rewrite step that uses these problems to produce a stronger version.

Rewrite Using the Critique

The Critic now returns a numeric score plus a concrete problems list. That gives your reflection pattern a target for the next pass.

A rewrite can lose the original meaning when it sees feedback without the source text. You will add a Rewrite node in n8n. Data mapping will place the draft plus critique in one prompt.

In this step, get ready to:

Add a Rewrite model node after Critic.
Build a rewrite prompt from draft, score, and problems.
Compare the original draft with the improved rewrite.

Add the Rewrite node

The new model step can reuse the provider setup from Draft Writer. Duplicating that node preserves its existing model configuration.

Hover over Draft Writer on the workflow canvas.
Open the Node context menu.
Select Duplicate node.
Drag the duplicate to the right of Critic.
Open the Node context menu on the duplicate.
Select Rename node.
Enter Rewrite as the node name.
Connect the output of Critic to the input of Rewrite by dragging between their connection points.

You should see a connection from Manual Trigger to Draft Writer. The path should continue through Critic to Rewrite.

Why Duplicate Draft Writer?

The duplicate already contains the configured model credential. You can focus on changing its purpose from writing a first draft to producing a revision.

Connection Missing?

Confirm the connection line reaches the left input of Rewrite. A disconnected node cannot receive the critique.

Check that the duplicated node was renamed exactly Rewrite.

help me connect my Critic and Rewrite nodes in n8n

Map the draft and critique

The rewrite needs the source text plus the critic's evidence. Each mapped value gives the model a different part of the revision job.

Open the Rewrite node.
Replace the duplicated writing prompt with sections for the original draft, critic score, problems to fix, and rewrite instruction.
Select Draft Writer in the INPUT pane to reveal its earlier output.
Drag draft into the original draft section of the prompt.

The prompt preview should now contain the original draft text. This confirms that Rewrite can reach data from an earlier node.

Select Critic in the INPUT pane.
Drag score into the critic score section of the prompt.
Drag problems into the problems to fix section of the prompt.

The prompt preview should now show the numeric score plus the list of identified problems. All three inputs are ready for the revision.

Write the rewrite instruction so the model fixes every identified problem while preserving accurate content from the original draft.
Change the duplicated output field from draft to rewrite in the same output setting used by Draft Writer.

Why Pass All Three Values?

The draft carries the content that must be revised. The problems list identifies the weak points.

The score summarizes the critic's overall judgment. Together, these inputs keep the rewrite focused on evidence.

✔️ My Rewrite node is ready

Your Rewrite node now receives the original draft plus the structured critique. Its output is named rewrite.

ⓧ I'd like to double check the workflow

Your canvas should show Manual Trigger connected to Draft Writer. Draft Writer should connect to Critic.

Critic should connect to Rewrite. Rewrite should use the configured AI-model credential.

The Rewrite prompt should supply draft, score, and problems. It should request an improved rewrite that fixes the identified problems.

Compare the original with the rewrite

A revised answer becomes useful when you can trace its changes back to the critique. The node's execution data places the source and result within the same view.

Before you run Rewrite, which critic problem do you expect the revised version to address most clearly?

Run the workflow through Rewrite by selecting Execute step in its node controls.

You should see a completed execution with revised text under rewrite in the OUTPUT pane.

Keep Rewrite open in the execution data.
Locate the original draft inside the rendered prompt in the INPUT pane.
Locate the revised rewrite in the OUTPUT pane.
Compare each item from problems against the revised text.

You should see the original draft beside a revision that addresses the critic's specific feedback. The topic should remain consistent across both versions.

Rewrite Missing or Unchanged?

If the output is missing, confirm that the duplicated output field is named rewrite.

If the result repeats the original draft, confirm that you fully replaced the duplicated writing prompt. Check that score plus problems appear in the rendered prompt.

help me debug my Rewrite node

You now have your first self-corrected draft. The execution data shows exactly how the critique changed the writing.

Next, you will route the rewrite back into the critic so the score can improve across multiple passes.

Loop the Critique and Rewrite

Your first revision proves that the three-node sequence can improve a draft once. The execution data in n8n shows both versions.

A single pass leaves useful feedback unused. A reflection loop sends each rewrite back through Critic so the workflow can improve it again.

In this step, get ready to:

Connect Rewrite back to Critic.
Route each rewrite into Critic as the next current draft.
Compare score values across repeated passes.

Connect Rewrite back to Critic

A loop is a connection that returns later output to an earlier node. Here, Rewrite becomes Critic's second input path.

Switch back to the AI Draft Critique and Fix Itself workflow canvas from earlier.
Create the return path by dragging Rewrite's output connector onto Critic's input connector.

You should now see one connection entering Critic from Draft Writer. A second connection should enter Critic from Rewrite.

Why Does This Form a Loop?

n8n sends each node's output to the next connected node. The return connection makes Rewrite's output arrive at Critic as fresh input.

Can't Connect Rewrite to Critic?

Zoom the canvas out until both node connectors are visible.
Start the drag from Rewrite's output connector.

Ask for help if the return connection still does not appear: help me connect Rewrite back to Critic in n8n.

Route each rewrite into the next critique

Critic already evaluates the first-pass value under draft. The returning item carries improved writing under rewrite.

Double-click Critic to reopen its configuration.
Update the prompt's current-writing section to evaluate whichever incoming writing value is populated. Use draft for the first pass. Use rewrite for later passes.
Keep the clarity, correctness, completeness, and concision checklist unchanged.

Critic now applies the same checklist to the initial draft or the latest rewrite. Each response still produces numeric score plus problems.

✔️ My loop is connected

Your return connection is ready. Critic can now receive writing from either Draft Writer or Rewrite.

ⓧ I'd like to double check the workflow

Manual Trigger starts Draft Writer.
Draft Writer generates the initial draft.
Critic evaluates the current draft with the clarity, correctness, completeness, and concision checklist.
Critic returns numeric score plus problems.
Rewrite receives the current draft, score, and problems.
Rewrite creates rewrite.
Rewrite connects back to Critic so the next reflection pass uses rewrite as the current draft.

Watch the loop repeat

Keep This Test Short

Each pass sends more requests to your AI model. A short manual test keeps the experiment controlled.

Before you run the workflow, which pair of nodes do you expect to repeat once Rewrite sends its output backward?

Run the workflow by selecting Execute Workflow.

You should see Critic process the initial draft. Rewrite then produces a revision before both nodes begin repeating.

Let Rewrite complete three passes.
Stop the manual run with the active execution control at the bottom of the canvas.
Double-click Critic to inspect its repeated outputs.
Choose the JSON view to see score and problems for each pass.
Move through the available Critic runs to compare their score values.
Double-click Rewrite to compare its repeated rewrite values.

You should see at least three sets of execution data. A later score should be higher as Rewrite addresses the listed problems.

The nodes kept repeating until you intervened. That continuing cycle is the intended shortfall in this version of the workflow.

Scores Not Improving?

Check that Critic uses the incoming rewrite value on loop passes.
Check that Rewrite still receives the current draft, score, and problems.
Confirm that Critic still uses the clarity, correctness, completeness, and concision checklist.

Ask for help with the execution data: help me find why my reflection loop scores are not improving.

That is the heart of reflection working: each rewrite becomes fresh material for the next critique. Next, you'll add a score gate and a pass counter so the loop can stop by itself.

Set the Quality Gate

Your Critic scores every draft. Rewrite uses the feedback to create a stronger version.

The n8n loop has no stopping rule yet. A stubborn score can keep model calls running.

In this step, get ready to:

Track passCount for every reflection pass.
Add a quality gate with a score threshold plus a pass cap.
Confirm deliberately bad input exits at the pass cap.

Track each reflection pass

A pass counter gives every trip through the reflection loop a number. The quality gate can use that number to enforce a firm limit.

Switch back to the AI Draft Critique and Fix Itself workflow from earlier.
Select the connection from Rewrite to Critic.
Press Backspace (macOS) or Delete (Windows) to remove the connection.

Before you run the open path, where do you expect the execution to stop?

Select Execute Workflow.

Good. The execution now stops after Rewrite instead of starting another reflection pass.

Add an Edit Fields (Set) node from Rewrite's output by using the plus icon.
Configure a Number field named passCount with the expression {{ $runIndex + 1 }}.

Before you run the workflow, what number should the first completed rewrite receive?

Select Execute Workflow.

You should see passCount equal 1 in the new node's output.

How Does passCount Work?

The $runIndex value starts at 0 for a node's first run. Adding 1 turns it into a pass count that begins at 1.

Each return through this node increases its run index. That gives the gate an updated count without storing state elsewhere.

Set Include in Output to All Input Fields.
Rename the node pass-counter.
Select pass-counter on the canvas.
Select Execute step.

The output should retain the latest rewrite value. It should also contain passCount.

Missing the Rewrite or Pass Count?

Check that Include in Output is set to All Input Fields. This preserves the data produced by Rewrite.

Confirm that the field name is exactly passCount. Field names are case-sensitive.

help me debug my pass-counter node

Build the quality gate

A quality gate turns the Critic's score into a routing decision. Another pass runs only while the draft needs improvement within your safety limit.

Your passing bar is your score threshold. Your safety limit is your maximum pass count.

Add an If node from pass-counter's output.
Configure the first Number condition to check whether {{ $json.score }} is less than your score threshold.

Before you test this single condition, which branch should the current score take?

Select the If node.
Select Execute step.

You should see the item leave through the branch that matches the current score. This proves the score comparison is working.

Add a second Number condition that checks whether {{ $json.passCount }} is less than your maximum pass count.
Select AND between the two conditions.

Before you test both conditions, should one true condition be enough to continue?

Select Execute step again.

The node now sends data through its true output only when both comparisons pass. Either failed comparison sends the latest data through its false output.

Connect the If node's true output back to Critic.

Leave the false output as the end of the workflow. Its data includes the latest rewrite because pass-counter preserved every input field.

How Does the Gate Decide?

A score below the threshold means the draft still needs work. A pass count below the maximum means the workflow still has permission to try again.

The AND rule requires both checks to pass. The loop exits as soon as the draft reaches the quality bar or uses its final allowed pass.

Taking the Wrong Branch?

Confirm both conditions use the Number data type. Text comparisons can route numeric values unexpectedly.

Check that the score condition references score. Check that the counter condition references passCount.

help me debug my quality-gate conditions

Prove the pass cap works

A stopping rule matters most when the score never reaches the quality bar. This test forces that situation so you can watch the cap take control.

This run deliberately makes several model calls. Your maximum pass count keeps the test bounded.

Temporarily set the score threshold above the highest score your Critic can return.
Return to the Draft Writer node from earlier.
Replace its current writing input with deliberately poor writing that breaks several checklist rules.

Before you run the test, do you think the score gate or the pass cap will stop this execution?

Select Execute Workflow.

This execution can take longer than a single draft because each allowed pass calls the model again. Watch the node run counts while the workflow progresses.

Inspect the recorded runs for pass-counter after the execution finishes.
Inspect the false output from the If node.

You should see passCount reach your maximum pass count. The false output should contain the latest rewrite.

That is the safety rail working. Your reflection loop can improve a draft without running forever.

Restore the gate's score threshold to your score threshold.
Confirm the gate still uses your maximum pass count.

Did the Loop Miss the Cap?

Confirm the pass condition uses is less than. Using an inclusive comparison allows one extra pass.

Confirm the conditions are joined by AND. The true output should be the only output connected back to Critic.

help me stop my reflection loop at the pass cap

✔️ My loop stops safely

Your counter and quality gate now give every execution a predictable exit.

ⓧ I'd like to double check the workflow

The workflow contains Manual Trigger, Draft Writer, Critic, Rewrite, a pass-counter control node, plus a quality-gate decision node. Manual Trigger starts Draft Writer to generate the initial draft.

Critic evaluates the current draft with the clarity, correctness, completeness, plus concision checklist. It returns numeric score plus problems.

Rewrite uses the current draft, score, plus problems to create rewrite. The pass counter initializes and increments passCount for every reflection pass.

The quality gate loops rewrite back to Critic only when score is below your score threshold while passCount is below your maximum pass count. Otherwise, the workflow exits with the latest rewrite.

A deliberately bad-input test confirms that execution exits on the maximum pass count.

Your reflection loop now has a measurable quality bar plus a firm stopping point. Next, you can run the finished workflow on a real piece of your own writing.

Save and Test the Workflow

Your reflection loop already survives its hardest test. It stops at the pass cap when deliberately bad input never reaches the score gate.

Now turn that controlled test into a finished n8n workflow for real writing. You will confirm the final output before exporting a JSON backup.

In this step, get ready to:

Confirm the finished workflow is saved.
Run the complete reflection loop on your own writing.
Export the workflow as a JSON backup.

Confirm the workflow is saved

n8n saves edits automatically. A brief delay of up to five seconds is normal while the latest draft is stored.

Return to the workflow canvas from the previous step.
Confirm the title at the top reads AI Draft Critique and Fix Itself.
Wait five seconds for the latest changes to finish saving.
Refresh the browser page.

You should return to the same workflow with Manual Trigger, Draft Writer, Critic, Rewrite, the pass-counter, and the quality gate still connected on the canvas.

Missing part of the workflow?

If a recent change disappears after the refresh, return to the previous browser tab or restore the missing connection before continuing.

Check that the pass-counter still feeds the quality gate. Check that the loop branch still returns the latest rewrite to Critic.

help me check my reflection workflow

Run the workflow on your writing

A real writing sample proves the loop can produce a useful result outside the deliberately bad test. The final execution should still respect both stopping conditions.

Select the Draft Writer node on the canvas.
Replace the deliberately bad writing sample from the previous test with a real piece of your own writing.
Close the Draft Writer node panel.

Before you run it, ask yourself: will your writing pass the score gate or reach the pass cap.

Start the end-to-end run by selecting Execute Workflow.

You should see the execution travel from Manual Trigger through the writing nodes. Any reflection passes should follow the loop before the quality gate sends the final result to the exit branch.

Select the final executed node on the quality gate's exit branch.
Review the latest rewrite in its output panel.
Select the final execution of the Critic node.
Confirm its score is numeric.
Select the final execution of the pass-counter node.
Confirm passCount does not exceed your chosen maximum.

You should see the latest rewrite on the exit path. You should also see a numeric score with passCount no higher than your chosen maximum.

That proves the complete loop can improve your writing without losing its stopping guardrails.

Did the end-to-end run stop early?

If the run stops at Draft Writer, check that the node still contains your writing sample. Confirm that its model credential remains selected.

If the loop reaches the pass cap, inspect the final numeric score. Confirm that the quality gate compares it with your chosen threshold.

help me debug my end-to-end reflection run

Export the workflow JSON

A workflow export gives you a portable record of the finished canvas. The backup preserves the setup you just tested.

Keep the export private

This backup is safe to keep for yourself. The exported file can include credential names and credential IDs.

Keep the file private. Remove identifying details before sharing it.

Return to the workflow canvas from the completed execution.
Select the three dots in the upper-right corner.
Select Download.

Before you check the file, ask yourself which workflow pieces the export should preserve.

Open your browser's downloads list.
Locate the newest file ending in .json.
Confirm the JSON file finished downloading.

You should see a downloaded JSON file for the saved AI Draft Critique and Fix Itself workflow. It preserves the nodes, connections, prompts, pass counter, and quality-gate configuration.

Can't find the JSON file?

Check whether your browser blocked the download. Allow the file if a download notice appears.

Return to the canvas menu if no file appears. Select Download again.

help me find my n8n workflow export

✔️ My workflow and export are ready

Great. Keep the downloaded JSON file somewhere private so you can restore or inspect the workflow later.

ⓧ I'd like to double check the full workflow

Use this checkpoint to compare your finished workflow with the required end state.

Confirm the saved workflow contains Manual Trigger, Draft Writer, Critic, Rewrite, a pass-counter control node, and a quality-gate decision node.
Confirm Draft Writer generates the initial draft.
Confirm Critic returns a numeric score plus problems using the clarity, correctness, completeness, and concision checklist.
Confirm Rewrite creates rewrite from the current draft, score, and problems.
Confirm passCount increments on every reflection pass.
Confirm the quality gate loops only while score is below your threshold and passCount is below your maximum.
Confirm the exit path returns the latest rewrite.
Confirm the workflow completed an end-to-end run on your own writing.
Confirm the downloaded JSON file preserves the finished workflow.

You have now tested the reflection loop on your own words and secured a copy of the finished workflow. Your draft, critique, rewrite, score gate, and pass cap now work as one complete system.

Secret mission

Build a Reflection Test Suite

Stress-test your reflection loop with three controlled writing samples. Compare score, problems, and passCount, then restore the saved workflow.

Clean Up Your Resources

Choose a cleanup option based on whether you plan to run the n8n workflow again. Each future run can consume model credits.

Resources you used:

Running n8n instance used to execute the reflection loop.
Saved workflow AI Draft Critique and Fix Itself containing the model steps and loop controls.
Exported workflow JSON file stored in the location you chose earlier.

Keep everything running

No action is needed. Choose this if you are still testing the reflection loop or refining its prompts.

Keep the n8n instance running while you are actively testing the workflow.
Keep the saved workflow AI Draft Critique and Fix Itself available for future runs.
Keep the exported workflow JSON file as your recovery copy.
Review your AI-model provider usage after future runs to track model-credit consumption.

Pause - I'll come back to this later

Stop the running instance to pause the project. Your saved workflow and exported file remain available for your return.

Return to the hosting controls you used earlier for the n8n instance.
Stop the running n8n instance with those controls.
Refresh the existing n8n browser tab to verify that the workflow editor is no longer accessible.
Keep the saved workflow AI Draft Critique and Fix Itself in your n8n storage.
Keep the exported workflow JSON file in its current location.

Delete - I don't want to use this again

Deleting the saved workflow removes it from n8n. Your exported JSON remains a recovery copy until you delete that file too.

Delete the saved workflow

Return to the n8n browser tab from earlier.
Select AI Draft Critique and Fix Itself from the workflow list.
Use the deletion control in the workflow menu to remove the workflow.
Return to the workflow list.

You should no longer see AI Draft Critique and Fix Itself in the workflow list.

Stop the n8n instance

Return to the hosting controls you used earlier for the n8n instance.
Stop the running n8n instance with those controls.
Refresh the existing n8n browser tab.

You should no longer be able to load the workflow editor from that instance.

Delete the exported workflow file

Find the exported workflow JSON file in the location you chose earlier.
Delete the exported workflow JSON file using your computer's file browser.
Return to the file's original location.

You should no longer see the exported workflow JSON file in that location.

Nice Work!

You did it! Your n8n workflow now improves writing through a bounded reflection loop.

You've learned how to:

Generate an initial draft with the Draft Writer node.
Score each draft with the Critic node. Feed its problems into Rewrite to produce a stronger rewrite.
Control the reflection loop with passCount plus a score threshold. Confirm that weak input exits at the pass cap. Export the workflow as JSON for safekeeping.
Secret Mission: Take on an optional challenge to push your reflection workflow skills further.

Ready to quiz yourself?