home / skills / itou-daiki / easy_stat_edu / continuous-learning

continuous-learning skill

safe

This skill automatically analyzes Claude Code sessions to extract reusable patterns and save them as learned skills for future use.

This is most likely a fork of the continuous-learning skill from affaan-m

npx playbooks add skill itou-daiki/easy_stat_edu --skill continuous-learning

Review the files below or copy the command above to add this skill to your agents.

Files (3)

SKILL.md

3.3 KB

---
name: continuous-learning
description: Automatically extract reusable patterns from Claude Code sessions and save them as learned skills for future use.
---

# Continuous Learning Skill

Automatically evaluates Claude Code sessions on end to extract reusable patterns that can be saved as learned skills.

## How It Works

This skill runs as a **Stop hook** at the end of each session:

1. **Session Evaluation**: Checks if session has enough messages (default: 10+)
2. **Pattern Detection**: Identifies extractable patterns from the session
3. **Skill Extraction**: Saves useful patterns to `~/.claude/skills/learned/`

## Configuration

Edit `config.json` to customize:

```json
{
  "min_session_length": 10,
  "extraction_threshold": "medium",
  "auto_approve": false,
  "learned_skills_path": "~/.claude/skills/learned/",
  "patterns_to_detect": [
    "error_resolution",
    "user_corrections",
    "workarounds",
    "debugging_techniques",
    "project_specific"
  ],
  "ignore_patterns": [
    "simple_typos",
    "one_time_fixes",
    "external_api_issues"
  ]
}
```

## Pattern Types

| Pattern | Description |
|---------|-------------|
| `error_resolution` | How specific errors were resolved |
| `user_corrections` | Patterns from user corrections |
| `workarounds` | Solutions to framework/library quirks |
| `debugging_techniques` | Effective debugging approaches |
| `project_specific` | Project-specific conventions |

## Hook Setup

Add to your `~/.claude/settings.json`:

```json
{
  "hooks": {
    "Stop": [{
      "matcher": "*",
      "hooks": [{
        "type": "command",
        "command": "~/.claude/skills/continuous-learning/evaluate-session.sh"
      }]
    }]
  }
}
```

## Why Stop Hook?

- **Lightweight**: Runs once at session end
- **Non-blocking**: Doesn't add latency to every message
- **Complete context**: Has access to full session transcript

## Related

- [The Longform Guide](https://x.com/affaanmustafa/status/2014040193557471352) - Section on continuous learning
- `/learn` command - Manual pattern extraction mid-session

---

## Comparison Notes (Research: Jan 2025)

### vs Homunculus (github.com/humanplane/homunculus)

Homunculus v2 takes a more sophisticated approach:

| Feature | Our Approach | Homunculus v2 |
|---------|--------------|---------------|
| Observation | Stop hook (end of session) | PreToolUse/PostToolUse hooks (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 |

**Key insight from homunculus:**
> "v1 relied on skills to observe. Skills are probabilistic—they fire ~50-80% of the time. v2 uses hooks for observation (100% reliable) and instincts as the atomic unit of learned behavior."

### Potential v2 Enhancements

1. **Instinct-based learning** - Smaller, atomic behaviors with confidence scoring
2. **Background observer** - Haiku agent analyzing in parallel
3. **Confidence decay** - Instincts lose confidence if contradicted
4. **Domain tagging** - code-style, testing, git, debugging, etc.
5. **Evolution path** - Cluster related instincts into skills/commands

See: `/Users/affoon/Documents/tasks/12-continuous-learning-v2.md` for full spec.

Overview

This skill automatically evaluates completed Claude Code sessions to extract reusable patterns and save them as learned skills for later reuse. It runs at session end, finds repeatable behaviors like debugging steps or workarounds, and persists them to a local learned-skills directory. The goal is to build a growing library of practical, reusable actions without interrupting the interactive flow.

How this skill works

The skill installs a Stop hook that triggers after a session finishes. It verifies the session meets a minimum length, scans the full transcript for configured pattern types, and applies extraction rules and thresholds to identify candidate patterns. Approved patterns are saved to a configurable learned-skills path; auto-approval can be enabled or manual review required.

When to use it

After development sessions where multiple edits, fixes, or debugging steps occur
When you want to capture recurring troubleshooting or coding idioms automatically
To bootstrap a personal library of project-specific conventions and workarounds
In environments where retrospective analysis is safe and privacy is preserved
When you need lightweight, non-blocking observation that doesn't run on every message

Best practices

Set a sensible min_session_length to avoid noise from short interactions
Tune extraction_threshold to balance recall vs precision for your workflow
Ignore transient or one-off fixes by adding them to ignore_patterns
Keep learned_skills_path under version control or backup for portability
Periodically review extracted skills and prune low-value or outdated items

Example use cases

Capture a repeatable sequence that resolves a recurring build error into an error_resolution skill
Extract common user_corrections to improve future assistant responses and reduce repeated edits
Save a library of framework-specific workarounds used across projects for quick reuse
Collect effective debugging_techniques observed in long debugging sessions for team training
Build project_specific conventions (naming, config patterns) automatically from long sessions

FAQ

Where are extracted skills saved?

By default they are written to a local learned_skills_path (e.g., ~/.claude/skills/learned/) and can be changed in configuration.

How do I prevent low-value patterns from being saved?

Adjust min_session_length and extraction_threshold, and add patterns to ignore_patterns like simple_typos or one_time_fixes.

Can extraction run automatically without manual approval?

Yes. The auto_approve setting enables automatic persistence; otherwise candidate skills are queued for review.