586 lines
16 KiB
Markdown
586 lines
16 KiB
Markdown
# Meta-Level Self-Improvement System
|
|
|
|
**Infinite Loop Variant 7**
|
|
|
|
A self-improving infinite loop orchestrator that can analyze its own performance, improve its commands, generate new specifications, and evolve its orchestration strategy using meta-prompting principles.
|
|
|
|
## What Makes This Special
|
|
|
|
Unlike traditional infinite loops that just generate content, this system has **meta-level awareness**:
|
|
|
|
- **Self-Analysis** - Examines its own performance and identifies bottlenecks
|
|
- **Self-Modification** - Can improve its own commands (with safety guardrails)
|
|
- **Self-Generation** - Creates new specifications from discovered patterns
|
|
- **Self-Testing** - Validates its own functionality automatically
|
|
- **Self-Documentation** - Updates its own documentation (including this file!)
|
|
- **Recursive Improvement** - Can improve the improvement process itself
|
|
|
|
## Quick Start
|
|
|
|
### Install
|
|
|
|
```bash
|
|
# Clone or navigate to this directory
|
|
cd infinite_variants/infinite_variant_7/
|
|
|
|
# Ensure Claude Code has access to the commands
|
|
# Commands are in .claude/commands/
|
|
```
|
|
|
|
### Basic Usage
|
|
|
|
```bash
|
|
# Generate content with continuous self-improvement
|
|
/infinite-meta specs/example_spec.md output/ 20 evolve
|
|
|
|
# Analyze system and propose improvements
|
|
/improve-self all standard
|
|
|
|
# Create new specifications from patterns
|
|
/generate-spec patterns novel
|
|
|
|
# Evolve the orchestration strategy
|
|
/evolve-strategy quality incremental
|
|
|
|
# Test everything works correctly
|
|
/self-test all standard
|
|
|
|
# Update documentation to reflect current state
|
|
/self-document all standard
|
|
```
|
|
|
|
## Core Philosophy: Meta-Prompting
|
|
|
|
This system is built on **meta-prompting principles** from [promptingguide.ai](https://www.promptingguide.ai/techniques/meta-prompting):
|
|
|
|
### 1. Structure-Oriented Design
|
|
|
|
Instead of giving specific examples, the system provides **structural frameworks**:
|
|
- Commands define "how to think" not just "what to do"
|
|
- Specs provide patterns, not templates
|
|
- Improvements focus on architecture, not just parameters
|
|
|
|
### 2. Abstract Frameworks
|
|
|
|
Everything uses generalizable patterns:
|
|
- Orchestration follows abstract decision trees
|
|
- Quality metrics are principle-based
|
|
- Evolution applies transferable insights
|
|
|
|
### 3. Minimal Example Dependency
|
|
|
|
The system learns from structure, not memorization:
|
|
- Sub-agents receive frameworks, not examples
|
|
- Patterns are extracted abstractly
|
|
- Reasoning is principle-driven
|
|
|
|
### 4. Efficient Reasoning
|
|
|
|
Meta-prompting enables efficiency:
|
|
- Reduced token usage through structural focus
|
|
- Pattern-based generation over example-based
|
|
- Meta-level optimization of all processes
|
|
|
|
## Available Commands
|
|
|
|
### `/infinite-meta` - Self-Improving Orchestrator
|
|
|
|
The main command that generates content while continuously improving itself.
|
|
|
|
```bash
|
|
/infinite-meta <spec_path> <output_dir> <count|infinite> [improvement_mode]
|
|
```
|
|
|
|
**Features:**
|
|
- Parallel sub-agent deployment
|
|
- Wave-based progressive improvement
|
|
- Performance tracking and metrics
|
|
- Strategy evolution between waves
|
|
- Meta-level self-reflection
|
|
|
|
**Example:**
|
|
```bash
|
|
# Generate 20 iterations with continuous improvement
|
|
/infinite-meta specs/example_spec.md output/ 20 evolve
|
|
```
|
|
|
|
### `/improve-self` - Self-Improvement Analyzer
|
|
|
|
Analyzes current system performance and generates concrete improvement proposals.
|
|
|
|
```bash
|
|
/improve-self [target] [depth]
|
|
```
|
|
|
|
**Parameters:**
|
|
- `target`: commands, specs, strategy, all (default: all)
|
|
- `depth`: quick, standard, deep (default: standard)
|
|
|
|
**Features:**
|
|
- Performance metric analysis
|
|
- Pattern recognition
|
|
- Concrete improvement proposals
|
|
- Risk assessment and rollback plans
|
|
- Meta-level insight extraction
|
|
|
|
**Example:**
|
|
```bash
|
|
# Deep analysis of all system components
|
|
/improve-self all deep
|
|
```
|
|
|
|
### `/generate-spec` - Auto-Specification Generator
|
|
|
|
Automatically creates new specification files based on discovered patterns.
|
|
|
|
```bash
|
|
/generate-spec [source] [focus] [output_name]
|
|
```
|
|
|
|
**Parameters:**
|
|
- `source`: patterns, logs, existing_specs, all (default: all)
|
|
- `focus`: novel, variant, evolution, hybrid (default: novel)
|
|
- `output_name`: filename (default: auto-generated)
|
|
|
|
**Features:**
|
|
- Pattern discovery from iterations
|
|
- Structure-oriented spec design
|
|
- Quality dimension extraction
|
|
- Validation and testing hooks
|
|
|
|
**Example:**
|
|
```bash
|
|
# Generate completely new spec from all patterns
|
|
/generate-spec all novel custom_domain
|
|
```
|
|
|
|
### `/evolve-strategy` - Strategy Evolution
|
|
|
|
Analyzes and evolves the orchestration strategy for better performance.
|
|
|
|
```bash
|
|
/evolve-strategy [metric_focus] [evolution_type]
|
|
```
|
|
|
|
**Parameters:**
|
|
- `metric_focus`: quality, efficiency, diversity, meta, all (default: all)
|
|
- `evolution_type`: incremental, experimental, revolutionary (default: incremental)
|
|
|
|
**Features:**
|
|
- Metric-focused optimization
|
|
- Pattern-based strategy evolution
|
|
- Validation and rollback procedures
|
|
- Meta-prompting principle application
|
|
|
|
**Example:**
|
|
```bash
|
|
# Incrementally improve quality-focused strategy
|
|
/evolve-strategy quality incremental
|
|
```
|
|
|
|
### `/self-test` - System Validator
|
|
|
|
Validates system capabilities, tests improvements, and ensures everything works.
|
|
|
|
```bash
|
|
/self-test [scope] [depth]
|
|
```
|
|
|
|
**Parameters:**
|
|
- `scope`: commands, generation, improvement, integration, all (default: all)
|
|
- `depth`: smoke, standard, comprehensive (default: standard)
|
|
|
|
**Features:**
|
|
- Command functionality testing
|
|
- Generation quality validation
|
|
- Improvement loop verification
|
|
- Integration testing
|
|
- Regression detection
|
|
|
|
**Example:**
|
|
```bash
|
|
# Quick smoke test of all systems
|
|
/self-test all smoke
|
|
```
|
|
|
|
### `/self-document` - Auto-Documentation
|
|
|
|
Generates and updates documentation to reflect current system state.
|
|
|
|
```bash
|
|
/self-document [scope] [detail_level]
|
|
```
|
|
|
|
**Parameters:**
|
|
- `scope`: commands, specs, improvements, architecture, all (default: all)
|
|
- `detail_level`: brief, standard, comprehensive (default: standard)
|
|
|
|
**Features:**
|
|
- Automatic documentation generation
|
|
- Current state reflection
|
|
- Evolution history tracking
|
|
- Meta-capability documentation
|
|
|
|
**Example:**
|
|
```bash
|
|
# Update all documentation comprehensively
|
|
/self-document all comprehensive
|
|
```
|
|
|
|
## System Architecture
|
|
|
|
```
|
|
┌─────────────────────────────────────────────┐
|
|
│ Meta-Level Control Layer │
|
|
│ • Self-analysis and reflection │
|
|
│ • Strategy evolution │
|
|
│ • Meta-prompting orchestration │
|
|
│ • Recursive improvement loops │
|
|
└─────────────────┬───────────────────────────┘
|
|
│
|
|
┌─────────────────┴───────────────────────────┐
|
|
│ Command Layer │
|
|
│ • /infinite-meta (orchestrator) │
|
|
│ • /improve-self (analyzer) │
|
|
│ • /generate-spec (creator) │
|
|
│ • /evolve-strategy (evolver) │
|
|
│ • /self-test (validator) │
|
|
│ • /self-document (documenter) │
|
|
└─────────────────┬───────────────────────────┘
|
|
│
|
|
┌─────────────────┴───────────────────────────┐
|
|
│ Data Layer │
|
|
│ • specs/ (generation templates) │
|
|
│ • improvement_log/ (evolution history) │
|
|
│ • meta_prompts/ (pattern library) │
|
|
│ • output_dirs/ (generated content) │
|
|
└─────────────────────────────────────────────┘
|
|
```
|
|
|
|
## Directory Structure
|
|
|
|
```
|
|
infinite_variant_7/
|
|
├── .claude/
|
|
│ ├── commands/ # All slash commands
|
|
│ │ ├── infinite-meta.md # Main orchestrator
|
|
│ │ ├── improve-self.md # Self-improvement analyzer
|
|
│ │ ├── generate-spec.md # Spec auto-generator
|
|
│ │ ├── evolve-strategy.md # Strategy evolver
|
|
│ │ ├── self-test.md # System validator
|
|
│ │ └── self-document.md # Auto-documentation
|
|
│ └── settings.json # Permissions
|
|
├── specs/ # Specifications
|
|
│ ├── example_spec.md # Example specification
|
|
│ └── auto_generated_spec.md # Template for auto-generation
|
|
├── improvement_log/ # Evolution tracking (created during use)
|
|
│ ├── wave_*_reflection.md
|
|
│ ├── wave_*_proposals.md
|
|
│ ├── evolved_strategy_*.md
|
|
│ ├── test_report_*.md
|
|
│ └── system_health.json
|
|
├── meta_prompts/ # Pattern library (created during use)
|
|
│ ├── command_improver.md
|
|
│ ├── spec_generator.md
|
|
│ └── orchestration_strategy.md
|
|
├── docs/ # Documentation
|
|
│ └── self_improvement_guide.md
|
|
├── README.md # This file (auto-maintained)
|
|
└── CLAUDE.md # Project instructions (auto-maintained)
|
|
```
|
|
|
|
## Typical Workflows
|
|
|
|
### Workflow 1: Generate and Improve
|
|
|
|
```bash
|
|
# Generate 20 iterations with automatic improvement
|
|
/infinite-meta specs/example_spec.md output/ 20 evolve
|
|
|
|
# System will:
|
|
# 1. Generate wave 1 (5 iterations)
|
|
# 2. Analyze performance
|
|
# 3. Evolve strategy
|
|
# 4. Generate wave 2 (improved)
|
|
# 5. Continue improving across 4 waves
|
|
```
|
|
|
|
### Workflow 2: Deep System Improvement
|
|
|
|
```bash
|
|
# Analyze current state deeply
|
|
/improve-self all deep
|
|
|
|
# Evolve strategy based on analysis
|
|
/evolve-strategy all incremental
|
|
|
|
# Validate improvements work
|
|
/self-test all standard
|
|
|
|
# Update documentation
|
|
/self-document all standard
|
|
```
|
|
|
|
### Workflow 3: Create and Use New Capability
|
|
|
|
```bash
|
|
# Generate new spec from discovered patterns
|
|
/generate-spec patterns novel custom_domain
|
|
|
|
# Test it with small batch
|
|
/infinite-meta specs/custom_domain.md test_output/ 5
|
|
|
|
# If good, run full batch with improvement
|
|
/infinite-meta specs/custom_domain.md output/ 20 evolve
|
|
```
|
|
|
|
### Workflow 4: Continuous Improvement Cycle
|
|
|
|
```bash
|
|
# 1. Baseline generation
|
|
/infinite-meta specs/example_spec.md baseline/ 10
|
|
|
|
# 2. Analyze for improvements
|
|
/improve-self all deep
|
|
|
|
# 3. Evolve strategy
|
|
/evolve-strategy quality incremental
|
|
|
|
# 4. Test evolved strategy
|
|
/self-test generation standard
|
|
|
|
# 5. Generate with improvements
|
|
/infinite-meta specs/example_spec.md improved/ 10
|
|
|
|
# 6. Document results
|
|
/self-document all standard
|
|
```
|
|
|
|
## Meta-Level Capabilities
|
|
|
|
### 1. Self-Analysis
|
|
|
|
The system examines its own processes:
|
|
- Performance metric tracking
|
|
- Bottleneck identification
|
|
- Pattern recognition
|
|
- Meta-level insight extraction
|
|
|
|
### 2. Self-Modification
|
|
|
|
Can improve its own components (with safety):
|
|
- Command enhancement
|
|
- Strategy evolution
|
|
- Spec refinement
|
|
- All changes logged and reversible
|
|
|
|
### 3. Self-Generation
|
|
|
|
Creates new capabilities from patterns:
|
|
- Auto-generates specifications
|
|
- Discovers structural frameworks
|
|
- Synthesizes new approaches
|
|
- Validates through testing
|
|
|
|
### 4. Self-Testing
|
|
|
|
Validates its own functionality:
|
|
- Automated test suites
|
|
- Regression detection
|
|
- Performance benchmarking
|
|
- Integration validation
|
|
|
|
### 5. Self-Documentation
|
|
|
|
Maintains its own docs:
|
|
- README auto-updates
|
|
- CLAUDE.md reflects current state
|
|
- Guides generated from system analysis
|
|
- Evolution history tracked
|
|
|
|
### 6. Recursive Improvement
|
|
|
|
Can improve the improvement process:
|
|
- Meta-meta-prompting
|
|
- Improvement of /improve-self itself
|
|
- Evolution of /evolve-strategy
|
|
- Continuous meta-level enhancement
|
|
|
|
## Safety and Guardrails
|
|
|
|
### Self-Modification Safety
|
|
|
|
The system can improve itself, but safely:
|
|
|
|
- **Logging**: All changes logged in `improvement_log/`
|
|
- **Backups**: Original versions preserved before modifications
|
|
- **Rollback**: Clear procedures to undo changes
|
|
- **Validation**: `/self-test` required before applying improvements
|
|
- **Monitoring**: Continuous health tracking in `system_health.json`
|
|
- **Thresholds**: Automatic rollback if metrics regress >15%
|
|
|
|
### Testing and Validation
|
|
|
|
- Smoke tests (5 min) - Quick health check
|
|
- Standard tests (15-30 min) - Full validation
|
|
- Comprehensive tests (45-90 min) - Deep validation with benchmarks
|
|
- Regression detection - Compares to baseline metrics
|
|
- Integration testing - Validates command interactions
|
|
|
|
## Performance Metrics
|
|
|
|
The system tracks these metrics continuously:
|
|
|
|
- **Quality Average**: Mean quality score of generations (target: ≥8.0)
|
|
- **Efficiency Score**: Context usage and speed optimization (target: ≥0.85)
|
|
- **Diversity Index**: Uniqueness across iterations (target: ≥0.90)
|
|
- **Meta-Awareness**: Self-reflection and improvement capability (target: ≥0.75)
|
|
- **Improvement Rate**: Quality gain per improvement cycle (target: ≥5%)
|
|
|
|
Check current metrics in `improvement_log/system_health.json`.
|
|
|
|
## Troubleshooting
|
|
|
|
### System Not Improving
|
|
|
|
```bash
|
|
# Check improvement logs
|
|
cat improvement_log/system_health.json
|
|
|
|
# Run deep analysis
|
|
/improve-self all deep
|
|
|
|
# Verify metrics
|
|
/self-test all standard
|
|
```
|
|
|
|
### Quality Declining
|
|
|
|
```bash
|
|
# Test generation quality
|
|
/self-test generation standard
|
|
|
|
# Evolve for quality
|
|
/evolve-strategy quality incremental
|
|
|
|
# Review recent changes
|
|
cat improvement_log/evolved_strategy_*.md
|
|
```
|
|
|
|
### Documentation Outdated
|
|
|
|
```bash
|
|
# Regenerate all documentation
|
|
/self-document all comprehensive
|
|
```
|
|
|
|
### Commands Not Working
|
|
|
|
```bash
|
|
# Run comprehensive test
|
|
/self-test all comprehensive
|
|
|
|
# Check for regressions
|
|
# Review test report in improvement_log/
|
|
```
|
|
|
|
## Advanced Features
|
|
|
|
### Pattern Library Evolution
|
|
|
|
The `meta_prompts/` directory evolves continuously:
|
|
- Successful patterns are added automatically
|
|
- Ineffective patterns are removed
|
|
- Abstract frameworks are refined
|
|
- Meta-level insights accumulate
|
|
|
|
### Adaptive Batch Sizing
|
|
|
|
The system dynamically adjusts sub-agent batch sizes:
|
|
- Based on available context
|
|
- Optimized for performance metrics
|
|
- Balanced for quality vs. speed
|
|
- Evolved through strategy improvements
|
|
|
|
### Automatic Spec Generation
|
|
|
|
When patterns across 10+ iterations show clear themes:
|
|
- System auto-generates new specs
|
|
- Validates through small test batch
|
|
- Refines based on results
|
|
- Adds to spec library
|
|
|
|
### Progressive Wave Learning
|
|
|
|
In infinite mode with evolve enabled:
|
|
- Each wave is more sophisticated
|
|
- Strategy evolves between waves
|
|
- Quality compounds progressively
|
|
- Meta-awareness increases
|
|
|
|
## Integration with Other Variants
|
|
|
|
This variant can be combined with others:
|
|
|
|
- **Variant 1-6**: Use meta-improvement on any variant
|
|
- **Web-Enhanced**: Add self-improvement to web learning loops
|
|
- **Multi-Modal**: Apply meta-prompting to multi-modal generation
|
|
|
|
## Contributing
|
|
|
|
### Adding New Capabilities
|
|
|
|
1. Create command in `.claude/commands/`
|
|
2. Follow meta-prompting principles (structure-oriented)
|
|
3. Add self-improvement hooks
|
|
4. Include meta-awareness
|
|
5. Test with `/self-test`
|
|
6. Document with `/self-document`
|
|
|
|
### Improving Existing Commands
|
|
|
|
1. Use `/improve-self` to analyze
|
|
2. Generate improvement proposals
|
|
3. Implement with safety checks (backups, validation)
|
|
4. Test with `/self-test`
|
|
5. Document changes
|
|
6. Update version in `improvement_log/`
|
|
|
|
## References
|
|
|
|
- **Meta-Prompting Guide**: https://www.promptingguide.ai/techniques/meta-prompting
|
|
- **Improvement Logs**: `improvement_log/` directory
|
|
- **Meta-Prompts Library**: `meta_prompts/` directory
|
|
- **Architecture Guide**: `docs/self_improvement_guide.md`
|
|
|
|
## Future Directions
|
|
|
|
Potential evolution paths:
|
|
|
|
- **Enhanced Pattern Recognition**: ML-based pattern discovery
|
|
- **Cross-Domain Learning**: Transfer patterns between domains
|
|
- **Multi-Agent Meta-Collaboration**: Agents that improve each other
|
|
- **Advanced Meta-Meta-Prompting**: Multiple levels of self-improvement
|
|
- **Autonomous Goal Setting**: System defines its own objectives
|
|
- **Self-Optimizing Context**: Automatic context window management
|
|
|
|
## Version History
|
|
|
|
**v1.0.0** (2025-10-10):
|
|
- Initial implementation
|
|
- All six core commands
|
|
- Meta-prompting foundation
|
|
- Self-improvement loop
|
|
- Pattern library system
|
|
- Safety guardrails
|
|
|
|
---
|
|
|
|
*This README is auto-maintained by `/self-document`. It reflects the current state of the system and will be automatically updated as the system evolves.*
|
|
|
|
**Meta-Note**: This README demonstrates meta-awareness by documenting its own auto-generation capability. When outdated, run `/self-document all comprehensive` to regenerate.
|
|
|
|
**Last Updated**: 2025-10-10
|
|
**System Version**: 1.0.0
|
|
**Status**: Operational
|