Evolving AI Skills Yield 116% Accuracy Boost – From Handwritten Prompts to Autonomous Creation

What is a Skill?

A Skill is a reusable, structured instruction set that tells an AI agent how to complete a specific type of task. Compared with a Prompt (a one‑time instruction) and a Tool (a fixed external capability), a Skill is persistent and can evolve over time.

Standard Skill structure

High‑quality Skills follow a YAML front‑matter format followed by Markdown sections. Example:

---
name: github-pr-review
description: Complete GitHub PR review workflow
tags: [github, code-review, devops]
---

# GitHub PR Review

## Trigger Conditions
- User mentions "review PR" or similar
- Includes a GitHub link or PR number

## Execution Steps
1. Get PR diff: `gh pr diff <number>`
2. Inspect changed files
3. Review per file, focusing on:
   - Security risks (hard‑coded keys, SQL injection)
   - Performance issues (N+1 queries, memory leaks)
   - Code style (naming, comments, error handling)
4. Generate a graded review report

## Common Pitfalls
- Never look at diff alone; consider related files
- Split large PRs for review
- Check test‑coverage changes

## Output Format
| File | Issue | Severity | Recommendation |
|------|-------|----------|----------------|
| `user.py` | Hard‑coded API key | 🔴 High | Use env vars |
| `db.py`   | Potential SQL injection | 🔴 High | Use parameterized queries |
| `api.py`  | Missing type hints | 🟡 Medium | Add type annotations |
| `utils.py`| Function too long | 🟢 Low | Refactor |

Three generations of Skills

First generation (2023‑2024): Hand‑written Skills

Manually authored by domain experts; static.

Representatives: OpenAI GPT Instructions, Claude System Prompts, Cursor .cursorrules.

Problems: high authoring cost, cannot adapt to new scenarios, errors cannot be auto‑fixed.

Second generation (2025): Template‑based Skills

Structured templates, semi‑automatic generation.

Representatives: LangChain Tools, AutoGPT Skills, Hermes Agent Skills.

Advances: standardized YAML + Markdown, reusable, community ecosystems.

Limitations: still static, difficult cross‑task reuse, no automatic optimisation.

Third generation (2026): Self‑evolving Skills

Agents autonomously create, test, and optimise Skills.

Representatives: SkillCAT (June 2026), MUSE‑Autoskill (May 2026), Memento‑Skills (March 2026).

Breakthroughs: learning from execution traces, automatic testing and quality validation, cross‑task transfer and continuous optimisation.

Self‑evolution frameworks

1. Memento‑Skills (March 2026)

Core idea: Read‑Write‑Reflective Learning.

Workflow:

Read phase:
  User request → Skill Router selects the most relevant Skill
Write phase:
  Execute task → Collect feedback → Update/create Skill
Reflect phase:
  Analyse success/failure → Distil experience → Optimise Skill library

Key innovations:

Stateful Prompts – Skills store both instructions and contextual state.

Skill Router – Dynamically selects the best Skill based on current state.

No model training – All learning occurs via external Skill files.

Experimental results:

General AI Assistants benchmark: +26.2% accuracy .

Humanity's Last Exam benchmark: +116.2% accuracy (large improvement over the base model).

2. MUSE‑Autoskill (May 2026)

Core idea: Skills are long‑living, experience‑aware, testable assets.

Five lifecycle stages:

Creation – On‑demand Skill creation from execution traces.

Memory – Store and index Skills; skill‑level memory accumulates cross‑task experience.

Management – Organise and select Skills using efficient retrieval and matching.

Evaluation – Unit tests + runtime feedback for quality verification.

Refinement – Continuous optimisation driven by feedback.

Key innovations:

Skill‑level memory – each Skill becomes more precise with repeated use.

Automatic unit testing – every Skill ships with test cases.

Cross‑Agent migration – Skills can be shared between different agents.

SkillsBench results:

Task success rate: +34.7% .

Token efficiency: ‑41.2% (fewer tokens for the same task).

Skill reuse rate: 68.3% of Skills reused across tasks.

3. SkillCAT (June 2026)

Core idea: Contrastive causal extraction from successful/failed traces combined with topology‑aware execution.

Three‑stage process:

Stage 1 – Contrastive Causal Extraction (CCE):
  Sample multiple execution traces for the same task.
  Extract decision points from a successful trace (A).
  Extract error causes from a failed trace (B).
  Compare A vs B to identify evidence that explains outcome differences.

Stage 2 – Assessment‑Augmented Evolution (AAE):
  Replay candidate Skill patches on a cloned source task.
  Keep only patches that improve or maintain results.
  Hierarchically merge retained patches.

Stage 3 – Topology‑Aware Task Execution (TTE):
  Compile evolved Skills into a routable sub‑Skill topology.
  At inference time load only the capability nodes relevant to the current task.
  Reduces Skill loading overhead by <strong>73%</strong>.

Benchmarks:

SpreadsheetBench: +40.40% average score.

WikiTableQuestions: +38.7% .

DocVQA: +35.2% .

Cross‑model generalisation effective on GPT‑4, Claude‑3, Gemini.

Global Skill ecosystem (selected examples)

Claude Code Skills – 200+ official, 1 000+ community Skills (e.g., writing-plans, code-review, test-driven-development).

Cursor Rules – 500+ community rules focused on front‑end and full‑stack best practices (e.g., nextjs-best-practices, typescript-strict, react-patterns).

OpenAI GPT Instructions – 3 M+ GPTs, many simple instructions (e.g., Code Copilot, Data Analyst, Creative Writer).

Hermes Agent Skills – 100+ official, 300+ community Skills (e.g., github-pr-workflow, systematic-debugging, wechat-article-pipeline).

Coze Skills (ByteDance) – 500+ Skills targeting Chinese content and marketing (e.g., 小红书文案生成, 抖音脚本创作, 客服机器人).

Dify Workflows – 200+ open‑source workflow templates (e.g., 智能客服, 内容审核, 数据提取).

Illustrative Skill example (Python workday counter)

from datetime import datetime, timedelta

def count_workdays(start_date: str, end_date: str) -> int:
    """Calculate workdays between start_date and end_date (exclude weekends)."""
    start = datetime.strptime(start_date, "%Y-%m-%d")
    end = datetime.strptime(end_date, "%Y-%m-%d")
    if start > end:
        raise ValueError("Start date cannot be after end date")
    workdays = 0
    current = start
    while current <= end:
        if current.weekday() < 5:  # Monday‑Friday
            workdays += 1
        current += timedelta(days=1)
    return workdays

Conclusion

Skills serve as the long‑term procedural memory of AI agents. Prompt provides short‑term, one‑off instructions; Tool supplies fixed capabilities; Skill encodes reusable, evolvable task strategies. The three 2026 systems demonstrate that autonomous creation, testing, and optimisation of Skills can improve benchmark performance without updating model parameters (Memento‑Skills +116.2% on Humanity's Last Exam), reduce token consumption (MUSE‑Autoskill ‑41.2%), and increase task success rates (+34.7%). These results establish Skill engineering as a practical technique for building continuously improving AI agents.