learn
Extract and persist insights from the current conversation to the knowledge base
Best use case
learn is best used when you need a repeatable AI agent workflow instead of a one-off prompt. It is especially useful for teams working in multi. Extract and persist insights from the current conversation to the knowledge base
Extract and persist insights from the current conversation to the knowledge base
Users should expect a more consistent workflow output, faster repeated execution, and less time spent rewriting prompts from scratch.
Practical example
Example input
Use the "learn" skill to help with this workflow task. Context: Extract and persist insights from the current conversation to the knowledge base
Example output
A structured workflow result with clearer steps, more consistent formatting, and an output that is easier to reuse in the next run.
When to use this skill
- Use this skill when you want a reusable workflow rather than writing the same prompt again and again.
When not to use this skill
- Do not use this when you only need a one-off answer and do not need a reusable workflow.
- Do not use it if you cannot install or maintain the related files, repository context, or supporting tools.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/learn/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How learn Compares
| Feature / Agent | learn | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Extract and persist insights from the current conversation to the knowledge base
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Learn
Extract insights from the current conversation and persist them to the project's knowledge base.
## What This Does
Analyzes the conversation context to identify:
- **Patterns**: Approaches that worked well in this project
- **Quirks**: Project-specific oddities or non-standard behaviors discovered
- **Decisions**: Architectural or implementation choices made with their rationale
These insights survive session boundaries and context compaction, building a persistent understanding of the project over time.
## Instructions
1. **Analyze the conversation** looking for:
- Successful problem-solving approaches that could apply again
- Unusual behaviors or gotchas discovered about the codebase
- Decisions made and why (architectural choices, library selections, patterns chosen)
2. **Categorize each insight** as pattern, quirk, or decision
3. **Format and append** to the appropriate file in `knowledge/learnings/`:
- `patterns.md` - What works well
- `quirks.md` - Unexpected behaviors
- `decisions.md` - Choices with rationale
4. **Update metadata** in each file's frontmatter (entry_count, last_updated)
5. **Update state** in `knowledge/state.json`:
- Set `last_extraction` to current timestamp
- Increment `extraction_count`
- Reset `queries_since_extraction` to 0
6. **Report** what was learned to the user
## Entry Format
### Pattern Entry
```markdown
## Pattern: [Short descriptive title]
- **Discovered:** [ISO date]
- **Context:** [What task/problem led to this discovery]
- **Insight:** [What approach works well and why]
- **Confidence:** high|medium|low
```
### Quirk Entry
```markdown
## Quirk: [Short descriptive title]
- **Discovered:** [ISO date]
- **Location:** [File/module/area where this applies]
- **Behavior:** [What's unusual or unexpected]
- **Workaround:** [How to handle it]
- **Confidence:** high|medium|low
```
### Decision Entry
```markdown
## Decision: [Short descriptive title]
- **Made:** [ISO date]
- **Context:** [What prompted this decision]
- **Choice:** [What was decided]
- **Rationale:** [Why this choice over alternatives]
- **Confidence:** high|medium|low
```
## Confidence Levels
- **high**: Clear, verified insight with strong evidence
- **medium**: Reasonable inference, likely correct
- **low**: Tentative observation, needs validation
Only high and medium confidence insights influence routing decisions.
## Steps
1. Review the conversation for extractable insights
2. For each insight found:
- Read the target file (patterns.md, quirks.md, or decisions.md)
- Check for duplicates (skip if similar insight exists)
- Append new entry in the format above
- Update frontmatter (increment entry_count, set last_updated)
3. Read and update `knowledge/state.json`
4. Report summary to user:
```
Knowledge Extraction Complete
─────────────────────────────
Extracted:
[Pattern] "Title of pattern learned"
[Quirk] "Title of quirk discovered"
[Decision] "Title of decision recorded"
Knowledge base now contains:
- X patterns
- Y quirks
- Z decisions
```
## Example Extraction
From a conversation where we debugged an auth issue:
**Quirk extracted:**
```markdown
## Quirk: Auth tokens require base64 padding
- **Discovered:** 2026-01-08
- **Location:** src/auth/tokenService.ts
- **Behavior:** JWT tokens in this codebase use non-standard base64 without padding, causing standard decoders to fail
- **Workaround:** Use the custom `decodeToken()` helper instead of atob()
- **Confidence:** high
```
## Notes
- This command extracts insights from the CURRENT conversation
- For continuous extraction, use `/learn-on` instead
- Insights should be project-specific, not generic programming knowledge
- Avoid extracting obvious or trivial information
- When in doubt about confidence, use "medium"Related Skills
ship-learn-next
Transform learning content (like YouTube transcripts, articles, tutorials) into actionable implementation plans using the Ship-Learn-Next framework. Use when user wants to turn advice, lessons, or educational content into concrete action steps, reps, or a learning quest.
machine-learning-ops-ml-pipeline
Design and implement a complete ML pipeline for: $ARGUMENTS
cc-skill-continuous-learning
Development skill from everything-claude-code
when-optimizing-agent-learning-use-reasoningbank-intelligence
Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement
reasoningbank-adaptive-learning-with-agentdb
Implement ReasoningBank adaptive learning with AgentDB for trajectory tracking, verdict judgment, memory distillation, and pattern recognition to build self-learning agents that improve decision-making through experience.
agentdb-reinforcement-learning-training
Train AI agents using AgentDB's 9 reinforcement learning algorithms including Q-Learning, DQN, PPO, and Actor-Critic. Build self-learning agents, implement RL training loops with experience replay, and deploy optimized models to production.
agentdb-learning-plugins
Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms. Includes Decision Transformer, Q-Learning, SARSA, Actor-Critic, and more. Use when building self-learning agents, implementing RL, or optimizing agent behavior through experience.
umap-learn
UMAP dimensionality reduction. Fast nonlinear manifold learning for 2D/3D visualization, clustering preprocessing (HDBSCAN), supervised/parametric UMAP, for high-dimensional data.
scikit-learn
Machine learning in Python with scikit-learn. Use when working with supervised learning (classification, regression), unsupervised learning (clustering, dimensionality reduction), model evaluation, hyperparameter tuning, preprocessing, or building ML pipelines. Provides comprehensive reference documentation for algorithms, preprocessing techniques, pipelines, and best practices.
cross-task-learning
Pattern for aggregating insights across multiple tasks to enable data-driven evolution.
learning-objectives
Generate measurable learning outcomes aligned with Bloom's taxonomy and CEFR proficiency levels for educational content. Use this skill when educators need to define what students will achieve, create learning objectives for curriculum planning, or ensure objectives are specific and testable rather than vague. This skill helps break down complex topics into progressively building learning goals with clear assessment methods and success criteria.
machine-learning
Machine learning development patterns, model training, evaluation, and deployment. Use when building ML pipelines, training models, feature engineering, model evaluation, or deploying ML systems to production.