Skillfy

Skillfy

🌍 English | 한국어 | 日本語 | 中文

Windows Users: Use WSL (Windows Subsystem for Linux) to run Skillfy.

Turn your corrections into reusable Claude Code Skills.

A Claude Code plugin that transforms your feedback into persistent learning.

Core Concept

User corrects Claude's output
       ↓
Record with /skillfy
       ↓
Promote to Skill with /skillfy review
       ↓
Claude automatically applies the rule going forward

Installation

First, add the plugin to your local marketplace, and then install it:

/plugin marketplace add https://github.com/yhzion/claude-code-skillfy.git
/plugin install skillfy@claude-code-skillfy

Update

/plugin marketplace update claude-code-skillfy

Uninstall

To completely remove the plugin, first uninstall it and then remove it from the marketplace:

/plugin uninstall skillfy@claude-code-skillfy
/plugin marketplace remove claude-code-skillfy

Usage

Initialize

/skillfy init

Creates the Skillfy database and directory structure.

Note: Skillfy installs in your Git repository root, or the current directory if not in a Git repository.

Record Mismatches

/skillfy

Record patterns when Claude generates something different from your expectations.

Recording Pattern Mismatch

What situation did this happen in?

1. {Suggested situation from context analysis}
2. {Another suggestion based on recent errors/corrections}
3. Enter manually

Select:

What did you expect?

1. {Suggested expectation based on situation}
2. {Another relevant expectation}
3. Enter manually

Select:

What rule should Claude learn? (imperative form)

1. {Suggested instruction - e.g., "Always include timestamp fields"}
2. {Another instruction option}
3. Enter manually

Select:

Record Summary

Situation: {situation}
Expected: {expectation}
Instruction: {instruction}

What would you like to do?

1. Register as Skill - Create skill file immediately
2. Save as memo - Store in DB for later review
3. Cancel

Select:

Review & Promote to Skills

/skillfy review

Review saved patterns and promote them to Skills.

Saved Patterns (not yet promoted)

[id=12] When creating models → Always include timestamp fields (2024-12-18)
[id=15] When writing API endpoints → Always include error handling (2024-12-17)

Enter pattern id(s) to promote (comma-separated for multiple, or 'skip' to cancel):
Example: 12 or 12,15

Skill Preview: {situation}

---
name: {kebab-case situation}
description: {instruction}. Auto-applied in {situation} situations.
learned_from: skillfy ({created_at})
---

## Rules

{instruction}

## Applies to

- {situation}

## Examples

### Do

(Add positive examples here)

### Don't

(Add negative examples here)

## Learning History

- Created: {created_at}
- Source: Manual recording via /skillfy

---

[Save] [Edit] [Skip]

✅ Skill created

- .claude/skills/{skill-name}/SKILL.md

🔄 Restart Claude Code to activate this skill.

Show Help

/skillfy help

Display available commands and current status.

📚 Skillfy Help

Status: ✅ Initialized | Patterns: {count} | Skills: {count} | Pending: {count}

Commands:
  /skillfy init      Initialize Skillfy
  /skillfy           Record an expectation mismatch
  /skillfy review    Promote patterns to Skills
  /skillfy reset     Delete all data
  /skillfy help      Show this help

Quick Start:
  1. /skillfy init → 2. /skillfy → 3. /skillfy review

Reset Data

/skillfy reset

⚠️ Deletes all pattern records. Generated Skills are preserved.

⚠️ Skillfy Reset

Database file:
- {DB_PATH}

Data to delete:
- {count} patterns

Note: Generated Skills (.claude/skills/) will be preserved.

✅ Skillfy data has been reset

- Patterns: all deleted
- Skills: preserved (.claude/skills/)

Start new records with /skillfy.

Examples

Two common scenarios to learn how to use Skillfy.

Example 1: Code Style Preference

Let's walk through a real scenario from start to finish.

😤 The Problem

You ask Claude to create a React component:

> Create a Button component

Claude responds:

const Button = ({ label, onClick }) => {
  return <button onClick={onClick}>{label}</button>
}

But you wanted TypeScript interfaces! This keeps happening...

📝 Step 1: Record the Mismatch

Run /skillfy right after the mismatch:

Situation: > Creating React components
Expected: > TypeScript interface for props
Instruction: > Always define a TypeScript interface for component props

What would you like to do?
> 1. Register as Skill

Result:

✅ Skill created: .claude/skills/creating-react-components/SKILL.md

