How to use the Self-Improvement Loops agent skill

What an agent skill is and what this one does

An agent skill is a folder with a SKILL.md file that an agent such as Claude loads when a request matches the skill's description. The skill adds instructions and reference material to the agent's working context for that task.

This skill applies when the harness, scaffold, workflow, or optimizer is the optimization target. It covers recursive self-improvement (RSI) loops, meta-harnesses, evolutionary search over agent scaffolds, acceptance gates for self-modifying systems, and context mechanisms that are versioned and evolved.

• Helps you pick the level at which to fix a recurring failure, from instruction prompts up to optimizer code.
• Explains how to keep the scoring signal out of the optimizer's reach so it cannot game the metric.
• Explains how to accept self-edits only when measured results show no regressions on a held-out split.
• Covers diversity preservation and archiving of candidates so evolutionary loops do not collapse.

Install the self-improvement-loops skill

Download the skill ZIP from this directory page. Unzip it into your personal skills folder at ~/.claude/skills/, or into a project's .claude/skills/ folder if you want the skill available only in that project.

You can also upload the ZIP in the Claude apps under Settings → Capabilities → Skills.

• Personal install: unzip into ~/.claude/skills/
• Project install: unzip into the project's .claude/skills/ folder
• Claude apps: Settings → Capabilities → Skills, then upload the ZIP

Trigger the skill with natural requests

You do not need a special command. Describe the design problem in plain words and mention the kind of loop you are building. The skill's description lists the triggers: recursive self-improvement, meta-harnesses, self-improving harnesses that propose bounded edits, evolutionary search over scaffolds, acceptance gates, and agentic context evolution.

If your request is about governing a single autonomous loop, the skill will route you elsewhere. Governance topics such as locked surfaces, durable logs, rollback and approval boundaries belong to harness-engineering, and evaluator design belongs to evaluation.

• Example: "Design an acceptance gate for an agent that edits its own prompts."
• Example: "Our meta-agent proposes harness code changes. How should we pick parents so the population does not collapse?"
• Example: "Diagnose why our self-improvement loop's score rises while its edit diffs are empty."

What the skill tells the agent to do

The skill organises design around an optimization ladder. Fix a recurring failure at the lowest rung that can express the fix, and move up only when failure clusters persist across candidates.

It stresses that the outside-the-loop invariant must hold. The evaluator, permission control and budget enforcement must live outside anything the loop can modify, and constraints written in prompt text get evolved away.

Acceptance is empirical. A held-in split checks the targeted weakness, a held-out split checks for regressions, and candidates that trade one split against the other are rejected even if their sum improves. Rejected candidates are logged with evidence.

• Rungs: instruction prompts, structured context, context mechanism, workflow graph, harness code, optimizer code.
• Track edit diffs, not only scores, to catch a broken improver that silently returns its input unchanged.
• Store candidates as directories with source, scores and raw traces, and let the proposer search them rather than receiving summaries.

Safety notes: scripts and network

According to the skill metadata, this skill runs no scripts and uses no network access, and it lists no required tools or packages. It is documentation the agent reads, so installing it does not add executable code to your system.

The loops you design with it are a different matter. A self-modifying loop can exploit weak scoring, so the skill advises enforcing budgets, permissions and sandbox boundaries at the OS or container level, not in prompt text.

• Runs scripts: no
• Uses network: no
• Requires: nothing listed
• Sandbox the loop you build at the OS or container level; do not rely on framework permission gates alone.
• Treat any detected exploit as a failed candidate, not a high score.

Tips for getting useful output

Give the agent your concrete failure cases and your current metric. The skill is most useful when it can reason about a specific gap between the metric and your intent.

Ask for a capability validation before enabling recursion. The skill recommends running a fixed number of iterations on a held-out task set and counting the loop as net-negative if the trajectory declines.

Check the reference file loop-design-evidence.md for per-system evidence. Its numbers are dated and the file says to revalidate them before quoting them as current.

• State which rung your failure sits at and whether it persists across candidates.
• Ask how to hide the scoring implementation from the proposer.
• Do not quote the evidence figures without checking them against current sources.