Self-improving AI agents: the Warp pattern you can copy

Your AI agents forget everything you teach them. Warp, the terminal company used by 800,000 developers, hit that wall too, and it built a fix so simple that self-improving AI agents now sound a lot less like science fiction.

The problem: agents that never learn

Warp runs an internal code review agent. When a developer opens a pull request, the agent reviews the code and leaves comments. Sounds useful, right? In practice, it was a mess. Engineers complained that the agent made unhelpful comments and produced low-quality output, so they started ignoring it entirely.

The team tried the usual fixes. They rewrote the agent’s prompts by hand whenever it failed, which helped a little but didn’t scale. They beefed up context files with project conventions, which helped more but still wasn’t enough. The real issue was something else: every piece of feedback given to the agent vanished when the session ended. Nothing carried over. The agent relearned nothing from one week to the next.

Sound familiar? That’s how most AI agents work, whether you’re using them for code, customer support, or content. You correct them over and over, and they never get better. And that’s precisely why self-improving AI agents are such a big deal: they close the loop.

The fix: a self-improvement loop

Warp’s answer is a loop with three parts, and you can copy all of them.

The base skill

First, you write a skill file that holds everything the agent needs to know about its job. Think of it as the agent’s instruction manual: what to do, what to look for, what good output looks like. It sits outside the raw prompt, kind of like a reference the agent checks while working. Anthropic calls this pattern Agent Skills, and its documentation explains the file format in detail.

For Warp’s code reviewer, the base skill describes how to review a pull request. For you, it might describe how to reply to customer emails or how to turn raw notes into a blog outline.

Human feedback in the middle

When the agent does its job, a human reacts. A thumbs up tells the loop the agent nailed it. A specific comment tells it way more, like “you suggested renaming this variable, but our codebase convention is different.” Warp’s founder Zach Lloyd puts it bluntly: the more specific the feedback, the faster the agent improves.

Here’s what that looks like in practice. “Good comment” is nearly useless as training data. “This suggestion would break the login flow on mobile, and here’s why” is gold. Warp’s take is that a small number of detailed, domain-specific comments beats a mountain of thumbs up, because the agent has no other way to learn that knowledge.

The improver skill

Then comes the clever part. A second skill acts as an observer that runs on a schedule, not alongside every task. It gathers all the accumulated feedback, compares what the agent suggested against how humans responded, and proposes a small, focused edit to the base skill.

Because skills are plain files, the agent can update them easily. That update goes through a normal review process, and once it’s approved and merged, the next run of the base skill inherits the improvement. Feedback compounds over time instead of evaporating.

That’s the entire trick behind self-improving AI agents: two files and a feedback loop, nothing more.

Why this works

Three reasons, and none of them are magic.

First, skills keep instructions out of the prompt. A prompt is a one-shot conversation; a skill is persistent knowledge an agent can look up. Second, the loop is human-in-the-middle by design, which means quality control stays where it belongs. Third, the whole thing flows through a normal approval workflow, so nobody is trusting a black box to rewrite its own brain.

Warp now runs this pattern across its entire codebase with separate spec-writing, review, and triage agents, each carrying its own loop. The stats backing it up are wild: 10 million Claude Code sessions have run inside Warp, more than 400,000 per week, and the company handles 40 million agent conversations total. Anthropic tells the full story in its customer write-up.

Think of it like onboarding a new employee. Nobody expects a new hire to be perfect on day one, so you hand them a handbook, you correct their mistakes, and after a few months they just know how your company does things. Most AI agents never get that handbook update. The Warp loop is the closest thing we have to giving an agent its own onboarding process, and it runs automatically.

The best part? Lloyd says the framework is deliberately simple. One base skill, one improver skill. That simplicity is the point, and it’s exactly what makes self-improving AI agents practical for the rest of us.

Warp’s five tips for skills that improve

The Warp team shared the rules they learned the hard way, and they translate to any AI agent setup:

1. Write principles, not rules. Instruct the agent like a smart person, not like a computer. “Look for repeated code” beats a list of a hundred naming rules.
2. Explain the why. When the agent knows the reason behind a rule, it can reason about edge cases instead of blindly following instructions.
3. Make feedback effortless. Capture it where people already work, like comments on a pull request, with zero extra submission steps. Low friction keeps the signal flowing.
4. Keep skills small. A good skill references other files instead of dumping everything into one giant document.
5. Quality beats volume. One detailed comment from a senior person is worth more than fifty thumbs up, though volume still helps.

How to try this yourself

You don’t need Warp or a Fortune 500 budget to start experimenting with self-improving AI agents. Start small and follow the same loop:

1. Pick one task you already delegate to an AI agent: drafting replies, summarizing meetings, reviewing your writing.
2. Write a short skill file with three to five principles for doing it well, and include the why behind each one.
3. Run the agent with that skill for a week, and leave feedback where you already work.
4. Once a week, ask a second agent to read that feedback and propose one small edit to the skill.
5. Review the edit, approve it, and let the loop run again.

Expect week one to be rough. The agent will still repeat the mistakes you tried to correct, because the improver only runs on a schedule and the first edit won’t land overnight. That’s normal. The wins show up in week three and four, when the accumulated feedback finally reshapes the base skill. Give the loop a month before you judge it.

If you’re curious how other companies put similar patterns to work, our breakdown of how Headway built a custom AI tool with Claude Code is a great read, and the Anthropic Skills API guide covers the infrastructure side. If you’re still on the fence about agents in general, here’s why most people don’t use them and how to get past it.

The takeaway

Self-improving AI agents are built on a loop you can copy this weekend: a base skill, human feedback, and an observer that turns that feedback into better instructions. Warp proves it scales, from one review agent to a whole company. Start with one boring, repetitive task, and let the loop do the rest.