Loops: How to Make Claude Fix Its Own Work Before You See It

Here's how almost everyone works with AI right now

You write a prompt, you read the answer, you spot what's wrong, you write another prompt with the fixes, you read again, you correct again, ten times in a row, and you are the one carrying every single round

A loop flips that

You define once what "done" looks like, then Claude generates, checks its own work against that standard, fixes what failed, and checks again, all inside a single task, before it ever shows you anything

You stop being the person who edits, you become the person who set the bar

This article shows you exactly what a loop is, how to set one up in your Claude settings, and three you can copy tonight, no code, no terminal, just Claude Chat or Cowork

Part 1: What a loop actually is

Normal prompting is one attempt for one result, you ask, Claude answers, and if it's off you fix it by hand, the quality of the output depends on you catching every flaw yourself

A loop is different, Claude checks its own work against a condition you set, and if it doesn't pass, it rewrites and checks again, it keeps going until the work clears the bar, and only then does it show you the result

Here's the mindset shift that makes it click: you stop trying to write the perfect prompt on the first try, instead you set the "done or not done" condition once and let Claude spin against it until it reaches done

You're not describing the answer anymore, you're describing what a good answer has to survive

Part 2: The anatomy of a loop

Every loop has four parts, and all four happen automatically inside a normal chat once you've set it up, miss one and it falls apart

What needs to happen and what "done" actually looks like, this is the target the loop aims at, you write it like any normal request, "write a post about X," a vague goal means a loop that never knows when to stop

The saved criteria Claude checks its own work against, your voice rules, the hook, the banned words, the length limit, you create this once as a skill and load it into your settings, from then on Claude applies it on its own whenever a matching task shows up

The pass or fail check that decides whether to try again or stop, the gate is what turns a one-shot answer into a loop, Claude runs its draft against the skill, if it fails the gate, it goes back and rewrites, no gate, no loop

What the loop has already tried, Claude holds this as it works so it doesn't repeat the same weak line or make the same mistake twice, each attempt starts smarter than the last, all of it inside the one task, nothing for you to manage

Task sets the target, the skill sets the standard, the gate makes the decision, memory keeps it moving forward, that's the whole machine and it runs itself

Part 3: The one path that actually works

You don't wire anything up each time, you set the standard once and then you just work

Load the skill once, you create it as a file named SKILL.md that spells out your "done" criteria, pack it into a zip, and load that zip a single time in Settings, Capabilities, Skills, no code and no commands

Just give tasks like normal, from that point on you work in Claude Chat or Cowork exactly like you always did

You type "write a post," and Claude sees the task, pulls the matching skill on its own, and loops against it before answering

The part that makes this stick: you never re-explain the rules and you never turn anything on, the skill lives in your settings

So it's there in every chat and in Cowork, for you and for anyone on your team

The loop fires by itself every time a task matches, that's the difference between a trick you do once and a standard that just runs

Part 4: How to set it up, step by step

The measurable part in Step 1 is where loops live or die, if your standard is fuzzy, Claude can't tell pass from fail, and the loop either stops too early or never stops

Here's the template you build any skill from, not just the three examples further down, fields in brackets are yours to fill:

name: [name]
description: Use whenever I ask you to [describe the task, for example "write a post", "draft an email", "check data"], check the result against these rules before showing it to me

The task is done only when all of these are true:
- [rule 1]
- [rule 2]
- [rule 3]
- [rule 4]

If any rule fails, rewrite the weakest part and check again
Stop after [number] attempts and give me your best version with a note on what still didn't pass

Replace everything in brackets with your own task and criteria, that's your first loop ready to load

Part 5: One example, start to finish

Watch a content loop run once, all the way through, with a voice skill already loaded in your settings

You type a normal task: turn these rough notes into a finished post

Claude sees it's a writing task and pulls your voice skill on its own

It writes a first draft, then checks that draft against the skill, the draft is 180 words and opens with a weak line, two rules fail, the gate says not done

It rewrites, cuts to 140 words, sharpens the hook, and checks again

This time every rule passes, the gate says done, and only now does it show you the post

You sent one message and got a finished result, the drafting, the judging, and the fixing all happened inside that one task, you never saw the rough middle because Claude never handed it to you

Part 6: Three loops worth copying

Each one is just a different skill loaded in your settings, doing its work inside a normal chat or Cowork, copy any of these and change the rules to your own

Content loop

A voice and format skill that makes Claude check every post against your rules and rewrite until it passes, you ask for a post and what comes back is already on standard

name: content-check
description: Use whenever I ask you to write a post or article, check the result against these rules before showing it to me

The piece is done only when all of these are true:
- a hook in the first line that earns the second
- one clear idea, no rambling
- short sentences with no filler
- ends on a line that lands, not a limp summary

If any rule fails, rewrite the weakest part and check again
Stop after 4 attempts and give me your best version with a note on what still didn't pass

Outreach loop

A skill for pitches and applications, it runs your outgoing draft through your rules before it shows you the final version, so no raw first draft ever goes out

name: pitch-check
description: Use whenever I ask you to write a cold outreach message, pitch, or application, check the result against these rules before showing it to me

The message is done only when all of these are true:
- opens with something specific to the recipient, not generic
- states the ask in the first two lines
- under 120 words
- no corporate filler like "reaching out to" or "circle back"

If any rule fails, rewrite the weakest part and check again
Stop after 4 attempts and give me your best version with a note on what still didn't pass

Research loop

A skill that makes Claude verify each source and claim before it reports, anything it can't stand behind gets cut in the draft you never see, so what reaches you is already clean

name: source-check
description: Use whenever I ask you to research a topic or gather data, check the result against these rules before showing it to me

The research is done only when all of these are true:
- every claim has a source I can check
- anything uncertain is marked as uncertain, not stated as fact
- only what answers the question, no padding
- sources are recent and relevant, not random

If any rule fails, fix or cut the weakest part and check again
Stop after 4 attempts and give me your best version with a note on what still didn't pass

Same skeleton every time, task, skill, gate, memory, only the standard changes

Part 7: Where loops break, and the fix for each

The loop keeps rewriting forever and never lands, chasing a bar it can't clear

The fix: build a stop into the standard itself, tell Claude in the skill to stop after a set number of attempts and hand you its best version with a note on what still didn't pass

A soft gate waves bad work through as "done" because it's grading with all the context of how the work was made, so it goes easy on itself

The fix: write the skill to judge the finished work on its own, against the plain rules only, as if it had never seen the drafting, a fresh judge with no reason to cut itself slack

The loop loses track and repeats the same mistake attempt after attempt

The fix: tell the skill to keep a running note of what it already tried and what failed, so each new attempt builds on the last instead of circling

Conclusion

Most people will close this and go right back to it, write a prompt, read the answer, write the next prompt by hand, forever

The gap between that and a loop isn't about who's smarter with AI, it's about who stopped being the single link holding the whole process together in their own head

Write one skill tonight, on a task you already do every week, load it once, and the next time you ask for that task, there'll be nothing to fix, it's already done