This skill should be used when the user asks to 'extract a skill from a debugging session', 'convert debugging session to skill', 'create skill from debug history', 'generate skill from troubleshooting', or mentions extracting reusable knowledge from Claude Code debugging conversations. Transforms conversation history into well-structured, reusable skills using conversation parsing and Fabric AI patterns.
/plugin marketplace add rafaelcalleja/claude-market-place/plugin install skill-extractor@claude-market-placeThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Systematically extract reusable skills and knowledge from Claude Code debugging sessions using conversation history, Fabric AI patterns, and automated skill generation. Transform tribal knowledge buried in conversations into actionable, well-structured documentation.
Debugging sessions contain valuable workflows hidden within exploration, trial-and-error, and backtracking. The working solution gets obscured by dead ends and failed attempts. This skill extracts the reusable essence—the recipe that actually worked—and transforms it into a well-structured, shareable skill.
Key principle: Document the recipe, not the discovery journey.
Claude Code stores conversations as JSONL (JSON Lines) in project-specific directories:
~/.claude/projects/{project-path-encoded}/{session-id}.jsonl
To find conversations:
# List recent conversations for a project
ls -lht ~/.claude/projects/{project-path}/*.jsonl | head -10
# Find today's conversations
find ~/.claude/projects/{project-path} -name "*.jsonl" -newermt "today"
The project path is encoded as a directory name. For example, /home/rcalleja/projects/claude-market-place becomes -home-rcalleja-projects-claude-market-place.
Ensure required tools are available:
# Check for Fabric (AI pattern extraction)
which fabric && fabric --version
# Check for jq (JSON parsing)
which jq --version
Install if missing:
# Install Fabric
go install github.com/danielmiessler/fabric@latest
# Install jq (via your package manager)
# macOS: brew install jq
# Linux: apt-get install jq (Ubuntu/Debian) or yum install jq (RHEL/CentOS)
Convert JSONL format to readable text using the parse script from skill-extractor:
bash plugins/skill-extractor/skills/extract-skill-from-conversation/scripts/parse_conversation.sh \
/path/to/session.jsonl > /tmp/conversation.txt
This script extracts:
Result: A readable conversation transcript without JSONL formatting noise.
Apply multiple Fabric patterns in parallel to extract different aspects of the conversation:
cat /tmp/conversation.txt | fabric -p extract_wisdom > /tmp/wisdom.md &
cat /tmp/conversation.txt | fabric -p extract_instructions > /tmp/instructions.md &
cat /tmp/conversation.txt | fabric -p extract_primary_problem > /tmp/problem.md &
cat /tmp/conversation.txt | fabric -p extract_primary_solution > /tmp/solution.md &
wait
Fabric patterns explained:
| Pattern | Extracts | Use For |
|---|---|---|
extract_wisdom | Key insights and learnings | "Key Insights" section in skill |
extract_instructions | Step-by-step procedures | "Steps" section in skill |
extract_primary_problem | Core problem statement | "Problem Pattern" section |
extract_primary_solution | What actually worked | Solution summary |
Running in parallel significantly speeds up extraction compared to sequential processing.
Examine what each Fabric pattern extracted:
cat /tmp/problem.md
cat /tmp/solution.md
cat /tmp/instructions.md
cat /tmp/wisdom.md
This gives you the raw material for the skill. These extractions will be refined in the next steps.
Instead of manually creating the SKILL.md file, use the plugin-dev:skill-development skill to generate it automatically.
Invoke the skill with the following prompt:
Create a new skill for Claude Code plugins based on this debugging session:
## Problem Summary
[Paste content from /tmp/problem.md]
## Solution That Worked
[Paste content from /tmp/solution.md]
## Actionable Steps
[Paste content from /tmp/instructions.md]
## Key Insights
[Paste content from /tmp/wisdom.md]
## Requirements
- Skill name: [skill-name-derived-from-problem]
- Write in imperative/infinitive form (not second person)
- Target 1,500-2,000 words for SKILL.md body
- Move detailed content to references/
- Include working examples in examples/
- Create utility scripts in scripts/ if applicable
- Focus on the "recipe that worked" without trial-and-error noise
This will guide you through:
After generating the skill structure with plugin-dev:skill-development, perform final refinement:
Place the generated skill in your plugin:
# For plugins in development
cp -r /path/to/generated-skill plugins/your-plugin/skills/skill-name/
# Test by asking Claude a question that should trigger it
cc --plugin-dir /path/to/plugin
The skill will be discovered automatically when Claude Code scans the skills/ directory.
Conversations contain buried value: Every debugging session includes exploration, dead ends, and backtracking that obscures the actual working solution.
JSONL format enables streaming: Claude Code stores conversations as JSONL, allowing efficient parsing without loading entire conversations into memory.
Multiple Fabric patterns extract different aspects: Running patterns in parallel extracts wisdom, instructions, problems, and solutions simultaneously for comprehensive coverage.
Parse-then-extract workflow separates concerns: Converting JSONL to readable text first, then applying Fabric patterns, improves reusability and clarity.
Parallel extraction saves significant time: Running multiple Fabric patterns simultaneously completes extraction much faster than sequential processing.
Curation is essential: Fabric extractions provide raw material—synthesizing them into a skill requires deliberate curation to maintain focus and clarity.
Recipes matter more than stories: Document what to do, not how you discovered it. The working solution stands alone without exploratory narrative.
Tool calls provide critical context: Conversation tool calls and results show exactly what executed successfully, which is more reliable than narrative descriptions.
Prerequisites aren't always obvious: Document assumptions, required tools, credentials, or setup steps that might not be clear to someone replicating the workflow later.
Pattern recognition is valuable knowledge: Insights like "this error type usually means X" or "this tool is commonly mistaken for Y" are worth capturing in skills.
Skill validation prevents distribution of incomplete workflows: Testing the extracted skill on a similar problem verifies completeness before sharing.
Progressive disclosure keeps skills focused: Lean SKILL.md with detailed content in references/ means essential information loads immediately when needed.
Imperative language improves clarity: Verb-first instructions are easier to follow than narrative explanations for procedural guidance.
Claude Code project paths are encoded: Project paths are transformed to directory names in ~/.claude/projects/, making conversations easy to locate programmatically.
Skill-extractor plugin is meta-documentation: The plugin documents its own extraction process, serving as both a tool and example of skill extraction in action.
Including all exploration: Including too much trial-and-error narrative. Edit ruthlessly; keep only the critical path to the solution.
Forgetting to verify commands: Commands extracted from conversation may have changed or contain typos. Test each command before finalizing the skill.
Verbose explanations: Converting verbose conversation explanations directly into skills. Distill to essence; remove redundancy.
Missing prerequisites: Assuming readers share your context. Document required tools, versions, credentials, file paths, and dependencies explicitly.
Narrative voice in procedures: Writing "I did X" or "You should do X" instead of "Do X". Use imperative voice for step-by-step instructions.
Retaining failed alternatives: Including alternative approaches you tried but abandoned. Focus on the single best approach that worked.
Skipping validation: Not testing the extracted skill on a fresh problem. Always validate completeness before distribution.
Dead-end references: Including URLs or files that led nowhere. Reference only materials that directly contribute to the solution.
Losing context about tool dependencies: Not documenting why specific tools are required or their role in the workflow.
Over-fitting to specific scenario: Making the skill too specific to your exact situation instead of generalizable to similar problems.
For detailed guidance on related topics, consult:
https://github.com/danielmiessler/fabric - Documentation on pattern extraction~/.claude/projects/ - Where conversations are storedplugins/skill-extractor/ - Pre-built scripts and templatesThis skill leverages resources from the skill-extractor plugin:
skills/extract-skill-from-conversation/scripts/parse_conversation.sh - Converts JSONL to readable textskills/extract-skill-from-conversation/references/fabric_patterns.md - Detailed pattern documentationskills/extract-skill-from-conversation/references/skill_template.md - SKILL.md template structureWhen using this skill, refer to these bundled resources for detailed guidance on pattern extraction and skill structure.
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.