1. What a self-improving agent loop actually is

A self-improving agent isn't a special model or a paid feature. It's a loop you put around any AI you already use. The loop has three beats, and once you see them you'll notice they're the same three beats behind every system that gets better over time — quality control in a factory, a postmortem in engineering, a coach's notes after a game.

The beats are: capture feedback → encode it as a rule or check → let it compound. When the agent does something wrong, you don't just fix this one output. You write down why it was wrong in a place the agent reads on every future run, and where you can you turn that lesson into an automated check the agent runs before it calls anything "done." The next time — and every time after — the mistake is already prevented.

The word that matters most is compound. A single correction is linear: it fixes one thing once. An encoded correction is exponential: it fixes that class of thing forever, and it stacks on top of every correction before it. Ten encoded lessons don't make your agent 10% better — they make it reliably better in ten dimensions at once, on work you'll never have to re-review.

The mental model: a one-off prompt is a conversation. A self-improving agent is a conversation that leaves a paper trail — and reads its own paper trail before it starts the next job.

2. One-off prompt vs. durable agent system

Almost everyone starts with one-off prompts, and for a while it feels productive. You ask, you correct, you get a good result. The problem is invisible until later: the lesson you just taught lives only inside that chat window. Open a fresh conversation tomorrow and you start from zero — same vague output, same correction, same wasted minutes. You're not building anything; you're re-teaching the same student every morning.

A durable agent system stores the lesson outside any single conversation, in context the agent loads every time it runs. That's the entire difference, and it changes the slope of your progress. Here's the contrast side by side.

💬

One-off prompt

Lives in a single chat. Corrections evaporate when the conversation ends. You re-explain the same preferences on every fresh start. Output quality plateaus because nothing accumulates.

"No, shorter. No bullet points. Use British spelling." …and again tomorrow.
🗂️

Durable agent system

Lessons live in a rules file the agent reads on every run. Each correction is written once and applied forever. Output quality compounds because every fix stays fixed.

rules.md: "Default to ≤150 words. Prose, not bullets. British spelling."

The durable side has one upfront cost — you have to write the lesson down instead of just saying it — and that cost is the whole game. It's the difference between a tool you operate and a system that operates better the more you use it.

3. The concrete starter: three parts you can ship today

You don't need a framework or a single line of code to start. A working self-improving agent has exactly three moving parts: a rules file the agent reads every run, a feedback-to-rule habit, and at least one self-verifying check. Here's each one, and then how they fit together.

Part 1 — A rules file the agent reads every run

This is the memory. It's a plain text file — call it rules.md, or use whatever persistent-context mechanism your tool gives you: a system prompt, a project-instructions field, a pinned message, or a CLAUDE.md if you're in Claude Code. The only requirement is that the agent loads it at the start of every task without you re-pasting it. Keep it short and imperative — rules, not essays.

rules.md
# HOW I WANT WORK DONE (read this first, every run) Voice: plain, confident, no hype words. Length: default to the shortest version that's complete. Format: prose over bullets unless I ask for a list. # LESSONS (each line = a mistake we already fixed) - Always show your numbers, never just the conclusion. - British spelling: "organise", "colour", "favour". - Never invent a source. If unsure, say "unverified". - Before finishing, re-read my request word for word.

That's it. The "LESSONS" block is the part that grows — every entry is a mistake that can't happen twice.

Part 2 — The feedback-to-rule habit

This is the engine. The rule is dead simple: every time you correct the agent, ask "should this be a rule?" — and if yes, add a line to the file before you move on. Don't just accept the fixed output and continue; that's the one-off trap. Spend the extra ten seconds to encode it. Over a week of normal use you'll accumulate a dozen lessons, and the agent that was annoying on Monday is sharp by Friday — with no extra effort beyond writing things down as you go.

The trigger phrase: any time you find yourself typing "no, I told you…" or "again, please don't…", stop. That sentence is a missing rule. Add it to the file and it never has to be said a third time.

Part 3 — A self-verifying check

This is the safety net. A rule the agent reads can still be forgotten in a long task; a check the agent runs cannot. So for your most important rules, add an explicit verification step the agent performs before it declares a task done. It can be a checklist it walks through, or — better — an actual test it runs and must pass.

self-check.md
# DONE-CHECK (run before saying "done") Before you finish ANY task, verify and report: 1. Did I follow every rule in rules.md? (list any I broke) 2. Are all numbers/claims backed by a source I can show? 3. Did I do exactly what was asked — nothing extra, nothing missing? If any check fails, FIX IT before reporting done. Never report "done" while a check is failing.

