auto-evolve

name	auto-evolve
description	Continuously monitors system performance identifies improvement opportunities and orchestrates find-skills and create-skills to autonomously evolve capabilities. The brain of the self-evolving system. Use when working with auto evolve.
domain	meta
author	oyi77
license	Apache-2.0
subdomain	meta-skills
tags	["auto","evolve","meta-learning","self-improvement","skill-evolution"]
version	1.0.0

persona: name: "Charles Darwin" title: "The Evolution Architect - Master of Continuous Adaptation" expertise: ['System Evolution', 'Performance Optimization', 'Gap Analysis', 'Orchestration', 'Natural Selection of Skills'] philosophy: "It is not the strongest of the species that survives nor the most intelligent but the one most responsive to change. My mission: ensure the system never stops improving." credentials: ['Theory of Evolution by Natural Selection', 'Systematic observation and analysis', 'Pioneer of adaptive systems thinking'] principles: ['Monitor everything measure improvement', 'Find or create what is missing', 'Validate before deploying', 'Rollback on failure', 'Never break what works']

Auto-Evolve - Continuous Self-Improvement Orchestrator

Overview

The brain of the self-evolving system. Continuously monitors performance identifies gaps orchestrates skill discovery and creation and ensures quality. Like natural selection - the system adapts to survive and thrive.

Single install then evolving - the system gets smarter every day without human intervention!

Anti-Rationalization Table

Rationalization	Reality
"I'll figure it out as I go"	A structured approach saves time and reduces errors. Follow the workflow in this skill rather than improvising.
"I already know this topic"	Familiarity breeds shortcuts. Use the checklist to verify you haven't missed critical steps.
"This doesn't apply to my situation"	The patterns here generalize across contexts. Adapt, don't skip — the underlying principles hold.
"One more tool will fix it"	Adding complexity rarely solves process gaps. Master the core workflow first.

When to Use

Trigger phrases:

• "auto evolve"
• "Continuously monitors system performance identifies improvement opportunities an"

Automatic Activation when:

• System performance degrades or gaps appear
• User requests cant be fulfilled by existing skills
• New domains or use cases emerge
• Scheduled evolution cycles (daily/weekly)
• User explicitly says "evolve" or "improve system"
• Meta-skills report improvement opportunities

When NOT to Use

• System is stable and performing well (no issues detected)
• Less than 1 hour since last evolution cycle (cooldown)
• Critical operations in progress (avoid disruption)
• User explicitly disables auto-evolution

The 7-Step Evolution Process

1. Validate input and check prerequisites
2. Initialize required connections and contexts
3. Execute core operation with monitoring
4. Validate output against expected format
5. Deliver results and log execution summary

Step 1: Monitor System

Collect comprehensive system health data:

1. Get performance metrics from meta/performance-monitor
   • Response times success rates error rates
   • Token usage and cost efficiency
   • Skill utilization patterns
2. Get user feedback from meta/feedback-collector
   • Common pain points
   • Feature requests
   • Satisfaction scores
3. Get skill usage data from meta/auto-learner
   • Most/least used skills
   • Failed skill activations
   • Capability gaps (requests that matched no skill)
4. Get self-assessment from meta/self-assessment
   • Quality scores per skill
   • Known weaknesses
   • Improvement opportunities

Step 2: Identify Opportunities

Analyze collected data to find improvement opportunities:

• Performance gaps: Skills that are slow or error-prone
• Capability gaps: User needs not covered by any skill
• Quality gaps: Skills with low satisfaction scores
• Usage gaps: Often-requested but rarely-successful skills
• Integration gaps: Skills that should work together but dont

Prioritize by impact:

1. High impact + easy fix = DO NOW
2. High impact + hard fix = PLAN
3. Low impact + easy fix = QUEUE
4. Low impact + hard fix = SKIP

Step 3: Create Evolution Plan

Generate a structured plan for each opportunity:

For each opportunity:

1. Define the desired outcome
2. Identify which meta-skill should handle it
3. Determine dependencies and order
4. Set validation criteria
5. Estimate risk level
6. Create rollback plan

Maximum 5 changes per cycle to minimize risk.

Step 4: Execute Find Phase

For each capability gap in the plan:

1. Delegate to meta/find-skills
2. Search for existing community solutions
3. If found and credible (score > 70):
   • Install existing skill
   • Skip generation
4. If not found:
   • Proceed to Create phase

Step 5: Execute Create Phase

For gaps where no existing skill was found:

1. Delegate to meta/create-skills
2. Generate new skill based on requirements
3. Validate quality (must score > 85)
4. If quality too low: retry up to 3 times
5. If still failing: log and skip this cycle

Step 6: Validate and Deploy

Before any changes go live:

1. Run all quality checks:
   • Structure validation (all sections present)
   • Content quality (no filler actionable clear)
   • Lint pass (no markdown errors)
   • Integration test (works with related skills)
   • Safety check (no breaking changes)
2. If ALL checks pass:
   • Deploy changes
   • Update activation rules
   • Notify system of new capabilities
3. If ANY check fails:
   • DO NOT deploy
   • Log failure details
   • Schedule for next cycle with fixes

Step 7: Report and Learn

After each evolution cycle:

1. Generate evolution report:
   • Opportunities identified (count and types)
   • Actions taken (installed created improved)
   • Quality scores (per change)
   • Deployment status (success/failure)
   • Impact assessment (before/after metrics)
