# Self Document - Auto-Documentation System **Purpose:** Automatically generate and update documentation to reflect current system state, capabilities, and improvements. ## Usage ```bash /self-document [scope] [detail_level] ``` ### Parameters - `scope`: What to document - "commands", "specs", "improvements", "architecture", "all" (default: "all") - `detail_level`: Documentation depth - "brief", "standard", "comprehensive" (default: "standard") ### Examples ```bash # Update all documentation with standard detail /self-document all standard # Brief documentation of commands only /self-document commands brief # Comprehensive architecture documentation /self-document architecture comprehensive # Document recent improvements /self-document improvements standard ``` ## Command Implementation You are the **Self-Documentation System**. Your role is to analyze the current state and generate accurate, helpful documentation automatically. ### Phase 1: System Analysis 1. **Scan System Components** Based on `{{scope}}`: **Commands:** - Read all `.claude/commands/*.md` files - Extract purpose, parameters, capabilities - Identify interdependencies - Document recent changes **Specs:** - Read all `specs/*.md` files - Categorize by type and purpose - Document patterns and frameworks - Track auto-generated vs. manual **Improvements:** - Read `improvement_log/` directory - Extract evolution history - Summarize performance trends - Highlight key achievements **Architecture:** - Analyze overall system structure - Map component relationships - Document data flows - Identify meta-level capabilities 2. **Extract Key Information** For each component: - **Purpose:** What it does - **Capabilities:** What it can accomplish - **Usage:** How to use it - **Integration:** How it connects to other components - **Evolution:** How it has improved - **Meta-Properties:** Self-improvement capabilities ### Phase 2: Meta-Prompting Analysis 3. **Identify Meta-Patterns** Structure-oriented documentation: - What architectural patterns are used? - What abstract frameworks enable capabilities? - How do components enable self-improvement? - What meta-level properties exist? 4. **Extract Documentation Principles** From meta-prompting: - Focus on structure over specific examples - Document patterns, not just functions - Enable understanding through abstraction - Show evolution and improvement potential ### Phase 3: Documentation Generation 5. **Generate/Update README.md** ```markdown # Meta-Level Self-Improvement System **Version:** {{version}} **Last Updated:** {{timestamp}} **Status:** {{system_health_status}} ## Overview This is an advanced infinite loop variant with **meta-level self-improvement capabilities**. The system can analyze its own performance, improve its commands, generate new specifications, and evolve its orchestration strategy. ### Core Philosophy Built on **meta-prompting principles** from [promptingguide.ai](https://www.promptingguide.ai/techniques/meta-prompting): - **Structure-oriented:** Emphasizes patterns over content - **Abstract frameworks:** Uses generalizable templates - **Minimal dependency:** Reduces reliance on specific examples - **Efficient reasoning:** Principle-driven over example-driven - **Self-improving:** Can enhance its own capabilities ## Quick Start ### Basic Usage ```bash # Generate content with self-improvement /infinite-meta specs/example_spec.md output/ 5 evolve # Analyze and improve the system /improve-self all standard # Generate new specifications /generate-spec patterns novel # Evolve orchestration strategy /evolve-strategy quality incremental # Validate everything works /self-test all standard # Update this documentation /self-document all standard ``` ### Available Commands {{#each commands}} #### `/{{name}}` {{purpose}} **Capabilities:** {{#each capabilities}} - {{this}} {{/each}} **Usage:** `{{usage_pattern}}` **Integration:** {{integration_notes}} {{/each}} ## System Architecture ### Component Overview ``` ┌─────────────────────────────────────────────┐ │ Meta-Level Control Layer │ │ - Self-analysis │ │ - Strategy evolution │ │ - Meta-prompting orchestration │ └─────────────────┬───────────────────────────┘ │ ┌─────────────────┴───────────────────────────┐ │ Command Layer │ │ - /infinite-meta (orchestrator) │ │ - /improve-self (analyzer) │ │ - /generate-spec (creator) │ │ - /evolve-strategy (evolver) │ │ - /self-test (validator) │ │ - /self-document (documenter) │ └─────────────────┬───────────────────────────┘ │ ┌─────────────────┴───────────────────────────┐ │ Data Layer │ │ - Specifications (generation templates) │ │ - Improvement logs (evolution history) │ │ - Meta-prompts (pattern library) │ │ - Generated content (outputs) │ └─────────────────────────────────────────────┘ ``` ### Data Flow 1. **Generation Flow:** Spec → infinite-meta → Sub-agents → Outputs → Improvement logs 2. **Improvement Flow:** Logs → improve-self → Proposals → evolve-strategy → Updated commands 3. **Evolution Flow:** Patterns → generate-spec → New specs → infinite-meta → More patterns 4. **Meta Flow:** System → self-test → Health data → self-document → Documentation ### Meta-Level Capabilities This system demonstrates advanced meta-capabilities: 1. **Self-Analysis:** Analyzes its own performance and identifies improvements 2. **Self-Modification:** Can improve its own commands and strategies (with safety) 3. **Self-Generation:** Creates new specifications from discovered patterns 4. **Self-Testing:** Validates its own functionality 5. **Self-Documentation:** Updates its own documentation (this file!) 6. **Recursive Improvement:** Improvements that improve improvements ## Specifications {{#each specs}} ### {{name}} {{description}} **Type:** {{type}} **Patterns:** {{patterns}} **Best For:** {{use_cases}} {{/each}} ## Performance Metrics **Current Performance:** - Quality Average: {{quality_avg}} / 10 - Efficiency Score: {{efficiency}} - Diversity Index: {{diversity}} - Meta-Awareness: {{meta_awareness}} **Evolution History:** - Total Improvements Applied: {{improvement_count}} - Average Quality Gain: +{{quality_gain}}% per improvement - System Age: {{age}} days - Total Iterations Generated: {{total_iterations}} **Health Status:** {{health_status}} ## Improvement Log ### Recent Improvements {{#each recent_improvements}} **{{date}}:** {{description}} - Impact: {{impact}} - Metrics: {{metrics_change}} {{/each}} ### Evolution Milestones {{#each milestones}} - **{{version}}** ({{date}}): {{achievement}} {{/each}} ## Usage Examples ### Example 1: Basic Generation with Evolution ```bash # Generate 20 iterations with continuous improvement /infinite-meta specs/example_spec.md output/ 20 evolve ``` This will: 1. Generate first wave (5 iterations) 2. Analyze performance 3. Evolve strategy 4. Generate second wave (improved) 5. Continue improving across 4 waves ### Example 2: Complete Self-Improvement Cycle ```bash # 1. Generate baseline /infinite-meta specs/example_spec.md baseline/ 10 # 2. Analyze for improvements /improve-self all deep # 3. Evolve strategy based on analysis /evolve-strategy quality incremental # 4. Generate with improved strategy /infinite-meta specs/example_spec.md improved/ 10 # 5. Compare results /self-test generation standard ``` ### Example 3: Auto-Generate and Use New Spec ```bash # 1. Generate new spec from patterns /generate-spec patterns novel custom_domain # 2. Use it immediately /infinite-meta specs/custom_domain.md output/ 10 evolve # 3. Document the results /self-document specs standard ``` ## Meta-Prompting in Practice ### How This System Applies Meta-Prompting **Structure-Oriented Design:** - Commands define frameworks, not just functions - Specs provide patterns, not examples - Improvements focus on structure, not content **Abstract Frameworks:** - Orchestration uses generalizable patterns - Quality metrics are principle-based - Evolution applies transferable insights **Minimal Example Dependency:** - Sub-agents receive structural guidance - Specs emphasize "how to think" vs "what to create" - Improvements extract abstract patterns **Efficient Reasoning:** - Reduced token usage through structural focus - Pattern-based generation over example-based - Meta-level optimization of processes ## Safety and Guardrails ### Self-Modification Safety The system can improve itself, but with safeguards: - ✓ All changes logged in improvement_log/ - ✓ Backups created before modifications - ✓ Rollback procedures for all improvements - ✓ Validation required before applying changes - ✓ Human oversight for major architectural changes ### Testing and Validation - Automated testing via /self-test - Regression detection - Performance monitoring - Health status tracking ## Troubleshooting ### System Health Check ```bash /self-test all smoke # Quick 5-minute validation ``` ### Common Issues **Quality Declining:** ```bash /improve-self all deep /evolve-strategy quality incremental ``` **Efficiency Issues:** ```bash /evolve-strategy efficiency experimental /self-test generation standard ``` **Documentation Outdated:** ```bash /self-document all comprehensive ``` ## Advanced Features ### Recursive Self-Improvement The system can improve the improvement process: 1. /improve-self analyzes the system 2. It can analyze /improve-self itself 3. Generate improvements to the analyzer 4. Apply those to make better analysis 5. Meta-meta-improvement! ### Pattern Library Evolution The `meta_prompts/` directory continuously evolves: - Successful patterns are added - Ineffective patterns are removed - Abstract frameworks are refined - Meta-level insights accumulate ## Contributing ### Adding New Capabilities 1. Create command in `.claude/commands/` 2. Follow meta-prompting principles 3. Add self-improvement hooks 4. Include meta-awareness 5. Run /self-test to validate 6. Run /self-document to update docs ### Improving Existing Commands 1. Use /improve-self to analyze 2. Generate proposals 3. Implement with safety checks 4. Validate with /self-test 5. Document with /self-document ## Future Directions Potential evolution paths: - Multi-agent collaboration improvements - Enhanced pattern recognition - Cross-domain learning integration - Advanced meta-meta-prompting - Autonomous goal setting - Self-optimizing context management ## References - **Meta-Prompting Guide:** https://www.promptingguide.ai/techniques/meta-prompting - **Improvement Logs:** `improvement_log/` - **Meta-Prompts Library:** `meta_prompts/` - **System Architecture:** `docs/self_improvement_guide.md` --- *This documentation was auto-generated by /self-document on {{timestamp}}. It reflects the current state of the system and will be automatically updated as the system evolves.* **Meta-Note:** This README can improve itself. If you notice outdated information, run `/self-document all comprehensive` to regenerate. ``` 6. **Generate CLAUDE.md** ```markdown # CLAUDE.md - Project Instructions **Auto-generated:** {{timestamp}} **System Version:** {{version}} ## Project Overview This is **Infinite Loop Variant 7**: A meta-level self-improvement system that can analyze, improve, and evolve itself using meta-prompting principles. ### Key Differentiator Unlike other infinite loop variants, this system has **meta-level awareness**: - Can improve its own commands - Generates new specifications from patterns - Evolves its orchestration strategy - Self-tests and self-documents - Applies recursive self-improvement ## Quick Start for Claude Code When working in this repository: ### Primary Commands ```bash # Main orchestration with self-improvement /infinite-meta [evolve] # Self-improvement utilities /improve-self [target] [depth] /generate-spec [source] [focus] [name] /evolve-strategy [metric] [type] /self-test [scope] [depth] /self-document [scope] [detail] ``` ### Typical Workflows **Workflow 1: Generati and Improve** ```bash /infinite-meta specs/example_spec.md output/ 20 evolve ``` **Workflow 2: Deep System Improvement** ```bash /improve-self all deep /evolve-strategy all incremental /self-test all standard /self-document all standard ``` **Workflow 3: Create New Capability** ```bash /generate-spec patterns novel domain_name /infinite-meta specs/domain_name.md output/ 10 evolve /self-test generation standard ``` ## Architecture ### Directory Structure ``` . ├── .claude/ │ ├── commands/ # All slash commands │ │ ├── infinite-meta.md │ │ ├── improve-self.md │ │ ├── generate-spec.md │ │ ├── evolve-strategy.md │ │ ├── self-test.md │ │ └── self-document.md │ └── settings.json # Permissions ├── specs/ # Specifications (generation templates) │ ├── example_spec.md │ └── auto_generated_*.md ├── improvement_log/ # Evolution history and metrics │ ├── wave_*_reflection.md │ ├── wave_*_proposals.md │ ├── evolved_strategy_*.md │ ├── test_report_*.md │ └── system_health.json ├── meta_prompts/ # Pattern library │ ├── command_improver.md │ ├── spec_generator.md │ └── orchestration_strategy.md ├── docs/ # Documentation │ └── self_improvement_guide.md ├── README.md # Auto-generated docs └── CLAUDE.md # This file (auto-generated) ``` ### Key Principles **Meta-Prompting Based:** - Structure over content - Patterns over examples - Abstraction over specifics - Efficiency through principles **Self-Improving:** - Analyzes own performance - Generates improvement proposals - Evolves strategy safely - Validates changes automatically **Safety-First:** - All modifications logged - Rollback procedures standard - Validation before application - Health monitoring continuous ## Command Responsibilities {{#each commands}} ### {{name}} **Role:** {{role}} **Key Actions:** {{actions}} **Integrates With:** {{integrations}} {{/each}} ## Meta-Level Capabilities 1. **Self-Analysis:** System examines its own processes 2. **Self-Modification:** Commands can be improved (safely) 3. **Self-Generation:** New specs created from patterns 4. **Self-Validation:** Automated testing of capabilities 5. **Self-Documentation:** This file updates itself! 6. **Recursive:** Can improve the improvement process ## Working with This System ### For Generation Tasks Use `/infinite-meta` with `evolve` mode: - System will improve across waves - Quality increases progressively - Strategy evolves automatically - Learnings accumulate in logs ### For System Improvement Use `/improve-self` then `/evolve-strategy`: - Analyzes current state deeply - Proposes concrete improvements - Evolves orchestration approach - Validates with /self-test ### For New Capabilities Use `/generate-spec` to create specs: - Analyzes existing patterns - Generates new specifications - Tests with small batch - Refines based on results ### For Validation Use `/self-test` regularly: - Smoke test after changes - Standard test weekly - Comprehensive before releases - Detects regressions early ## Important Notes ### Safety Guardrails - **Never** modify core commands without validation - **Always** create backups before improvements - **Test** changes with /self-test before full deployment - **Document** all modifications in improvement_log/ - **Rollback** if metrics regress >15% ### Performance Monitoring Check `improvement_log/system_health.json` for: - Current health status - Recent performance trends - Known issues - Improvement progress ### Context Management This system is context-aware: - Monitors token usage - Optimizes batch sizes - Uses efficient prompting - Prunes unnecessary context ## Evolution History **Current Version:** {{version}} {{#each evolution_history}} **v{{version}}** ({{date}}): - {{change_summary}} - Impact: {{impact}} {{/each}} ## Troubleshooting **System not improving:** - Check improvement_log/ for analysis - Run /improve-self all deep - Verify metrics in system_health.json **Quality declining:** - Run /self-test generation standard - Use /evolve-strategy quality incremental - Review recent changes in logs **Documentation outdated:** - Run /self-document all comprehensive - System will auto-update README and this file ## References - Main documentation: README.md (auto-generated) - Architecture guide: docs/self_improvement_guide.md - Pattern library: meta_prompts/ - Evolution history: improvement_log/ --- *This file is auto-maintained by /self-document. Last updated: {{timestamp}}* ``` 7. **Generate Improvement Guide** Create `docs/self_improvement_guide.md`: ```markdown # Self-Improvement System Architecture Guide **Auto-generated:** {{timestamp}} ## Overview This guide explains how the meta-level self-improvement system works, enabling you to understand, use, and extend its capabilities. ## Core Concepts ### Meta-Prompting Based on principles from https://www.promptingguide.ai/techniques/meta-prompting: **Structure-Oriented:** - Focus on patterns and frameworks - Define "how to think" not "what to create" - Enable generalization across contexts **Minimal Example Dependency:** - Reduce reliance on specific examples - Use abstract templates - Principle-driven reasoning **Efficient Reasoning:** - Less token usage through structural focus - Pattern recognition over memorization - Meta-level optimization ### Self-Improvement Loop ``` ┌─────────────────────────────────────────┐ │ 1. GENERATE │ │ /infinite-meta creates content │ │ Logs performance metrics │ └──────────────┬──────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ 2. ANALYZE │ │ /improve-self reviews performance │ │ Identifies improvement opportunities │ └──────────────┬──────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ 3. EVOLVE │ │ /evolve-strategy creates new approach│ │ Updates orchestration patterns │ └──────────────┬──────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ 4. VALIDATE │ │ /self-test confirms improvements │ │ Detects any regressions │ └──────────────┬──────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ 5. DOCUMENT │ │ /self-document updates docs │ │ Records evolution history │ └──────────────┬──────────────────────────┘ │ └──────────► Back to 1. GENERATE (improved) ``` [Continue with detailed architectural explanations...] ``` ### Phase 4: Component-Specific Documentation 8. **Document Commands** (if scope includes "commands") For each command in `.claude/commands/`: - Extract purpose and usage - Document parameters and options - Show integration points - Include examples 9. **Document Specs** (if scope includes "specs") Create `specs/README.md`: - List all specifications - Categorize by type - Show usage patterns - Include generation statistics 10. **Document Improvements** (if scope includes "improvements") Create `improvement_log/IMPROVEMENTS.md`: - Timeline of all improvements - Metrics progression - Key milestones - Lessons learned ### Phase 5: Update and Finalize 11. **Update Timestamps** Add "Last Updated" timestamps to all generated docs. 12. **Generate Documentation Index** Create `docs/INDEX.md` linking all documentation. 13. **Validate Links and References** Ensure all internal links work and references are accurate. ## Success Criteria Successful self-documentation: 1. Accurate reflection of current state 2. Clear and helpful for users 3. Shows evolution and improvements 4. Demonstrates meta-capabilities 5. Auto-updates when system changes 6. Enables understanding and extension --- *This command maintains system documentation using meta-prompting principles. It analyzes structure and generates documentation that reflects both current capabilities and evolution potential.*