---

name: skill-evolution description: Review accumulated feedback and propose skill updates. Use periodically or when evolution triggers accumulate. Requires user approval before modifying skills. allowed-tools: "Read,Write,Edit,Grep,Glob,mcp__plugin_claude-mem_mcp-search__search,mcp__plugin_claude-mem_mcp-search__timeline,mcp__plugin_claude-mem_mcp-search__get_observations" version: 1.1.0

Evolve Skills Based on Accumulated Feedback

Analyze feedback patterns and propose targeted skill improvements with human oversight.

Overview

This skill implements adaptive skill evolution - the T2 paradigm where tool modules (skills) improve based on execution feedback while the core model (Claude) remains stable.

Key Principle: Skills evolve; Claude doesn't. This decouples learning from reasoning.

When to Invoke

• When skill-feedback flags evolution triggers
• Periodically (weekly/monthly) to review accumulated patterns
• When user requests skill improvement
• After repeated failures with a specific skill

Instructions

Step 1: Search for Evolution Triggers

Query claude-mem for pending evolution triggers:

CopyQuery: "evolution trigger PENDING_REVIEW"

List all skills with accumulated feedback patterns.

Step 2: Analyze Pattern Evidence

For each triggered skill:

1. Retrieve all related feedback observations
2. Identify common themes across occurrences
3. Quantify the pattern (frequency, impact, consistency)

Create analysis summary:

Copy## Evolution Analysis: [Skill Name]

**Pattern Count:** [N occurrences]
**Time Span:** [First occurrence] to [Last occurrence]
**Confidence:** [high|medium|low]

### Evidence Summary
| Date | Task | Pattern Instance |
|------|------|------------------|
| ... | ... | ... |

### Root Cause
[Why this pattern keeps occurring]

### Proposed Change
[Specific modification to skill content]

Step 3: Draft Skill Modification

Read the current skill:

CopyRead: .claude/skills/[skill-name]/SKILL.md

Draft the specific change:

Copy## Proposed Edit: [Skill Name]

### Current Content (lines X-Y)

[existing text]

Copy
### Proposed Content

[new text]

Copy
### Rationale
[Why this change addresses the pattern]

### Impact
- Prevents: [What errors/issues this avoids]
- Adds: [What new guidance this provides]
- Risk: [Any potential downsides]

Step 4: Present for User Approval

CRITICAL: Never modify skills without explicit user approval.

Present the proposal clearly:

CopyEvolution Proposal for: [skill-name]

Pattern: [Brief description of what keeps happening]
Evidence: [N occurrences over N days/weeks]
Change: [One-sentence summary of modification]

Detailed diff:
[Show exact before/after]

Options:
1. Approve and apply
2. Modify proposal
3. Reject (pattern not significant)
4. Defer (need more evidence)

Step 5: Apply Approved Changes

Only after explicit user approval:

1. Use Edit tool to modify the skill file
2. Update skill version in frontmatter (increment patch version)
3. Record the evolution in claude-mem:

Copy## Skill Evolution Applied: [Skill Name]

**Version:** [old] → [new]
**Date:** [ISO date]
**Pattern Addressed:** [description]
**Change Summary:** [what was modified]
**Evidence IDs:** [observation IDs that triggered this]
**Approved By:** user

1. Mark related evolution triggers as RESOLVED

Step 6: Verify Evolution

After applying changes:

1. Review the modified skill for consistency
2. Check that the change doesn't conflict with other skills
3. Suggest a task to test the improved skill (optional)

Step 7: Generate Evidence Watchlist

Critical for bidirectional learning loop.

After analyzing all patterns, identify those approaching but not meeting threshold:

1. Query claude-mem for patterns with 1-2 occurrences (below 3x threshold)
2. Assess which patterns are likely to recur
3. Output watchlist for skill-feedback to prioritize

Copy## Evidence Watchlist

Patterns approaching threshold - prioritize capturing in future skill-feedback:

| Pattern | Skill | Count | Threshold | What to Watch For |
|---------|-------|-------|-----------|-------------------|
| [description] | [skill-name] | 2/3 | workaround | [specific situation] |
| [description] | [skill-name] | 1/2 | gotcha | [specific trigger] |

**Active Until:** [date 30 days from now]

Store watchlist in claude-mem with type evolution-watchlist.

This enables bidirectional evolution:

• Forward: feedback → evolution proposals
• Backward: evolution → watchlist → targeted feedback collection

Evolution Types

Safety Constraints

1. User approval required - Never auto-modify skills
2. One change at a time - Don't bundle multiple modifications
3. Preserve intent - Modifications should enhance, not rewrite
4. Version tracking - Always increment version on change
5. Evidence-based - Only propose changes with 2+ occurrences

Output Format

Summary Report

CopySkill Evolution Review Complete

Analyzed: [N] skills with feedback
Evolution Triggers Found: [N]

Proposed Changes:
1. [skill-name]: [brief description] - [awaiting approval]
2. [skill-name]: [brief description] - [awaiting approval]

No Changes Needed:
- [skill-name]: Patterns below threshold
- [skill-name]: No actionable patterns

Evidence Watchlist (for skill-feedback):
- [pattern]: [skill-name] - [N]/[threshold] observations
- [pattern]: [skill-name] - [N]/[threshold] observations

Next Review: [suggested date based on feedback velocity]

Integration with Workflow

This skill completes the bidirectional adaptive feedback loop:

Copy/plan → /implement → /verify → skill-feedback → skill-evolution
                                     ↓                  ↓
                                 [claude-mem]    [skill updates]
                                     ↑                  ↓
                                     ←←←← improved skills ←←←←

                              BIDIRECTIONAL LOOP:

skill-evolution ──→ Evidence Watchlist ──→ skill-feedback
       ↑                                         ↓
       └────────── targeted feedback ←──────────┘

Bidirectional benefits:

• Forward flow: Feedback accumulates → Evolution proposes changes
• Backward flow: Evolution identifies gaps → Watchlist guides feedback collection

Skills improve incrementally based on real usage patterns, not hypothetical scenarios.