skill-evolve

Name: skill-evolve
Author: UniClipboard

Data Community

Repo stars 479
Author repo UniClipboard

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: Meta-skill for evolving other skills. Invoke after resolving a real-world issue to extract lessons and merge them into the refer…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “When to Use”, “Procedure”, “Step 1 — Gather Context”, “Step 2 — Classify the Learning”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name skill-evolve directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “When to Use / Procedure / Step 1 — Gather Context” before expanding.

Boundaries And Review

Dependencies: It usually needs no extra API key, so start with a small validation task.
Permissions: Declared permissions include read / write / shell-exec; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

Skill Evolve

Turn real-world experience into durable skill knowledge.

When to Use

User invokes this skill after completing work that revealed a gap, pitfall, or new pattern not yet captured in an existing SKILL.md. Typical trigger: /skill-evolve @path/to/SKILL.md

Procedure

Step 1 — Gather Context

Read the referenced SKILL.md in full.
Review the current conversation to identify:
- What went wrong or was discovered (the incident/finding)
- Root cause (why it happened)
- The fix or pattern (what the correct approach is)
- Why the existing skill didn't prevent it (the gap)

Step 2 — Classify the Learning

Determine which type of update is needed:

Type	Description	Example
New Rule	A pattern/anti-pattern not covered at all	`.entered()` in async is forbidden
Rule Refinement	Existing rule needs caveats or edge cases	`skip_all` needed when params include trait objects
New Example	Correct/incorrect code pattern to illustrate existing rule	`async {}.instrument(span).await` for match arms
Checklist Addition	New review checkpoint	"`.entered()` held across `.await`? FORBIDDEN"
Section Expansion	Existing section needs a new subsection	Adding async lifecycle patterns to spawn section

Step 3 — Draft the Update

Write the proposed additions following these principles:

Match the existing style — same heading levels, table formats, code block conventions
Place it where it belongs — near related content, not appended randomly at the end
Lead with the rule, then the why, then the example
Include both CORRECT and FORBIDDEN patterns when adding anti-patterns
Keep it concise — skills are reference material, not tutorials

Step 4 — Apply and Summarize

Edit the SKILL.md with the new content.
Present a summary to the user:

## Skill Evolution Summary

**Skill**: <skill name>
**Trigger**: <what happened that revealed the gap>
**Update type**: <New Rule | Rule Refinement | New Example | Checklist Addition | Section Expansion>
**What was added**:
- <bullet summary of each change>
**Section(s) modified**: <list of modified section numbers/names>

Quality Gates

Before applying the update, verify:

The new content does NOT duplicate existing rules (check the full SKILL first)
The new content is grounded in a real incident from this conversation (not hypothetical)
Code examples compile conceptually (correct syntax, realistic types)
The learning is generalizable — useful beyond this one specific case
If adding a FORBIDDEN pattern, a CORRECT alternative is shown alongside it

Anti-Patterns for This Skill

Don't bloat: If the learning is too narrow or one-off, suggest the user add it to memory instead of a skill
Don't rewrite: Evolve the skill incrementally. Don't restructure or rewrite existing sections unless they are wrong
Don't speculate: Only add patterns that were validated in practice during this conversation
Don't duplicate: If the fix was specific to one codebase and not transferable, it belongs in CLAUDE.md, not a skill

Fluxly profile Author and license come from source; runtime, permissions, and network are Fluxly detections or estimates

Fluxly category: Data
Author-declared agents: No explicit declaration found; this is not inferred or tested compatibility
Static check: 88 / 100 · heuristic scan, not runtime safety proof
Author / version / license: @UniClipboard · no license declared
Fluxly token estimate: Lean
Fluxly setup estimate: Guided setup
External API key: No requirement detected
Detected OS requirements: Unspecified
Runtime requirements: Unspecified
Detected file/system behavior: Read-only
Write / modify
Shell exec
Detected network behavior: Local-only
Install commands: None (reference only)

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。

Output preview skill-evolve-uniclipboard.preview

The current SKILL.md does not define a fixed output example.

SKILL.md SKILL.md

# Skill Evolve

Turn real-world experience into durable skill knowledge.

## When to Use

User invokes this skill after completing work that revealed a gap, pitfall, or new pattern not yet captured in an existing SKILL.md. Typical trigger: `/skill-evolve @path/to/SKILL.md`

## Procedure

### Step 1 — Gather Context

1. Read the referenced SKILL.md in full.
2. Review the current conversation to identify:
   - **What went wrong or was discovered** (the incident/finding)
   - **Root cause** (why it happened)
   - **The fix or pattern** (what the correct approach is)
   - **Why the existing skill didn't prevent it** (the gap)

### Step 2 — Classify the Learning

Determine which type of update is needed:

| Type                   | Description                                                | Example                                             |
| ---------------------- | ---------------------------------------------------------- | --------------------------------------------------- |
| **New Rule**           | A pattern/anti-pattern not covered at all                  | `.entered()` in async is forbidden                  |
| **Rule Refinement**    | Existing rule needs caveats or edge cases                  | `skip_all` needed when params include trait objects |
| **New Example**        | Correct/incorrect code pattern to illustrate existing rule | `async {}.instrument(span).await` for match arms    |
| **Checklist Addition** | New review checkpoint                                      | "`.entered()` held across `.await`? FORBIDDEN"      |
| **Section Expansion**  | Existing section needs a new subsection                    | Adding async lifecycle patterns to spawn section    |

### Step 3 — Draft the Update

Write the proposed additions following these principles:

…

Evidence boundary and execution chain

Author text anchors workflow facts; Fluxly only indexes current sections, terms, files, and commands.

sections -> When to Use → Procedure → Step 1 — Gather Context → Step 2 — Classify the Learning → Step 3 — Draft the Update → Step 4 — Apply and Summarize
terms    -> What went wrong or was discovered · Root cause · The fix or pattern · Why the existing skill didn't prevent it · New Rule · Rule Refinement · New Example · Checklist Addition
files/cmd -> /skill-evolve @path/to/SKILL.md · .entered() · skipall · async {}.instrument(span).await · .await
body sha256 -> 2b372d3a3e2b