---

name: skill-feedback description: Capture task outcomes and patterns after completing work. Use after /verify or when a task succeeds/fails to enable adaptive skill evolution. allowed-tools: "Read,Grep,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

Capture Task Feedback for Adaptive Evolution

Record what worked, what failed, and emerging patterns to enable continuous skill improvement.

Overview

This skill implements the Agentic Context Engineering (ACE) pattern from adaptive AI research. Instead of static playbooks, skills evolve based on accumulated execution feedback.

When to Invoke

• After /verify completes (success or failure)
• When a skill-based task finishes
• When you discover a pattern that should be remembered
• When a workaround is needed repeatedly

Instructions

Step 0: Check Evidence Watchlist

Before capturing feedback, check for active watchlist items.

Query claude-mem:

CopyQuery: "evolution-watchlist"

If a watchlist exists:

1. Review the watched patterns
2. Check if current task relates to any watched item
3. Prioritize capturing feedback for watched patterns (they're close to evolution threshold)

This closes the bidirectional loop - evolution requests specific evidence, feedback delivers it.

Step 1: Identify the Completed Task

Determine:

1. Task type: Feature, bugfix, refactor, research, debugging
2. Skills used: Which skills were invoked during the task
3. Outcome: Success, partial success, or failure
4. Watchlist match: Does this task relate to any watched patterns?

Step 2: Capture Structured Feedback

Record the following to claude-mem:

Copy## Task Feedback: [Brief Description]

**Task Type:** [feature|bugfix|refactor|research|debug]
**Skills Used:** [skill-1, skill-2, ...]
**Outcome:** [success|partial|failure]
**Date:** [ISO date]
**Watchlist Match:** [pattern name if matches, or "none"]

### What Worked
- [Specific technique or approach that succeeded]
- [Tool combination that was effective]

### What Failed
- [Approach that didn't work and why]
- [Unexpected obstacle encountered]

### Pattern Detected
- [Recurring situation that could inform skill updates]
- [Workaround that should be formalized]

### Suggested Improvement
- **Skill:** [skill-name]
- **Change:** [Specific addition or modification]
- **Rationale:** [Why this would help future tasks]

If Watchlist Match: Add explicit tag watchlist-evidence:[pattern-name] to help skill-evolution find this feedback quickly.

Step 3: Check for Pattern Accumulation

Search claude-mem for similar feedback:

CopyQuery: "skill feedback [skill-name]"

If 3+ similar patterns exist:

1. Flag for skill evolution review
2. Summarize the accumulated pattern
3. Draft specific skill modification

Step 4: Record Evolution Trigger (If Applicable)

When pattern threshold is met:

Copy## Evolution Trigger: [Skill Name]

**Pattern Count:** [N occurrences]
**Pattern Summary:** [What keeps happening]
**Proposed Change:** [Specific skill modification]
**Evidence IDs:** [claude-mem observation IDs]

**Status:** PENDING_REVIEW

Feedback Categories

Pattern Detection Thresholds

Integration with Memory

Use claude-mem to:

1. Store feedback with type skill-feedback
2. Search patterns by skill name and outcome
3. Track evolution triggers for review

Output Format

After capturing feedback, summarize:

CopyFeedback Recorded:
- Task: [description]
- Outcome: [success/partial/failure]
- Patterns: [N new patterns detected]
- Evolution Triggers: [N skills flagged for review]
- Watchlist Evidence: [N patterns advanced toward threshold]

If watchlist items were matched, highlight them:

CopyWatchlist Progress:
- [pattern]: [skill-name] - now [N]/[threshold] (was [N-1]/[threshold])

Example

Copy## Task Feedback: Implemented user authentication

**Task Type:** feature
**Skills Used:** backend-api-standards, testing-writing-guidelines
**Outcome:** success
**Date:** 2026-01-06
**Watchlist Match:** jwt-expiry-format

### What Worked
- TDD approach caught edge case early (empty password)
- Using pytest fixtures from existing tests saved time

### What Failed
- Initially missed rate limiting requirement
- First JWT implementation had wrong expiry format

### Pattern Detected
- Third time seeing JWT expiry format confusion
- Pattern: datetime vs Unix timestamp mismatch

### Suggested Improvement
- **Skill:** backend-api-standards
- **Change:** Add JWT section with explicit expiry format example
- **Rationale:** Prevents recurring timestamp format errors

Tags: watchlist-evidence:jwt-expiry-format

Output after this feedback:

CopyFeedback Recorded:
- Task: Implemented user authentication
- Outcome: success
- Patterns: 1 new pattern detected
- Evolution Triggers: 1 skill flagged for review
- Watchlist Evidence: 1 pattern advanced

Watchlist Progress:
- jwt-expiry-format: backend-api-standards - now 3/3 (was 2/3) → THRESHOLD MET

Integration: Bidirectional Evolution Loop

This skill is part of a bidirectional learning system:

Copy                    FORWARD FLOW (passive)
task execution → skill-feedback → claude-mem → skill-evolution → proposals
                                                      ↓
                    BACKWARD FLOW (active)            ↓
skill-feedback ←← Evidence Watchlist ←←←←←←←←←←←←←←←←
      ↓
   targeted capture → accelerates threshold

Why bidirectional matters:

• Passive only: Patterns accumulate randomly, evolution is slow
• With watchlist: Evolution requests specific evidence, feedback delivers it, thresholds met faster

The watchlist transforms feedback from "record everything" to "prioritize what matters for evolution."