The magic of a self-verifying check is that it makes "done" mean something. Without it, the agent's idea of finished is "I produced output." With it, finished means "I produced output and proved it meets the bar." That single shift catches the majority of the errors you'd otherwise have to spot yourself.

How the three fit together: the rules file holds what you've learned, the feedback habit keeps it growing, and the self-verifying check enforces it. Capture → encode → enforce, on repeat. That's the whole loop — and you can stand it up in the next ten minutes with nothing but a text file.

4. Newbie → vibe → advanced: the same loop, three altitudes

The beauty of this setup is that it scales with you. The same capture-encode-enforce loop grows from a single text file into a real automated system. Here's the path.

Level 1 · Newbie

One rules file, by hand

Keep a single rules.md (or a pinned system prompt) and paste it at the top of each session. When the agent makes a mistake, add a line. Your "check" is a closing instruction: "before finishing, re-read my rules and confirm you followed them." Zero tooling — pure habit.

Level 2 · Vibe

Persistent context + a real checklist

Move the rules into context the tool loads automatically — a project-instructions file or CLAUDE.md — so you stop pasting. Split rules from a structured done-check the agent must walk through every run. Start grouping lessons by category (voice, accuracy, format) as the file grows.

Level 3 · Advanced

Automated checks + a feedback log

Turn your most important checks into code the agent actually runs — a linter, a test, a validator that must pass before anything ships. Keep a feedback log so recurring corrections get promoted into permanent checks. Now the system improves itself with the human only steering, not babysitting.

What Level 3 looks like in practice

At the advanced end, a rule stops being something the agent reads and becomes something the agent's work has to survive. Instead of "remember to show your numbers," you have a check that scans the output and blocks it if a claim has no source attached. The lesson is no longer advisory — it's enforced by code.

done-gate.check
# A rule, promoted from advisory to enforced RULE (advisory): "Always cite a source for every claim." CHECK (enforced): scan output → every numeric claim must have a source tag → if any is missing, BLOCK and send back for revision. # The loop that makes it self-improving 1. Correction happens → add a line to rules.md 2. Same correction twice → promote it to an enforced check 3. Check runs every time → that mistake is now impossible

Notice the through-line across all three levels: nothing changes about the loop. You're always capturing feedback, encoding it, and enforcing it. The only thing that levels up is how automated the enforcement is — from "re-read the rules" to "the code won't let it ship." Start at Level 1 today; you'll climb naturally as your rules file earns its keep.

5. The 30-second recap

  • The loop: capture feedback → encode it as a rule or check → it compounds. That's a self-improving agent.
  • One-off vs. durable: a chat forgets; a rules file remembers. Write the lesson down or re-teach it forever.
  • Rules file: short, imperative context the agent reads on every run. The "lessons" block is the part that grows.
  • Feedback-to-rule habit: when you catch yourself saying "I told you already," that's a missing rule — add it now.
  • Self-verifying check: make "done" mean "proved it meets the bar," not just "produced output."
  • It scales: hand-written file → auto-loaded context + checklist → automated checks the work must pass. Same loop, all the way up.

The fastest way to internalize this isn't reading about it once — it's practicing the loop until capturing and encoding feedback is automatic. That's exactly what PromptSharp is built for: one short lesson a day, real examples, until you instruct AI like someone who builds systems instead of someone who repeats themselves.

Frequently asked questions

What is a self-improving agent? +
An AI setup that gets better over time instead of repeating mistakes. It runs a simple loop: capture feedback when something goes wrong, encode it as a durable rule or automated check, and let those corrections compound across every future run. The key is durability — the lesson lives where the agent reads it every time, not in a chat that disappears.
How is it different from a one-off prompt? +
A one-off prompt is a single conversation — you fix a mistake, get a good result, and the lesson vanishes when the chat ends. A durable agent system stores the lesson in a rules file the agent reads on every run, so the same correction never has to be given twice. One-off prompts plateau; durable systems compound.
What's the minimum setup? +
Three things: (1) a rules file the agent reads at the start of every run, (2) a feedback-to-rule habit where every correction gets written into that file, and (3) at least one self-verifying check the agent runs before declaring a task done. You can stand all three up with nothing but a text file.
Does this work with ChatGPT, Claude, and Gemini? +
Yes — the pattern is model-agnostic. A rules file is just persistent context: a system prompt, a project-instructions field, a pinned message, or a CLAUDE.md file. The feedback-to-rule habit and the self-verifying check are workflow ideas, not features of any single model.