Skip to content
Skillpedia
Agents280k · #162

continuous-learning-v2

Lets the agent learn from interactions and create new skills. It's useful for improving the agent's performance over time.

What it does

This system learns from your AI conversations. It identifies patterns in your work and turns them into 'instincts' - small tips on how to do something. Over time, these instincts can become more complete tools.

When to use it

  • ✓When you want the AI to learn from your coding sessions.
  • ✓To organize and reuse AI learnings.
  • ✓To turn useful tips into automatic commands or skills.

Example of what to ask your AI

“Turn my code sessions into reusable learnings.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/affaan-m/ECC/blob/main/skills/continuous-learning-v2/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/affaan-m/ECC/blob/main/skills/continuous-learning-v2/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The AI observes your interactions, identifies repeated patterns or corrections you make. It saves these patterns as 'instincts' with a confidence score. These instincts can be grouped and turned into larger skills.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add affaan-m/ECC --skill continuous-learning-v2

Or download just the file:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/skills/continuous-learning-v2/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Continuous Learning v2.1 - Instinct

-Based Architecture

An advanced learning system that turns your Claude Code sessions into reusable knowledge through atomic "instincts" - small learned behaviors with confidence scoring.

v2.1 adds project-scoped instincts — React patterns stay in your React project, Python conventions stay in your Python project, and universal patterns (like "always validate input") are shared globally.

When to Activate

  • Setting up automatic learning from Claude Code sessions
  • Configuring instinct-based behavior extraction via hooks
  • Tuning confidence thresholds for learned behaviors
  • Reviewing, exporting, or importing instinct libraries
  • Evolving instincts into full skills, commands, or agents
  • Managing project-scoped vs global instincts
  • Promoting instincts from project to global scope

What's New in v2.1

Feature v2.0 v2.1
Storage Global (~/.claude/homunculus/) Project-scoped (${XDG_DATA_HOME:-~/.local/share}/ecc-homunculus/projects/<hash>/)
Scope All instincts apply everywhere Project-scoped + global
Detection None git remote URL / repo path
Promotion N/A Project → global when seen in 2+ projects
Commands 4 (status/evolve/export/import) 6 (+promote/projects)
Cross-project Contamination risk Isolated by default

What's New in v2 (vs v1)

Feature v1 v2
Observation Stop hook (session end) PreToolUse/PostToolUse (100% reliable)
Analysis Main context Background agent (Haiku)
Granularity Full skills Atomic "instincts"
Confidence None 0.3-0.9 weighted
Evolution Direct to skill Instincts -> cluster -> skill/command/agent
Sharing None Export/import instincts

The Instinct Model

An instinct is a small learned behavior:

---
id: prefer-functional-style
trigger: "when writing new functions"
confidence: 0.7
domain: "code-style"
source: "session-observation"
scope: project
project_id: "a1b2c3d4e5f6"
project_name: "my-react-app"
---

# Prefer Functional Style

## Action
Use functional patterns over classes when appropriate.

## Evidence
- Observed 5 instances of functional pattern preference
- User corrected class-based approach to functional on 2025-01-15

Properties:

  • Atomic -- one trigger, one action
  • Confidence-weighted -- 0.3 = tentative, 0.9 = near certain
  • Domain-tagged -- code-style, testing, git, debugging, workflow, etc.
  • Evidence-backed -- tracks what observations created it
  • Scope-aware -- project (default) or global

How It Works

Session Activity (in a git repo)
      |
      | Hooks capture prompts + tool use (100% reliable)
      | + detect project context (git remote / repo path)
      v
+---------------------------------------------+
|  projects/<project-hash>/observations.jsonl  |
|   (prompts, tool calls, outcomes, project)   |
+---------------------------------------------+
      |
      | Observer agent reads (background, Haiku)
      v
+---------------------------------------------+
|          PATTERN DETECTION                   |
|   * User corrections -> instinct             |
|   * Error resolutions -> instinct            |
|   * Repeated workflows -> instinct           |
|   * Scope decision: project or global?       |
+---------------------------------------------+
      |
      | Creates/updates
      v
+---------------------------------------------+
|  projects/<project-hash>/instincts/personal/ |
|   * prefer-functional.yaml (0.7) [project]   |
|   * use-react-hooks.yaml (0.9) [project]     |
+---------------------------------------------+
|  instincts/personal/  (GLOBAL)               |
|   * always-validate-input.yaml (0.85) [global]|
|   * grep-before-edit.yaml (0.6) [global]     |
+---------------------------------------------+
      |
      | /evolve clusters + /promote
      v
+---------------------------------------------+
|  projects/<hash>/evolved/ (project-scoped)   |
|  evolved/ (global)                           |
|   * commands/new-feature.md                  |
|   * skills/testing-workflow.md               |
|   * agents/refactor-specialist.md            |
+---------------------------------------------+

Project Detection

The system automatically detects your current project:

…

FAQ

What are 'instincts'?

They are small lessons the AI learns about how you do things, like preferring a coding style or a way to solve a problem. They have a confidence score to indicate how sure the AI is about that learning.

How does the AI know which project I'm working on?

It checks if you are using a Git repository or a specific environment variable to identify the project. This ensures that learnings from one project don't mix with those from another.

Can I use my learnings in other projects?

Yes. Instincts that are useful across multiple projects can be promoted from a project scope to a global scope, making them available anywhere.

Details

Original description by the author

Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents. v2.1 adds project-scoped instincts to prevent cross-project contamination. Use when capturing lessons from a session, managing instincts, or promoting them into skills, commands, or agents.

repo: affaan-m/ECC

Popularity

GitHub stars
280k
Ranking position
#162
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills