recursive-self-improvement

Enable metric-gated self-improvement of code, prompts, and skills.

Updated Sep 1, 2021
One-click install
npx skills add https://github.com/unclehowell/unclehowell --skill recursive-self-improvement-unclehowell
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: recursive-self-improvement
Source: https://github.com/unclehowell/unclehowell/tree/main/skills/recursive-self-improvement
Command: npx skills add https://github.com/unclehowell/unclehowell --skill recursive-self-improvement-unclehowell

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a disciplined, production-ready approach for AI agents to iteratively improve their own code, prompts, memories, and workflows while preventing runaway or unsafe self-modification through metric gates, verification, and archival lifecycle controls.

Core Features & Use Cases

  • Closed-loop improvement flywheel: Integrates generate→execute→evaluate→refine→archive cycles to compound gains across subsystems.
  • Three-tier versioned memory: Episodic, semantic, and procedural tiers with decay, compaction, and consolidation routines.
  • Skill evolution & pruning: Formal promotion pipeline, versioning, monitoring, and archive-first prune phase to avoid context pollution.
  • Safety & guardrails: Sandboxed execution, diff validation, pre-commit CI gates, constitutional immutables, and circuit breakers for bounded self-modification.
  • Programmatic prompt & ACI patterns: DSPy-style prompt compilation, machine-readable skill interfaces with JSON schemas, and DAG-based composition for safe automation.
  • Meta-evaluation & metrics: Anti-Goodhart checks, orthogonal metric tracking (pass rate, token cost, regression), and blind A/B verification.
  • Self-play & training signals: Controlled adversarial testing, bug-injection/fix cycles, and isolated self-play pipelines for continuous signal generation.

Quick Start

Search past interactions for similar tasks, run a short generate-execute-evaluate loop with sandboxed execution, and archive successful patterns into the semantic memory tier.

Frequently Asked Questions about recursive-self-improvement

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

FAQPage Schema
How do I safely implement agent self-improvement without risking runaway code modifications?

Agent self-improvement can be safely constrained using metric gates, sandboxed execution, and diff validation. This approach enforces bounded self-modification through pre-commit CI gates and circuit breakers, ensuring autonomous workflows remain stable and production-ready.

What is the best way to structure agent memory for meta-learning and continuous skill evolution?

Structuring agent memory for meta-learning requires three-tier versioned memory: episodic, semantic, and procedural. This configuration supports decay, compaction, and consolidation routines, enabling agents to archive successful patterns and prevent context pollution during skill evolution.

How does metric-gated self-improvement work in autonomous development workflows?

Metric-gated self-improvement works by running generate, execute, evaluate, and refine cycles with automated evaluation and meta-evaluation. It tracks orthogonal metrics like pass rate and token cost, applying anti-Goodhart checks and blind A/B verification to compound gains safely.

Can I use automated prompt compilation and self-play for debugging and optimization?

Automated prompt compilation and self-play are supported through DSPy-style patterns and controlled adversarial testing. This generates continuous training signals via bug-injection and fix cycles, enabling agents to optimize prompts and debug code within isolated self-play pipelines.

How do I manage skill pruning and version control to avoid context pollution in AI agents?

Skill pruning and version control manage context pollution through a formal promotion pipeline and an archive-first prune lifecycle. By implementing monitoring and verification gates, agents can safely retire outdated skills while preserving validated procedural knowledge.

When should I not use autonomous self-modification workflows for code and prompt optimization?

Autonomous self-modification workflows should be avoided when environments lack sandboxed execution or constitutional immutables. Without diff validation and circuit breakers, running unconstrained generate-execute-evaluate loops risks introducing regressions and unsafe code modifications.