Skip to main content
skill CX Codex

continuous-learning · rohitg00 — Claude Code skill: learning and setup

The continuous-learning skill turns session corrections and successful approaches into reusable project knowledge. It helps when you want the agent to account for earlier feedback.

Apache-2.0 ★ 2,858 updated 2026-05-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rohitg00/awesome-claude-code-toolkit --skill continuous-learning -a claude-code
Open on GitHub

What continuous-learning does

After a substantial coding session, the skill sorts observations into corrections, successful approaches, and anti-patterns. Each entry can record context, an observation, a lesson, and a confidence score. When the same observation appears again, its frequency and confidence can be updated.

At session end, the agent reviews changes and saves lessons to CLAUDE.md or LEARNED.md. The knowledge base can be split into topic files, such as error handling or testing. Confidence guides how a pattern is used: established findings may be applied automatically, while weaker ones call for a caveat or user confirmation. User approval and rejection affect the score, so a pattern can lose standing after a correction.

What it helps with

  • capture user corrections as reusable lessons
  • separate successful approaches from harmful patterns
  • save session findings to CLAUDE.md or LEARNED.md
  • adjust pattern confidence as new evidence appears

Example prompts for the agent

  • Review this session's changes and save corrections and successful approaches to CLAUDE.md.
  • Record my correction as a lesson, identify its cause, and look for similar patterns.
  • Assess confidence in the stored patterns and suggest which ones to apply automatically.

How to install continuous-learning

1Skills CLI (Vercel)

npx skills add rohitg00/awesome-claude-code-toolkit --skill continuous-learning -a claude-code

2Manually: put the files in place

~/.claude/skills/continuous-learning/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/continuous-learning/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about continuous-learning

How do I install continuous-learning in Claude Code?

Run npx skills add rohitg00/awesome-claude-code-toolkit --skill continuous-learning -a claude-code, then use ~/.claude/skills/continuous-learning/SKILL.md.

What does continuous-learning do?

It turns session feedback into records of corrections, successful approaches, and anti-patterns. The skill tracks confidence so the agent can decide how to use each finding.

How does continuous-learning use confidence scores?

Strongly supported patterns can be applied automatically; less certain ones may be suggested with a caveat or held for confirmation. Scores change when users confirm or reject a pattern.

Source text

SKILL.md · Apache-2.0
---
name: continuous-learning
description: Auto-extract patterns from coding sessions, track corrections, and build reusable knowledge with confidence scoring
---

# Continuous Learning

## Pattern Extraction Framework

After every significant coding session, extract and categorize learnings into three buckets:

1. **Corrections** - Mistakes caught during review or by the user
2. **Successful Approaches** - Patterns that worked well and should be repeated
3. **Anti-Patterns** - Approaches that caused problems and should be avoided

## Learning Entry Format

```yaml
pattern:
  id: "LEARN-2025-0042"
  category: "error-handling"
  type: "correction"         # correction | success | anti-pattern
  confidence: 0.85           # 0.0 to 1.0
  language: "typescript"
  context: "API error responses"
  observation: "Returning raw error messages from database exceptions exposes internals"
  lesson: "Always map database errors to application-level error codes before returning"
  example:
    before: "catch (e) { res.status(500).json({ error: e.message }) }"
    after: "catch (e) { logger.error(e); res.status(500).json({ error: 'INTERNAL_ERROR' }) }"
  frequency: 3               # times this pattern has been observed
  last_seen: "2025-06-15"
```

## Confidence Scoring

| Score | Meaning | Action |
|-------|---------|--------|
| 0.95+ | Verified across multiple projects | Apply automatically |
| 0.80-0.94 | Confirmed in this codebase | Apply and mention |
| 0.60-0.79 | Observed but not fully validated | Suggest with caveat |
| 0.40-0.59 | Hypothesis based on limited data | Ask before applying |
| <0.40 | Speculative, needs validation | Document but do not apply |

Update confidence based on:
- +0.10 when pattern is confirmed correct by user
- +0.05 when pattern is observed again in a different context
- -0.15 when pattern leads to a correction
- -0.20 when pattern is explicitly rejected by user

## Session Wrap-Up Protocol

At the end of each session or before context compaction:

1. **Review changes made** - Scan diffs for patterns
2. **Identify corrections** - What was changed after initial implementation?
3. **Note successful first-attempts** - What worked without revision?
4. **Record environment details** - Framework versions, config specifics
5. **Update confidence scores** - Adjust based on session outcomes
6. **Write to knowledge base** - Append new entries to CLAUDE.md or LEARNED.md

```markdown
## Session Learnings (2025-06-15)

### Corrections Applied
- [0.85] TypeScript: Use `satisfies` instead of `as` for type narrowing with object literals
- [0.90] Next.js: Server Actions must be async functions, even for synchronous operations

### Successful Patterns
- [0.80] PostgreSQL: Partial indexes on status columns reduced query time by 60%
- [0.75] React: Extracting data fetching into Server Components eliminated 3 useEffect hooks

### Anti-Patterns Identified
- [0.70] Avoid: Nesting more than 2 levels of Suspense boundaries (causes waterfall)
- [0.65] Avoid: Using `any` to suppress TypeScript errors in catch blocks (use `unknown`)
```

## Knowledge Base Organization

Structure the knowledge base by domain:

