Self-Improvement Meta-Skill

This meta-skill enables the Cursor system to learn from GitHub PRs, issues, discussions, and user interactions to continuously improve guidance and prevent common mistakes.

When to Use

Use this skill when:

Analyzing closed PRs to extract lessons learned
Identifying patterns in rejected vs. accepted contributions
Learning from user corrections and feedback
Updating rules based on what worked or didn't work
Creating new rules when patterns emerge
Tracking effectiveness of existing rules

Key Capabilities

1. PR Analysis

Analyze closed PRs to extract patterns:

What to look for:

Review comments and rejection reasons
Common failure patterns (deprecated functions, architecture misunderstandings, missing context)
Success patterns (what made PRs get merged)
Code review feedback themes
Testing and verification gaps

How to analyze:

Fetch PR details via GitHub API or web fetch
Parse review comments for actionable feedback
Identify recurring themes
Extract specific mistakes (e.g., "used deprecated function X")
Map to existing rules or identify gaps

2. Issue Pattern Extraction

Learn from GitHub issues:

What to track:

Common bug patterns
Feature requests that reveal gaps
User-reported issues that indicate misunderstandings
Triage patterns (what gets prioritized)

How to extract:

Analyze issue descriptions and labels
Identify recurring themes
Map to Omi layers (Capture/Understand/Memory/etc.)
Extract lessons about what not to do

3. User Interaction Learning

Learn from direct user feedback:

What to track:

User corrections ("No, don't do X")
Rejected suggestions ("That's not what I meant")
Clarification requests (reveals gaps in understanding)
Preference patterns (user's coding style, preferred approaches)
Success patterns (what user consistently approves)

How to learn:

Monitor conversation for corrections and feedback
Extract the lesson from each correction
Identify patterns across multiple interactions
Update rules or create new ones based on patterns
Build user preference profile

4. Rule Generation and Updates

Create or update rules based on findings:

Process:

Identify the pattern or mistake
Check if existing rule covers it
If yes, update the rule with new information
If no, create a new rule
Test rule effectiveness

Rule update format:

Add to existing rule if it's the same category
Create new rule if it's a new category
Include specific examples from PRs/issues
Reference the source (PR number, issue number)

5. Effectiveness Tracking

Track which rules are most effective:

Metrics:

How often a rule prevents mistakes
Reduction in PR rejections after rule creation
User correction frequency
Rule coverage (how many scenarios it covers)

Common Patterns to Extract

From PR #3567 (Rejected):

❌ Used deprecated postprocess_conversation function
❌ Didn't understand current audio storage flow
❌ Didn't provide enough context upfront
❌ Didn't verify end-to-end flow
✅ Good: Provided benchmarks and test results
✅ Good: Addressed code review feedback promptly

From Issues:

Language settings not respected (#4394)
Features only work when app is open (#4355)
Missing conversations/processing issues (#4354, #4353)

From User Interactions:

"No, don't use that function, it's deprecated" → Always check for deprecated functions
"I need more context before you start coding" → User prefers planning phase
"That's not how the system works" → Need to understand architecture better

Implementation Guidelines

Analyzing a PR

Fetch PR data:

# Use mcp_web_fetch or GitHub API
pr_url = f"https://github.com/BasedHardware/omi/pull/{pr_number}"

Extract key information:
- PR status (merged/rejected)
- Review comments
- Code changes
- Rejection reasons (if rejected)
Identify patterns:
- What mistakes were made?
- What feedback was given?
- What worked well?
Map to rules:
- Which existing rule should be updated?
- Is a new rule needed?
Update/create rules:
- Add examples to existing rules
- Create new rules for new patterns

Learning from User Feedback

Detect correction:
- User says "no", "don't", "that's wrong", etc.
- User provides different approach
Extract lesson:
- What was wrong?
- Why was it wrong?
- What should be done instead?
Update guidance:
- Add to relevant rule
- Create new rule if needed
- Update user preference profile

Creating New Rules

When a new pattern emerges:

Identify the pattern: What mistake or gap does it address?
Find examples: Collect 2-3 examples from PRs/issues/interactions
Write the rule: Follow existing rule format
Add to file structure: Place in appropriate .cursor/rules/ file
Link from related rules: Add references in other relevant rules

Related Cursor Resources

Rules

.cursor/rules/common-mistakes.mdc - Common mistakes to avoid
.cursor/rules/pre-implementation-checklist.mdc - Pre-implementation verification
.cursor/rules/verification.mdc - Self-checking guidelines
.cursor/rules/context-communication.mdc - Communication best practices
.cursor/rules/user-feedback-integration.mdc - Learning from user interactions

Commands

/learn-from-pr - Analyze a specific PR
/learn-from-conversation - Learn from current conversation
/self-improve - Analyze patterns and update rules

Skills

.cursor/skills/rule-updater/SKILL.md - Skill for updating rules programmatically

Best Practices

Be specific: Extract concrete examples, not vague patterns
Reference sources: Always note which PR/issue/interaction the lesson came from
Test updates: Verify rule updates don't break existing guidance
Prioritize: Focus on patterns that cause the most problems
Iterate: Rules should improve over time as more data is collected

Example Usage

Analyzing a rejected PR:

User: "Learn from PR #3567"
Agent: [Uses this skill to]
1. Fetch PR #3567 details
2. Extract rejection reasons
3. Identify patterns (deprecated functions, missing context)
4. Update common-mistakes.mdc rule
5. Report findings

Learning from user correction:

User: "No, don't use postprocess_conversation, it's deprecated"
Agent: [Uses this skill to]
1. Extract lesson: Always check for deprecated functions
2. Update common-mistakes.mdc rule
3. Add to pre-implementation-checklist.mdc
4. Note in user preference profile

self-improvement