← Back to all free guides

The AI Feedback
Loop Nobody Builds

Your AI writes a draft. You make your final edits and publish. Then the lesson dies and next week it makes the same mistake. Here’s how to make your skill learn from every edit.

A skill that gets smarter every time you use it. Almost nobody sets this up.

Here’s the loop. Your skill writes a draft. You edit and publish. Then you hand the published version back and make it compare the two, pull out the edits that will happen again, and write those rules into its own instructions. The actual file that tells it how to work, not a memory it might forget.

Your final edit is the answer key. What you decided was good enough to ship is the one piece of evidence that can’t be argued with.

The Loop At A Glance

1. Your skill hands you a draft. 2. You edit and publish. 3. The agent compares its draft to your final version. 4. The edits that will repeat get written into SKILL.md. 5. The next run starts smarter.

I run this on the email agent for my clothing brand. It drafts, my team edits, we send, then the agent reads the sent version against its draft. Two months in, the drafts need a lot less work. It works on anything a person edits before it goes out, like a newsletter, proposals, product descriptions, job posts or ad copy.

Why This Beats "Review Your Own Draft"

A model grading itself grades against its own taste, and its taste is what was wrong. Your edit is outside evidence.

Setup: Two Folders And One File

Two minutes, once. This runs in Claude Code, because the agent needs to read your files and edit its own skill.

The file. A skill is a text file named SKILL.md in its own folder, either personal (~/.claude/skills/newsletter/SKILL.md, available everywhere) or in the project (.claude/skills/newsletter/SKILL.md, shared with your team). Claude Code watches those folders, so an edited skill takes effect in the session you’re already in. One catch: if the skills folder didn’t exist when you started the session, run /reload-skills once. (Claude Code docs) Never built a skill? Start with 3 Ways To Build A Claude Skill.

The folders. Make drafts/ and published/ in your project. Every piece gets the same filename in both, a date then a short slug, like drafts/2026-11-01-welcome-email.md and published/2026-11-01-welcome-email.md. Matching names is how the agent finds the pair.

Do This First

If the skill came from a plugin, copy it into ~/.claude/skills/ and work on your copy. Plugin updates install a fresh copy in a new location, so rules written inside the plugin’s folder can disappear. (plugin docs)

Three Moves, Every Publish

01

Save the raw draft before anyone edits it

The moment the agent finishes, the draft has to land in a file, not the chat and not the doc you’re about to edit. You can’t compare two versions if you only kept one.

Add one line to the bottom of your skill file so it happens on its own: "When you finish a draft, save it to drafts/ as YYYY-MM-DD-slug.md before showing it to me."

02

Save what actually shipped

After it goes out, copy the exact final version, including any last-second change someone made in the email tool at 11pm, into published/ with the matching filename. Thirty seconds.

03

Run the engine

This prompt reads both versions, lists what changed, keeps only the edits that will happen again, and writes them into your skill file after you approve them. Swap in your file paths and change nothing else the first few times.

The Engine Prompt
You are my editor's apprentice. Your job is to compare what my skill drafted with what I actually published, and turn my edits into rules so the next draft needs less work. DRAFT, what you wrote: drafts/[YYYY-MM-DD-slug].md PUBLISHED, what we sent: published/[YYYY-MM-DD-slug].md SKILL FILE: ~/.claude/skills/[skill-name]/SKILL.md Work in this order and do not skip ahead. 1. Read both files all the way through. If almost nothing changed, say so and stop. A piece that shipped 95 percent intact has nothing to teach. 2. List every difference. For each one give me the draft version quoted exactly, the published version quoted exactly, and one type: FACT, TONE, STRUCTURE, LENGTH, FORMATTING, or MISSED (something required that was left out of the draft). 3. Sort each difference into REPEATABLE or ONE-OFF. REPEATABLE means a person would make this same edit again on the next piece of this type. ONE-OFF means it was about this one piece, this one week, this one promotion. When you cannot tell, mark it ONE-OFF. Being wrong that way costs nothing. Being wrong the other way puts a permanent bad rule in my instructions. 4. Write each REPEATABLE edit as an instruction, not an observation. "Be more concise" is useless. "Cut the opening to two sentences, never three" is a rule. Each one must be specific enough that a freelancer could follow it on the first try without asking me. 5. Show me the proposed rules and STOP. Let me delete the ones I disagree with before you touch any file. 6. Once I approve, add them to the skill file under a heading called "## Learned Rules" near the bottom. Never touch the frontmatter or my original instructions, only that section. Each rule is one line, in this shape: - [YYYY-MM-DD] RULE: (the instruction) | WHY: (the edit that taught it) If a new rule repeats one already there, sharpen the existing one and update its date instead of adding a duplicate. Guardrails: never edit the files in drafts/ or published/. Never add a rule based on a single typo fix. If the skill file has no "## Learned Rules" section yet, create it, and tell me you did.

Expect three to eight rules on the first run, and most will be right, because your edits are more consistent than you think. The next thing you ask it to write already follows the new rules. Reading the proposed rules and cutting the bad ones takes thirty seconds and is the only quality control this loop has, so don’t skip it.

Keep The File From Getting Fat

This quietly kills these loops. Month one you have six sharp rules and better drafts. Month four you have sixty, some repeat, two contradict each other, and the output is worse than it was at rule fifteen. A learning loop with no pruning is a hoarding loop.

One prompt runs the whole prune pass:

The Prune Pass
You are cleaning up a skill file that has been learning from my edits. Run a prune pass on it. FILE: ~/.claude/skills/[skill-name]/SKILL.md CAP: 15 rules under "## Learned Rules" 1. List every rule with its date and how old it is, and the total count against the cap. 2. DUPLICATES. Group rules that would produce the same edit, even if worded differently. Propose one merged rule per group, sharpest wording, newest date. 3. CONTRADICTIONS. Show any pair of rules that cannot both be followed at once. Do not resolve them yourself, ask me which wins. 4. DEAD RULES. Read the last 8 pairs in drafts/ and published/. For each rule, tell me whether that pattern actually showed up in any of those 8. If it did not appear once, mark it DEAD and propose deleting it. 5. VAGUE RULES. Flag any rule with "better", "more", "less", or "as needed" in it, the kind a new freelancer could not follow. Rewrite it as something specific, or propose deleting it. 6. If the list is still over the cap, rank the survivors by how often the pattern appeared in the last 8 diffs and show me the bottom 5. Show me the whole plan before you change one line. I approve, then you edit.

The Test For Every Rule

Could a freelancer who started this morning follow it without asking a question? "Be more concise" fails. "Product descriptions are 40 words or fewer" passes.

Run It Once This Week
  1. Pick the piece you edit the hardest. Whatever you rewrite the most is where the most learning is sitting.
  2. Make drafts/ and published/, and copy the skill out of any plugin into ~/.claude/skills/.
  3. Save the next draft before anyone edits it. This is the step you’ll forget, so set a reminder.
  4. Publish like normal, then paste the final version into published/ with the matching filename.
  5. Run the engine prompt and cut the rules you disagree with. Do it four times before you judge it.

Almost nobody has this running because the edit feels finished the moment you hit publish. Every edit you make is training data, and right now you’re throwing it away. For the theory underneath, Loop Engineering covers what a loop actually is.

If You Commented IMPROVE

You have everything you need on this page. Start small and keep going. Save your next draft before anyone touches it.