Skill Experience Layer

Pre-call experience checking + error-driven learning + layered experience storage. Avoid repeating mistakes, get smarter every time. Pre-integrated with self...

Security Scan

The skill's stated purpose (per-skill experience memory and pre-call checks) is plausible, but the runtime instructions contain contradictory and under-specified behaviors around which files may be written and how integrations (self-improving, capability-evolver) are triggered — this mismatch warrants caution before installing.

Purpose & Capability

The described capability (keeping per-skill JSON experience files, reading them before calls, recording mistakes, and invoking an evolver) is coherent with the name and description. However the SKILL.md assumes integration with other skills (self-improving, capability-evolver) without declaring those dependencies or required permissions, which is an omission that reduces clarity.

Instruction Scope

The instructions tell the agent to create and update files (memory/experiences/{skill}.json and self-improving/corrections.md) and to 'promote key lessons to long-term memory in MEMORY.md' — yet the 'Safety Boundaries' claim the skill 'Never touches' core root files and 'reads but does not write' them. That is a direct contradiction. Also 'read before every invocation' and automatic triggering of capability-evolver could cause broad, repeated file reads/writes and autonomous changes without a clear, implementable approval mechanism.

Install Mechanism

This is an instruction-only skill with no install spec and no code files, so there is no installer or remote download risk.

Credentials

No environment variables, binaries, or credentials are requested (which matches a local file-based memory approach). That said, the skill implicitly requires filesystem write/read permission for memory/experiences/, self-improving/, and possibly MEMORY.md — these expected file accesses are not explicitly declared in requires.configPaths, and the policy/limits around which files may be modified are inconsistent in the doc.

Persistence & Privilege

always is false (good). Autonomous invocation is allowed (the platform default). The skill claims it will perform automatic evolution and backups and will trigger capability-evolver when mistakes repeat — this could grant the skill effective ongoing influence over agent behavior if the agent follows the instructions, so confirm human-approval steps and backup/rollback mechanisms before enabling automatic changes.

What to consider before installing

This skill's core idea is reasonable (store per-skill experience and consult it before calls), but there are contradictory and under-specified instructions you should clear up before installing. Ask the author to: (1) explicitly list which files the skill will read and which it will write (and add them to requires/configPaths), (2) resolve the contradiction about writing to MEMORY.md vs the 'never writes core root files' statement, (3) describe exactly how capability-evolver is triggered and require human approval for high-risk automatic changes, (4) show the backup/rollback implementation, and (5) confirm whether self-improving/corrections.md is considered a skill-owned file. Until those are clarified, run this skill in a sandboxed agent with limited filesystem permissions and do not grant it write access to global root files (MEMORY.md, IDENTITY.md, .env, etc.).

Skill Experience Layer - 技能经验分层机制

What it does

Give your agent permanent, per-skill experience memory that:

1. Pre-call checking: Before you call any skill, automatically read the common mistakes and best practices so you avoid repeating the same pitfalls
2. Error-driven learning: When you make a mistake, immediately record it to the corresponding skill's experience file
3. Automatic evolution: Integrates with capability-evolver to automatically improve experience when mistakes repeat
4. Fits existing memory architecture: Works with your existing (instant → hot → short-term → long-term) memory hierarchy

Why this is different

Approach	Traditional	skill-experience-layer
When lessons are applied	After mistake (retrospective)	Before next call (preventive)
Experience storage	Global reflection	Per-skill JSON files, easy to evolve
Integration	Self-contained, requires manual integration	Designed to fit your existing memory hierarchy
Automatic evolution	No built-in support	First-class integration with capability-evolver

Workflow

1. For every skill you use

When you install a new skill:

• Create memory/experiences/{skill-name}.json
• Define commonMistakes[] and bestPractices[]
• Before every invocation, read it and remind yourself what to avoid

2. When you make a mistake

1. Stop immediately, don't keep retrying
2. Record the mistake in self-improving/corrections.md
3. Update the skill's experience JSON:
   • Add new entry to experiences[] with context, lesson, prevention
   • Update commonMistakes[] if it's a new pattern
   • Increment failureCount
4. If the same mistake repeats 2+ times, trigger capability-evolver to automatically improve the experience and best practices
5. Retry after updating

3. Regular maintenance

• Daily: End-of-day review mistakes, update experiences
• Weekly: Promote key lessons to long-term memory in MEMORY.md
• Automatic: capability-evolver can continuously improve stale experiences

Example experience file

{
  "type": "skill",
  "name": "my-skill",
  "lastUpdated": "2026-03-17T19:00:00+08:00",
  "totalExecutions": 10,
  "successCount": 8,
  "failureCount": 2,
  "experiences": [
    {
      "id": "exp-my-skill-001",
      "timestamp": "2026-03-10T20:00:00+08:00",
      "context": "What you were doing when the mistake happened",
      "lesson": "What you learned",
      "severity": "medium",
      "timesRepeated": 1,
      "prevention": "What to do differently next time"
    }
  ],
  "patterns": {
    "commonMistakes": [
      "First common mistake to avoid",
      "Second common mistake"
    ],
    "bestPractices": [
      "First best practice",
      "Second best practice"
    ]
  }
}

Integration with existing systems

Works great with:

• self-improving: Uses the correction/reflection workflow
• capability-evolver: Automatic experience improvement when mistakes repeat
• Your existing memory hierarchy: Experiences live in memory/experiences/, fits alongside your daily/weekly memory

Safety Boundaries

• ✅ Only modifies experience files in memory/experiences/ and skill-owned files
• ✅ Never touches core root files (MEMORY.md, SOUL.md, IDENTITY.md, USER.md, .env) — reads but does not write
• ✅ Never accesses sensitive directories (~/.ssh, ~/.aws, /etc)
• ✅ All automatic changes are backed up before applying, can roll back
• ✅ High-risk changes require human approval

Author

Created from practical experience integrating self-improvement into a working agent. This is the missing glue between general self-improving frameworks and your actual daily usage.

Get smarter with every mistake, don't repeat the same pit twice.