Warp's Self-Improving Agents on Claude: The Base-Skill + Improver-Skill Loop

Agents need to handle recurring tasks reliably and effectively. A first-pass prompt that gets 80% of the task correct can create a noisy and annoying experience for the user. Warp learned this the hard way, and used it to inform its product strategy, creating an improved experience for nearly 1M developers worldwide. Warp, the AI-powered terminal and agentic development environment, builds on the Claude Platform. The team ran into this "noisy experience" problem with their internal code review agent: engineers complained that their agent made unhelpful comments and produced low-quality output. Ultimately, they realized, the real issue was that feedback to an agent, no matter what its purpose, typically disappears when the session ends — removing critical context from the agentic loop. Their solution: an Agent Skills-based framework to create self-improving agents where feedback compounds over time to continually refine and enhance agent output.

1. The Problem: Feedback Disappears When the Session Ends

Feedback to an agent, no matter what its purpose, typically disappears when the session ends. That is fatal for any agentic loop: every run restarts from the same imperfect baseline, and the same mistakes repeat because "what the human corrected last time" was never saved. Warp's engineers were specific about their complaints against the internal code review agent: unhelpful comments, low-quality output. The model wasn't the problem. There was simply no mechanism to accumulate human corrections. Sessions are isolated; knowledge is not.

// The inner/base skill: functional domain knowledge and
// instructions, kept OUT of the raw prompt. When a PR is
// opened, the code agent executes using this skill.
// SKILLS/code-review/SKILL.md
# Code Review Agent
## Rules
- Comment only when the change is actionable.
- Naming: follow repo conventions (see GLOSSARY.md).
- Never suggest a rename that contradicts a global
  variable naming convention documented in the repo.
- Explain the why behind every rule so the agent can
  reason instead of pattern-match.
## Context
- Load GLOSSARY.md before reviewing.

2. The Fix: Agent Skills and a Two-Skill Architecture

The central technique is a self-improvement loop using skills — file-based encodings of knowledge that keep instructions out of the raw prompt. Warp evolved a self-improving agent architecture consisting of two skills, with human feedback in between. The inner/base skill holds the functional domain knowledge and instructions: when a PR is opened, Warp's code agent executes using that base skill and context to produce its review. The outer/improver skill functions as an observer agent that runs on a schedule rather than per-task: it pulls the accumulated human feedback, compares what the agent suggested against how humans responded, and proposes a small, focused edit to the base skill.

// Feedback is the critical component: explicit is better.
// A thumbs up helps; detailed reasons teach. The session
// used to swallow this — now it feeds the loop.
type Feedback = {
  prId: string;
  agentCommentId: string;
  human: "affirmed" | "rejected";
  reason?: string; // "you suggested renaming X, but our
                   // codebase convention for globals is Y"
};
const collected: Feedback[] = await pullFromPRs(org, "30d");

3. Human Feedback: Quality Over Volume, but Volume Helps

Human feedback on agent output is the critical component for the self-improvement loop. For code review this could be something as simple as a thumbs up — but the more explicit the better. "A human could affirm, 'this was a good, useful comment,'" Warp founder Zach Lloyd explains, "but the human could also give detailed reasons why a code review wasn't good. Specifics like 'you suggested renaming this variable, but our code base convention is this type of global variable uses this particular naming context' tell the agent how to do it right next time." A small amount of detailed, domain-specific feedback from a senior engineer can be worth more than lots of cursory feedback, because binary thumbs up/down doesn't say why.

// The outer/improver skill: an observer agent that runs on
// a schedule, not per task. It pulls 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, agents are
// extremely good at updating them.
// SKILLS/code-review-improver/SKILL.md
# Improver
1. Load feedback collected over the last 30 days.
2. Group by pattern: which suggestions got rejected?
3. Draft ONE small edit to ../code-review/SKILL.md.
4. Open a PR with the change + the evidence.

4. Why Skills Make Improvement Practical

Because skills are plain files, agents are extremely good at updating them. The updates the improver produces are reviewable, approvable, and mergeable — they flow through a normal PR/code-review workflow. Once merged, the next run of the inner skill inherits the improvement. This solves a foundational problem: the old ways of making an agent "remember lessons" meant either stuffing them into the prompt (which grows every run) or relying on some mysterious state system. Files as knowledge, PRs as memory. Warp turned the feedback loop into an ordinary engineering process.

5. Warp's Scale Numbers

Warp has raised $73M, 800K monthly developers build on Warp, and 56% of the Fortune 500 uses Warp; 10M Claude Code sessions have run inside Warp to date — 400K+ per week — and Warp Agent conversations total 40M. Warp now runs this pattern across its entire open-source repo, with separate spec-writing, review, and triage agents, each carrying its own self-improvement loop. "File-based skills are a way of encoding knowledge for agents without putting that knowledge directly in the prompt, as something the agent can simply look up in the course of doing its job," says Zach. "The framework is really simple actually: there's the base domain-specific skill and then there's the improver skill that refines that domain-specific skill. This simplicity is the beauty of this approach."

// The update flows through a normal PR/code-review
// workflow: reviewable, approvable, mergeable. Once merged,
// the next run of the inner skill inherits the improvement.
async function improveLoop(schedule: Cron) {
  schedule.every("monday 09:00", async () => {
    const feedback = await collectFeedback("30d");
    if (feedback.length < MIN_SIGNAL) return; // quality > volume
    const pr = await improverAgent.proposeEdit(feedback);
    await openReviewablePR(pr); // human approves, then merge
  });
}
// Feedback compounds over time instead of vanishing.

6. Practical Tips for Writing Self-Improving Skills

The Warp team shares several tried-and-true tips. Explain the why: providing the rationale behind the rule lets the agent reason about the problem instead of following rigid instructions, again allowing for better generalization. Feedback quality > volume, but volume helps: a small amount of detailed, domain-specific feedback from a senior engineer can be worth more than lots of cursory feedback, because binary thumbs up/down doesn't say why. Keep edits small: one focused modification to the base skill per cycle, so each improvement is reviewable and reversible. The beauty of the framework is its simplicity: a base domain-specific skill, and an improver skill that refines it.

// The full architecture Warp runs across its open-source
// repo: separate spec-writing, review, and triage agents,
// each carrying its own self-improvement loop.
const agents = [
  { name: "spec-writer",  base: "spec-writing",  improver: "spec-improver" },
  { name: "reviewer",     base: "code-review",   improver: "code-review-improver" },
  { name: "triage",       base: "issue-triage",  improver: "triage-improver" },
];
for (const a of agents) {
  runLoop({ base: loadSkill(a.base),
            improver: loadSkill(a.improver),
            schedule: "weekly" });
}
// The framework is really simple: a base domain-specific
// skill and an improver skill that refines it.