Auto-Learning: How to Extract Skills from AI Conversations

The Knowledge Trapped in Your Conversations

Every AI conversation teaches you something:

A debugging technique that worked
An approach that failed spectacularly
A pattern that fits your codebase
A library quirk to avoid

But when the conversation ends, the lesson is buried. Next time you face the same problem, you might not remember. You might repeat the same mistakes.

What if every conversation automatically extracted its lessons?

From Conversations to Knowledge

The concept is simple:

You have AI conversations while coding
Each conversation contains implicit lessons
Extract those lessons explicitly
Apply them to future conversations

Before (implicit lessons):

You: "Why isn't my state updating?"
AI: "You're mutating state directly. In React, you need to 
create a new object reference for re-renders to trigger."
You: "Oh, that fixed it. Thanks!"
[Lesson buried in chat history]

After (explicit extraction):

LESSON EXTRACTED:
[DONT] Mutate state directly in React
[DO] Create new object references for state updates
[WHY] React uses reference equality for re-render detection

Now this lesson persists. Next time you (or your AI) faces a similar problem, the pattern is available.

The DONT/DO Framework

Extracted lessons follow a simple structure:

DONT (Anti-patterns)

What to avoid. What failed. What causes problems.

[DONT] Use useEffect for derived state
[DONT] Nest ternaries more than 2 levels
[DONT] Import entire lodash package

DO (Best practices)

What works. What succeeded. What to repeat.

[DO] Use useMemo for expensive computations
[DO] Colocate queries with their components
[DO] Prefix unused variables with underscore

WHY (Rationale)

The reason behind the lesson. Helps apply it correctly.

[WHY] useEffect runs after render, causing flicker
[WHY] Nested ternaries reduce readability significantly
[WHY] Tree-shaking doesn't work well with lodash

How Extraction Works

In RL4 v2.0, skill extraction is fully automated via the Phase Protocol. Every time you run a snapshot (via MCP or Wizard), Phase 2b automatically updates your skills file:

The Phase 2b Flow:

`run_snapshot` captures your full development context
Phase 1 generates the activity summary
Phase 2 updates your timeline
**Phase 2b** analyzes all conversations and updates `.cursor/rules/Rl4-Skills.mdc`
Phase 3 cleans up via `finalize_snapshot`

You don't need to manually trigger extraction — it happens every snapshot.

What gets analyzed:

All captured conversations in `chat_history.jsonl`
Decision records in `decisions.jsonl`
Burst patterns (what worked, what caused regressions)
Causal links (which conversations led to which code changes)

Output format — DO / DON'T / CONSTRAINTS / INSIGHTS:

## DO
- Use server actions for data mutations (learned from 5 conversations)
- Validate at boundary with Zod, trust internally (3 regressions prevented)
- Use transactions for related Prisma operations (race condition fix)

## DON'T
- Mutate state directly in React (caused 2 bugs)
- Chain more than 3 Prisma queries without transaction
- Skip Zod validation on API inputs (production incident)

## CONSTRAINTS
- All API responses must be < 100ms (SLA requirement)
- Offline mode required (architectural constraint)

## INSIGHTS
- JWT rotation pattern is stable after 4 iterations
- The auth module averages 12 saves per session (high churn area)

Where Lessons Live

Extracted lessons are stored in your workspace:

.cursor/rules/Rl4-Skills.mdc

This file is automatically read by Cursor, meaning your AI assistant learns your patterns over time.

Example Rl4-Skills.mdc:

# RL4 Skills - Auto-Extracted Patterns

## React Patterns
- [DO] Use useCallback for handlers passed to children
- [DONT] Create objects in JSX props (causes re-renders)

## Database Patterns  
- [DO] Use connection pooling for serverless
- [DONT] Run migrations in production without backup

## API Patterns
- [DO] Return consistent error shapes
- [DONT] Expose internal IDs in responses

The Compound Effect

Here's where it gets powerful:

Week 1: 5 lessons extracted

Week 2: 12 lessons (7 new)

Week 4: 25 lessons

Week 8: 45 lessons

Week 12: 70+ lessons

After three months, you have a personalized knowledge base of 70+ validated patterns for your specific codebase.

Your AI assistant now knows:

What works here (not just generally)
What to avoid (learned from real mistakes)
Your preferences (not generic best practices)

Using Your Lessons

Automatic application:

When lessons are in `.cursor/rules/`, Cursor automatically considers them:

You: "Help me add a new API endpoint"
AI: [Reads Rl4-Skills.mdc]
AI: "Based on your patterns, I'll use server actions with Zod 
validation at the boundary. I notice from your lessons that you 
prefer consistent error shapes, so I'll use the ErrorResponse 
type you established..."

Manual reference:

Include lessons in context when working in other tools:

[Paste lessons file]
"Following these patterns, help me refactor the auth module"

Team sharing:

Commit lessons to repo for team-wide patterns:

git add .cursor/rules/Rl4-Skills.mdc
git commit -m "Update team patterns from recent work"

Quality Over Quantity

Not all lessons are equal. Good lessons are:

Specific: "Use Zod for API validation" not "Validate inputs"

Actionable: Clear DO/DONT, not vague advice

Contextual: Relevant to your codebase, not generic

Validated: Learned from real experience, not theory

Bad lessons dilute your knowledge base. The extraction process filters for high-signal patterns.

Lessons Across Projects

Some lessons are project-specific:

[DO] Use the ErrorResponse type in /types/api.ts

Some are portable across projects:

[DONT] Mutate arguments in pure functions

You can maintain:

**Project lessons:** In project's `.cursor/rules/`
**Personal lessons:** In your global snippets
**Team lessons:** In shared team configs

Advanced: Lesson Categories

As your knowledge base grows, organize by domain:

# Performance Lessons
- [DO] Lazy load below-fold components
- [DONT] Use layout effects for animations

# Security Lessons
- [DO] Sanitize user input before database
- [DONT] Log sensitive data even in debug

# Testing Lessons
- [DO] Test behavior, not implementation
- [DONT] Mock what you don't own

Measuring Knowledge Growth

Track your learning:

Monthly Knowledge Report
━━━━━━━━━━━━━━━━━━━━━━━
New lessons: +15
Categories covered: 8
Most active area: API Design
Lesson applied: 47 times

Some teams gamify this:

Lessons contributed per sprint
Most valuable lesson of the month
Knowledge sharing leaderboard

From Individual to Team Intelligence

The real power is collective:

Developer A discovers a database pattern

Developer B finds a testing approach

Developer C solves a deployment issue

All lessons merge into team knowledge:

.cursor/rules/
├── team-patterns.mdc     # Shared lessons
├── alice-patterns.mdc    # Alice's specialties
└── project-patterns.mdc  # This project's specifics

New developers inherit the team's accumulated intelligence on day one.

Start Building Your Knowledge Base

Every conversation you have with AI contains lessons. Right now, they're disappearing when the chat ends. Learn how to stop losing contextstop losing context/cursor/blog/cursor-context-loss-killing-productivity and create your first snapshotcreate your first snapshot/cursor/blog/create-first-ai-snapshot-tutorial.

**Try RL4 Snapshot**Try RL4 Snapshot/cursor/form — automatically extract and accumulate lessons from your Cursor conversations. Build a personal AI knowledge base with auto-learning development.

Your future self will thank you for the AI skill extraction patterns you capture today.