# 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 <spec> <output> <count> [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.*