```
knowledge/
  error-handling.md      # Error patterns across languages
  testing.md             # Test patterns and anti-patterns
  performance.md         # Optimization learnings
  api-design.md          # API design decisions
  deployment.md          # Infrastructure learnings
  project-specific.md    # Current project conventions
```

Each file follows the same entry format. Deduplicate entries with matching `observation` fields by incrementing `frequency` and updating `confidence`.

## Correction Tracking

When a user corrects code or approach:

1. Record what was originally produced
2. Record what the correction was
3. Identify the root cause (wrong assumption, missing context, outdated pattern)
4. Create or update a learning entry
5. Search for similar patterns that might need the same correction

```markdown
### Correction Log
- **Original**: Used `useEffect` to fetch data on mount
- **Correction**: Moved data fetching to Server Component
- **Root cause**: Applied client-side SPA pattern in Server Component context
- **Generalization**: In Next.js App Router, prefer server-side data fetching for initial page data
- **Confidence**: 0.90 (confirmed across 4 components)
```

## Pattern Reinforcement

Track how often patterns are applied and whether they hold:

```
Pattern: "Use zod for API input validation"
  Applied: 12 times
  Confirmed: 11 times
  Corrected: 1 time (edge case with file uploads)
  Confidence: 0.92
  Status: ESTABLISHED
```

Statuses:
- **EMERGING** (frequency < 3) - New pattern, needs validation
- **GROWING** (frequency 3-7) - Building evidence, apply with mention
- **ESTABLISHED** (frequency 8+, confidence > 0.85) - Apply automatically
- **DEPRECATED** - Once valid, now superseded by a better approach

## Integration with Memory Files

Store learnings in the project's memory file (CLAUDE.md or equivalent):

- High-confidence learnings (>0.85) go in the main instructions section
- Medium-confidence (0.60-0.84) go in a dedicated "Learnings" section
- Low-confidence (<0.60) stay in session notes until validated
- Deprecated patterns move to an archive section with reason for deprecation

Review and prune the knowledge base monthly. Remove entries that have not been referenced in 90 days and have confidence below 0.70.

© rohitg00 · Apache-2.0 · rohitg00/awesome-claude-code-toolkit

Similar skills

All skills for Agent setup: memory, context, orchestration →

continuous-learning by other authors comes first.

continuous-learning affaan-m continuous-learning is a Claude Code skill that inspects session transcripts at completion to extract reusable patterns. It exports troubleshooting techniques into learned skills. CX Codex +1 6,300installs continuous-learning-construction datadrivenconstruction continuous-learning-construction extracts reusable solutions and patterns from construction automation sessions. Use it after estimation work, document processing, or setting up integrations. CX Codex +1 118installs continual-learning cursor Runs the continual-learning loop: distill past chats into AGENTS.md, with all the actual work handed to the agents-memory-updater subagent. CX Codex +1 1,500installs self-learning kulaxyz self-learning is a Claude Code skill that captures a working route from the current session as a reusable skill, so the next session already knows it. CX Codex +1 889installs session-learning-capture davila7 session-learning-capture is a Claude Code command that saves session insights to project memory. Choose project knowledge, implementation fixes, structure notes, or workflow improvements. CX Codex +1 425installs instinct-export sangrokjung instinct-export exports continuous-learning instincts into a shareable file for team members or migration across machines. CX Codex +1 ★ 880repo stars golang-continuous-integration samber golang-continuous-integration writes and fixes GitHub Actions workflows for Go projects: tests, lint, security scans, Dependabot and GoReleaser releases. Use it when CI is missing or incomplete. CX Codex +1 41,500installs

From the same set178

The whole set →
test-architect test-architect designs test pyramids, guides TDD workflows, and sets up integration, property-based, and mutation tests in Claude Code. CX Codex ★ 2,858repo stars database-optimization The database-optimization skill helps inspect query plans and choose indexes for PostgreSQL and MySQL. Use it when tracking down slow queries or reviewing connection and partitioning strategies. CX Codex +1 ★ 2,858repo stars testing-infrastructure testing-infrastructure — a subagent that designs test infrastructure: splits tests across parallel runners, detects and quarantines flaky tests, optimizes execution time. For teams where CI is a bottleneck or tests fail unpredictably. CX Codex ★ 2,858repo stars healthcare-engineer healthcare-engineer designs HIPAA-compliant architectures and HL7 FHIR interfaces. Useful when connecting EHR platforms, mapping clinical vocabularies, or de-identifying records. CX Codex ★ 2,858repo stars developer-portal Subagent for building internal developer portals using Backstage with service catalogs, project templates, and self-service infrastructure provisioning. Replaces scattered wikis and manual setup with unified discovery and CI/CD integration. CX Codex ★ 2,858repo stars websocket-realtime websocket-realtime provides real-time communication patterns for Claude Code, covering raw WebSocket implementations, Socket.io rooms, SSE, and Redis scaling. CX Codex +1 ★ 2,858repo stars monitoring-observability monitoring-observability is a Claude Code skill that adds tracing, metrics, structured logs, and alert rules to Node.js services. It connects application signals to dashboards and SLOs. CX Codex +1 ★ 2,858repo stars database-optimizer database-optimizer — a subagent that diagnoses slow queries, designs indexes, implements partitioning schemes, and plans capacity for PostgreSQL, MySQL, and distributed databases. CX Codex ★ 2,858repo stars

Project sponsors

Companies that keep this analytics open