self-improve

Orchestrate autonomous code-improvement loops with multi-agent research, planning, execution, and evaluation.

Updated Apr 11, 2026
One-click install
npx skills add https://github.com/Pryma-Tech/iris --skill self-improve-pryma-tech
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: self-improve
Source: https://github.com/Pryma-Tech/iris/tree/main/cli/skills/self-improve
Command: npx skills add https://github.com/Pryma-Tech/iris --skill self-improve-pryma-tech

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires jq, git, and includes scripts (resource) components.

What problem does it solve?

Coordinates and automates end-to-end code improvement within a repository by guiding research, planning, execution, and evaluation, reducing manual overhead and decisions.

Core Features & Use Cases

  • Multi-agent orchestration that runs autonomous improvement iterations with tournament-style selection
  • Robust state tracking, resumability, and guardrails (sealed files, trust gate, stop conditions)
  • Git worktree management for isolated experiments and historical record-keeping
  • Use cases include performance optimization, refactor risk reduction, and feature evolution through iterative experiments

Quick Start

Initialize the target repository path, define a crystal-clear goal via si-goal-clarifier, generate a benchmark with si-benchmark-builder, and run Self-Improve to start iterative optimization.

Frequently Asked Questions about self-improve

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate code improvement loops within a repository?

Autonomous code improvement loops are orchestrated by coordinating research, planning, execution, and evaluation. The process uses tournament-style selection among multiple agents to iteratively optimize code while enforcing safety guardrails and sealed-file constraints.

How does tournament-style selection work for autonomous code optimization?

Tournament-style selection runs multiple autonomous agents that generate competing code improvements. The system evaluates these iterations against benchmarks, selecting the best-performing changes to merge while discarding less effective experiments.

Do I need git worktrees to run isolated code experiments safely?

Yes, git worktree management creates isolated environments for autonomous experiments. This ensures iterative code changes are tested safely without affecting the main branch and maintains a historical record of all optimization trials.

What are the prerequisites for running autonomous code optimization workflows?

You need jq and git installed. You must also initialize the target repository path, define a clear optimization goal via the goal-clarifier, and generate a benchmark to evaluate improvements before starting the iterative process.

How do safety guardrails and trust gates prevent unwanted code changes?

Safety guardrails enforce sealed-file constraints and safelists to prevent unauthorized modifications. Trust gates evaluate autonomous changes against stop conditions before allowing merges, ensuring all code experiments remain auditable and reversible.

Can I resume an interrupted autonomous code optimization session?

Yes, the system features robust state tracking and resumability. If an autonomous code improvement iteration is interrupted, you can resume progress from the last saved state without losing experimental data or historical records.