autoskill

Self-improving skills for AI agents. No commands. No setup. Just continuous improvement.

Installation

One-Liner (Easiest)

curl -fsSL https://raw.githubusercontent.com/Samurai412/autoskill/main/install-remote.sh | bash

Just the Core Skill

curl -o ~/.agents/skills/autoskill/SKILL.md \
  https://raw.githubusercontent.com/Samurai412/autoskill/main/SKILL.md

Clone & Install

git clone https://github.com/Samurai412/autoskill.git
cd autoskill
./install.sh

Manual

mkdir -p ~/.agents/skills/autoskill
curl -fsSL https://raw.githubusercontent.com/Samurai412/autoskill/main/SKILL.md \
  -o ~/.agents/skills/autoskill/SKILL.md

---

What This Is

A system where:

1. Skills adapt to YOUR project — learns your patterns, utilities, conventions
2. Projects improve from skills — skill knowledge finds opportunities in your code
3. Learning is continuous — happens while you work, not as a separate step

The Core Insight

Traditional skills are static — they give the same advice regardless of project.

autoskill makes skills adaptive — they learn from your codebase and give project-specific guidance.

Before: "Use GetComponent caching"
After:  "Use GetComponent caching — this project caches in Awake
         with expression bodies, see EnemyController.cs:15"

Files

autoskill/
├── SKILL.md                    # The main skill
├── SKILL-FORMAT.md             # Instrumented skill format spec
└── examples/
    └── unity-game-dev/
        └── SKILL.md            # Example instrumented skill

How It Works

Three Modes

Mode 0: Auto-Detection (Session Start)

Agent starts working

→ Scans project for file types (*.cs, *.py, *.tsx)
→ Matches file types to skill registry
→ Auto-loads matching skills
→ Continuous learning now active

No user action. Just start working.

Mode 1: Explicit Adaptation

User: "adapt unity-game-dev.md"

→ Full scan of project
→ Proposes code improvements
→ Bulk learns project patterns

For deep one-time passes.

Mode 2: Continuous Learning

Agent reads file during work

→ Notices patterns in skill's domain
→ Queues learnings
→ Writes to skill on task complete

Happens automatically while you work.

The Loop

┌─────────────────────────────────────────────┐
│                                             │
│   SKILL ──────────────────────────┐        │
│     │                              │        │
│     │ proposes                     │ learns │
│     │ improvements                 │ from   │
│     ▼                              │        │
│   PROJECT ─────────────────────────┘        │
│                                             │
│   Each cycle: skill gets smarter            │
│               project gets better           │
│                                             │
└─────────────────────────────────────────────┘

Quick Start

1. Instrument Your Skill

Add to frontmatter:

domain:
  file_patterns: ["*.cs"]  # What files to watch
  watch_for:
    - pattern: "GetComponent<.*> in Awake"
      category: component-caching
      type: exemplar
    - pattern: "GetComponent<.*> in Update"
      category: component-caching
      type: anti-pattern
principles_locked: true

Add sections:

## Principles
<!-- 🔒 LOCKED -->
1. Cache expensive operations
2. Avoid allocations in hot paths

## Project Learnings
<!-- 🤖 AUTO-UPDATED -->
_Updated as agent works._

2. Run Explicit Adaptation (Optional)

> adapt my-skill.md

Scanning project...
Found 5 opportunities, 8 exemplars

Proposals:
1. PlayerController.cs:45 - Cache GetComponent

Apply? [All / Select / Learn only]

3. Work Normally

After initial adaptation, just work. The skill learns continuously:

Agent reads code → notices patterns → updates skill

You never invoke anything. Skill just gets better.

Quality Gates

What gets learned:

• Patterns that appear 2+ times (not one-offs)
• Patterns that don't violate any principle
• Project-specific implementations of general techniques

What gets rejected:

• Anti-patterns (even if frequently used)
• Patterns that violate locked principles
• One-off implementations

Example

Before working on a project:

## Project Learnings
_Updated automatically._

After working on "Horse & Knight Arena":

## Project Learnings

### Horse & Knight Arena (2026-03-21)
- [Learned]: Expression body caching: `_rb = GetComponent<Rigidbody>();`
- [Learned]: ObjectPool<T> utility at Scripts/Utils/ObjectPool.cs
- [Learned]: [RequireComponent] attribute on all dependencies
- [Learned]: ScriptableObject event channels at /Events/

The Revolution

Traditional Skills	autoskill
Static advice	Project-specific guidance
Same for all projects	Learns your patterns
Manual updates	Self-improving
Generic examples	References YOUR code
One-size-fits-all	Fits YOUR project

Skills that get smarter every time the agent reads your code.

License

MIT