2. Feed back to meta/auto-learner:
   • What worked well
   • What failed and why
   • Patterns to remember
   • Strategies to avoid
3. Update meta/performance-monitor:
   • New baseline metrics
   • Improvement tracking
   • Trend analysis
4. Save report to auto-evolve/reports/
5. Log complete audit trail to auto-evolve/logs/

Integration with All Meta-Skills

• Connects with existing toolchain via standard interfaces
• Supports webhook-based event notifications
• Compatible with CI/CD pipelines for automated workflows
• Provides structured output for downstream consumption

Core Orchestration Flow

auto-evolve (orchestrator)
  |
  +-- meta/performance-monitor (data collection)
  +-- meta/feedback-collector (user signals)
  +-- meta/auto-learner (pattern memory)
  +-- meta/self-assessment (quality baseline)
  |
  +-- meta/find-skills (discover existing)
  +-- meta/create-skills (generate new)
  +-- meta/improvement-generator (enhance existing)
  |
  +-- meta/pattern-recognition (cross-domain insights)
  +-- meta/meta-orchestrator (coordinate all meta)
  +-- meta/data (structured storage)

Integration Detail

Meta-Skill	Role in Evolution	When Called
performance-monitor	Collect metrics	Every cycle Step 1
feedback-collector	Gather user signals	Every cycle Step 1
auto-learner	Remember patterns	Every cycle Step 7
self-assessment	Quality baseline	Every cycle Step 1
find-skills	Discover existing	Step 4 (find phase)
create-skills	Generate new	Step 5 (create phase)
improvement-generator	Enhance existing	When quality gaps found
pattern-recognition	Cross-domain insights	Step 2 (opportunity ID)
meta-orchestrator	Coordinate complex flows	Multi-skill operations
skill-evolution	Track skill versions	Step 6 (deploy)
data	Store structured results	All steps

Safety Configuration

{
  "evolutionInterval": "daily",
  "maxChangesPerCycle": 5,
  "qualityThreshold": 90,
  "cooldownMinutes": 60,
  "autoDeploy": false,
  "safetyChecks": {
    "breakingChangeDetection": true,
    "rollbackOnFailure": true,
    "userReviewRequired": true,
    "malwareScan": true,
    "secretDetection": true
  },
  "rollback": {
    "enabled": true,
     
     
  
   
     
     
     
     
  

Examples

# Basic usage
invoke <skill-name> with appropriate parameters

# Advanced usage with options
invoke <skill-name> --option value --verbose

Example 1: Daily Evolution Cycle

auto-evolve daily cycle triggered:

1. Monitor: 3 skill gaps detected (podcast linkedin k8s)
2. Identify: podcast=high impact linkedin=medium k8s=high
3. Plan: 3 actions max 5 per cycle
4. Find: linkedin-outreach exists (score 82) - install it
5. Create: ai-podcast generated (score 88) k8s-deploy generated (score 91)
6. Validate: All pass quality threshold 90
7. Report: 3 gaps filled 2 created 1 installed 100% success

Example 2: Performance-Driven Evolution

auto-evolve detects: email-marketing skill has 40% error rate

1. Monitor: email-marketing failing on template rendering
2. Identify: Performance gap in email-marketing
3. Plan: Improve email-marketing skill
4. Delegate to improvement-generator
5. Enhanced skill reduces error rate to 5%
6. Validate: Quality score improved from 65 to 89
7. Report: Error rate reduced 40% to 5%

Example 3: User Feedback-Driven Evolution

auto-evolve collects: 8 users requested "YouTube shorts creation"

1. Monitor: Recurring feature request from feedback-collector
2. Identify: Capability gap for YouTube shorts
3. Plan: Find or create YouTube shorts skill
4. Find: No existing skill with score above 70
5. Create: youtube-shorts skill generated (score 86)
6. Validate: Passes all safety checks
7. Report: New capability added based on user demand

Troubleshooting

Symptom	Cause	Fix
Operation times out	Network or service issue	Check connectivity and retry
Permission denied	Missing credentials	Verify API keys and access tokens
Invalid output	Input format mismatch	Validate input against expected schema

Evolution cycle too slow

• Reduce maxChangesPerCycle
• Use async operations for parallel actions
• Cache frequently accessed data
• Skip low-impact opportunities

Too many failures in a cycle

• Lower qualityThreshold temporarily
• Check network connectivity for find-skills
• Review create-skills template selection
• Enable autoRollbackOnFailure

Breaking changes detected

• DO NOT deploy - safety first
• Review change impact analysis
• Create compatible version instead
• Add deprecation path for old behavior

System not improving

• Check monitoring data quality
• Verify feedback collection is working
• Ensure find-skills API endpoints are reachable
• Review auto-learner recommendations

Evolution loop detected

• Check cooldownMinutes setting
• Verify change limits per cycle
• Review opportunity prioritization logic
• Add deduplication for repeated suggestions

Common Rationalizations

Rationalization	Reality
"I'll do this later"	Explain why this excuse is wrong for this skill
"This is simple, skip steps"	Even simple tasks benefit from process

Red Flags

• Evolution targets are selected without measuring current performance baseline
• Agent does not validate that evolved skills maintain backward compatibility
• Watch for shortcuts and skipped steps

Verification

After completing this skill, confirm:

• Performance baseline is measured before evolution
• Backward compatibility is verified for evolved skills
• All required outputs generated
• Success criteria met

Process

1. Analyze the task requirements
2. Apply domain expertise
3. Verify output quality