Managing Skill Lifecycle
Managing Skill Lifecycle
Full-lifecycle meta-skill framework: CREATE → EVALUATE → OPTIMIZE → EVOLVE. Produces certifiable, reusable skill artifacts rather than ad-hoc prompts.
Pick the lifecycle stage matching the request:
| User intent | Stage | Entry point |
|---|---|---|
| "Make a skill that does X" | CREATE | Choose template type → scaffold → fill |
| "Is this skill any good? / Score it" | EVALUATE | Run 1000-point pipeline |
| "Make this skill better" | OPTIMIZE | Run up to 20 iterative rounds |
| "Update skill for new version/platform" | EVOLVE | Run UTE protocol |
Example invocation:
Request: "Create a skill for reviewing SQL migrations"
→ Stage: CREATE
→ Template: Analytical/Review type
→ Output: skill-review-sql-migrations.md with frontmatter, workflow, examples
→ Offer: "Run EVALUATE pipeline on this now? (y/n)"
Stage 1: CREATE
Progress:
- Classify skill type: Generative (produces artifacts), Analytical (reviews/evaluates), Procedural (multi-step process), Conversational (guides dialogue), or Integration (connects systems/APIs)
- Select matching template for that type
- Draft YAML frontmatter (name: gerund-kebab-case, description: third-person + triggers, ≤1024 chars)
- Fill Quick Start, Workflow, Examples (min 2), Best Practices, Pitfalls
- Target platform check: Claude (skill.md), OpenCode (tool-compatible format), OpenClaw (agent manifest) — adjust structure accordingly
- Validate against naming/length rules before handoff to EVALUATE
Stage 2: EVALUATE (1000-point pipeline)
Score across 5 categories, 200 points each:
- Structural integrity (frontmatter correctness, section completeness, length discipline)
- Clarity & specificity (concrete examples vs vague abstractions, actionable steps)
- Trigger precision (description unambiguously signals when to invoke vs when not to)
- Robustness (handles edge cases, includes pitfalls, negative boundaries defined)
- Reusability (works across inputs, not hardcoded to one example)
Certification tiers:
- 900-1000: Gold certified — deploy as-is
- 700-899: Silver — functional, recommend 1 OPTIMIZE pass
- 500-699: Bronze — needs 3+ OPTIMIZE rounds
- <500: Reject — recreate from template
Stage 3: OPTIMIZE (iterative, max 20 rounds)
Progress:
- Round N: Run EVALUATE, record score
- Identify lowest-scoring category, apply targeted fix only (don't rewrite wholesale)
- Re-run EVALUATE; if score delta < 10 points for 2 consecutive rounds, stop early (convergence)
- Stop at round 20 regardless of score; report final tier + remaining gaps
- Log each round's score delta so regressions are visible
Stage 4: EVOLVE (UTE Protocol — Upgrade/Transfer/Extend)
- Upgrade: detect target platform/version change, remap frontmatter and structural conventions
- Transfer: port skill semantics across platforms (Claude ↔ OpenCode ↔ OpenClaw) preserving trigger logic
- Extend: add new workflow branches/examples without breaking existing certification tier
- Re-run EVALUATE post-evolution; never ship an evolved skill below its pre-evolution tier
Example 1 — CREATE
Input: "I need a skill for generating commit messages from diffs"
Output: Classified as Generative type → writing-commit-messages skill with frontmatter, Quick Start showing a diff→message example, workflow (parse diff → categorize change → draft message → validate format), 2 examples, pitfalls (e.g., "don't summarize the diff verbatim").
Example 2 — EVALUATE Input: An existing skill file with thin frontmatter description and no pitfalls section Output: Score breakdown — Structural 140/200, Clarity 160/200, Trigger precision 90/200 (vague description), Robustness 60/200 (no pitfalls/edge cases), Reusability 150/200. Total: 600/1000 → Bronze, recommend 3+ OPTIMIZE rounds targeting trigger precision and robustness first.
Example 3 — OPTIMIZE Input: Bronze-tier skill at 600/1000 Output: Round 1 fixes trigger precision (+95 → 695). Round 2 adds pitfalls/edge cases (+110 → 805, Silver). Round 3 delta +8 → converged, stop early at round 3 with final report.
Example 4 — EVOLVE Input: "Port this Claude skill to OpenCode" Output: UTE Transfer — frontmatter remapped to OpenCode's tool schema, trigger description preserved verbatim, workflow steps unchanged, re-evaluated at 820/1000 (no regression from original 830/1000... flagged as acceptable within tolerance, else blocked).
- Always classify skill type before choosing a template — mismatched templates cause low Structural scores later.
- Default to CREATE→EVALUATE as a pair; don't hand off an unscored skill as "done."
- In OPTIMIZE, fix one category at a time — simultaneous fixes make regressions hard to trace.
- Preserve the original trigger description's intent during EVOLVE; only adapt platform syntax.
- Keep skills under ~500 lines; if exceeding, split into a main skill file plus linked reference files.
- Don't skip EVALUATE "because the skill looks fine" — subjective review misses trigger-precision and robustness gaps.
- Don't run OPTIMIZE rounds without logging score deltas — invisible regressions compound.
- Don't treat EVOLVE as a rewrite — it's a targeted remap/extend; wholesale rewrites forfeit certification history.
- Don't use this skill for one-off questions, direct API calls, or non-skill automation — those are out of scope (Negative Boundaries).
- Don't certify Gold-tier based on only one EVALUATE category scoring well — all 5 must clear their share.