🔄 Restart Claude Code to activate this skill.

✨ Step 2: Result

Restart Claude Code, then ask the same question:

> Create a Button component

Now Claude responds:

interface ButtonProps {
  label: string;
  onClick: () => void;
}

const Button = ({ label, onClick }: ButtonProps) => {
  return <button onClick={onClick}>{label}</button>
}

🎉 Claude learned your preference and applies it automatically!

Example 2: Workflow Behavior Preference

Learn how to teach Claude when to act automatically vs. ask for confirmation.

😤 The Problem

You ask Claude to check code quality:

> Check lint and format

Claude finds issues and asks:

Found issues:

| Check    | Status                           |
|----------|----------------------------------|
| ESLint   | ⚠️ 1 warning                     |
| Prettier | ❌ 2 files need formatting       |

Would you like me to fix these issues?

But you wanted Claude to just fix them! You don't want to be asked every time...

📝 Step 1: Record the Mismatch

Run /skillfy right after the mismatch:

Situation: > When checking lint/format
Expected: > Auto-fix issues without asking and fix first, then report
Instruction: > Fix without asking, report after

What would you like to do?
> 1. Register as Skill

Result:

✅ Skill created: .claude/skills/when-checking-lintformat/SKILL.md

🔄 Restart Claude Code to activate this skill.

✨ Step 2: Result

Restart Claude Code, then ask the same question:

> Check lint and format

Now Claude responds:

The skill instructs me to fix without asking. Let me fix these issues now.

✅ All issues fixed:

| Check    | Result                                         |
|----------|------------------------------------------------|
| Prettier | ✅ 2 files formatted (App.vue, HelloWorld.vue) |
| ESLint   | ✅ 0 errors, 0 warnings                        |

Changes made:
- src/App.vue — formatting fixed
- src/components/HelloWorld.vue — formatting fixed + added default value

🎉 Claude learned your workflow preference and acts without asking!

⚠️ Note: Skill Activation

Skills may not always trigger automatically. If Claude doesn't apply the skill:

1. Improve the description - Make the skill's description field more specific
2. Manual invocation - You can explicitly invoke it:

   > Check lint and format. Use skill: when-checking-lintformat
   

3. Check skill loading - Run /skillfy help to verify the skill is recognized

Best Practice

The recommended workflow:

1. Work with Claude as usual
       ↓
2. Notice a mismatch? Run /skillfy immediately
       ↓
3. Be specific: "When creating React components" > "When coding"
       ↓
4. Write clear instructions: "Always use TypeScript interfaces"
       ↓
5. Restart Claude Code to activate new Skills

Tips:

• 📝 Record mismatches right when they happen - context matters
• 🎯 Be specific about the situation - vague patterns don't help
• ✍️ Write imperative instructions - "Always do X" or "Never do Y"
• 🚀 After creating Skills, restart Claude Code to load them

How It Works

1. Record: Log situations where Claude's output didn't match expectations with /skillfy
2. Save or Promote: Either save as memo for later or create Skill immediately
3. Review: Use /skillfy review to promote saved patterns to Skills
4. Apply: Once promoted to a Skill, Claude automatically applies it in similar situations

Data Storage

Skill Naming Rules

When a skill is created, the name is automatically generated from the situation:

Security Considerations

Data Privacy

• patterns.db may contain sensitive data: The database stores situations and expectations you record. Be mindful of what information you include.
• Automatic .gitignore: The init command automatically adds .claude/skillfy/ to .gitignore to prevent accidental commits.
• Review skill files before committing: Generated skills in .claude/skills/ are NOT gitignored. Review them for sensitive context before committing to version control.
• Backup exclusions: Consider excluding .claude/skillfy/ from cloud sync services if it contains sensitive information.

File Permissions

Secure permissions are automatically set during initialization:

Input Validation

• SQL injection is prevented through quote escaping
• Path traversal is prevented in skill name generation

Troubleshooting

Common Issues

"sqlite3 is required but not installed"

• macOS/Linux: sqlite3 is typically pre-installed
• Windows: Install from https://sqlite.org/download.html

Skills not being applied

• Ensure the skill was properly created (check /skillfy help for status)
• Verify the skill file exists in .claude/skills/
• Restart Claude Code to load new skills

Requirements

• Claude Code
• sqlite3 CLI (pre-installed on macOS/Linux)
• SQLite version 3.24.0+ (for improved performance and compatibility)
• realpath or python3 (for path resolution in review command; typically pre-installed)

License

MIT