Weaves custom Skills for Claude following official best practices including proper structure, metadata, progressive disclosure, and security guidelines. Use when creating new skills, building custom workflows, or when user mentions skill creation, skill development, custom skill authoring, weaving skills, or crafting skills.
Creates complete Claude Skills following official best practices. Triggers when users request skill creation, development, or authoring.
/plugin marketplace add flashingcursor/skill-creator-plugin/plugin install weaver@skill-weaver-marketplaceThis skill inherits all available tools. When active, it can use any tool Claude has access to.
README.mdREFERENCE.mdtemplates/advanced-skill-template.mdtemplates/basic-skill-template.mdtemplates/example-script.jstemplates/example-script.pyNote: Anthropic provides default skills including "skill-builder" and "skill-creator" that may also respond to skill creation requests. If you prefer to use this Skill Weaver instead, you can be explicit in your request (e.g., "use weaver to create a skill for...") or manage your enabled skills in settings.
This Skill helps users create Skills for both Claude Code and claude.ai following official best practices. It guides through creating SKILL.md files, structuring directories, adding resources, and ensuring quality.
What are Skills? Skills package expertise into discoverable capabilities. Each Skill consists of a SKILL.md file with instructions that Claude reads when relevant, plus optional supporting files like scripts and templates.
Model-invoked: Skills are autonomously triggered by Claude based on your request and the Skill's description. This is different from slash commands (which you explicitly type to trigger).
Current Version: 0.2.1
This release renames the directory to "weaver-create" to fully avoid conflicts with Anthropic's default skills. For version history and changelog, see README.md.
Skill Weaver supports two platforms:
~/.claude/skills/, .claude/skills/)allowed-tools fieldclaude --debugallowed-tools field supportCommon Features (both platforms):
Use when:
This Skill uses a create-review-adapt approach that minimizes friction while adapting to user engagement level.
Phase 1: AUTONOMOUS CREATE (with progress indicators)
Creating Skill structure... ✓
Writing description and metadata... ✓
Generating core instructions... ✓
Adding examples and templates... ✓
Phase 2: CONCISE SUMMARY (with offer to elaborate)
Phase 3: ENGAGEMENT DETECTION (adapt based on feedback)
Low Engagement - User provides minimal feedback:
Medium Engagement - User requests specific changes:
High Engagement - User asks detailed questions or expresses uncertainty:
Re-emphasize download links to keep them visible and accessible:
After providing explanations:
[Detailed explanation of validation patterns]
**Download:** [Download api-testing.zip]
Any other questions, or ready to use it?
After making changes:
✓ Updated to include GraphQL support
**Download:** [Download api-testing.zip]
Ready to go, or any other changes?
Why this matters:
Show progress during autonomous creation to:
Good progress indicators:
Analyzing requirements... ✓
Setting up Skill structure for claude.ai... ✓
Writing SKILL.md with comprehensive instructions... ✓
Creating validation script template... ✓
Preparing example prompts for testing... ✓
Avoid:
When presenting the Skill in Phase 2, explain your key choices:
Platform decisions:
"I created this for both platforms since you didn't specify. This means omitting allowed-tools (Claude Code-only), but it gives you maximum flexibility for distribution."
Structural decisions: "I included a REFERENCE.md file for detailed API documentation instead of putting everything in SKILL.md. This keeps the main instructions concise while Claude can load the reference on-demand when needed."
Scope decisions: "I focused on the core workflow you described and added basic error handling. I didn't include advanced edge cases yet - we can add those if you need them."
Description decisions: "The description mentions 'CSV', 'data analysis', and 'pandas' as triggers. This should invoke the Skill when you're working with data files without being too broad."
Users can explicitly request different interaction styles. Recognize these requests and adapt accordingly.
Purpose: Fast, autonomous Skill creation with minimal interaction.
When users request this:
Workflow:
What to skip:
Example interaction:
User: "Just create a skill for code reviews quickly"
AI: "Creating code-review skill for both platforms...
Creating Skill structure... ✓
Writing description and instructions... ✓
Adding review checklist... ✓
Packaging... ✓
✓ All set! Here's your code-reviewer.zip
**Installation:**
[Brief platform-specific instructions]
**Quick test:**
Try: 'Review this Python file for best practices'"
Purpose: Collaborative, educational Skill creation with user involved at each step.
When users request this:
Workflow:
What to include:
Example interaction:
User: "Walk me through creating a skill for data analysis"
AI: "I'd be happy to guide you through creating a data-analysis skill! Let's start by making some key decisions together.
**Platform Choice:**
We need to decide where this skill will run:
- **Claude Code only**: Can use tool restrictions, distribute via plugin
- **claude.ai only**: ZIP upload, simpler for individuals
- **Both platforms**: Maximum compatibility, skip platform-specific features
Which environment are you targeting?"
User: "Both platforms"
AI: "Great choice for maximum flexibility! Since we're targeting both platforms, we'll use the metadata field format and skip the allowed-tools field.
**Skill Scope:**
For data analysis, we could focus on:
- **Option A**: General CSV/Excel analysis (pandas-based, broad applicability)
- **Option B**: Specific analysis type (e.g., time series, statistical)
- **Option C**: Domain-specific (e.g., sales data, scientific data)
What type of data analysis will this skill handle?"
[Continues with collaborative decision-making]
Purpose: Balanced approach that adapts to user's natural engagement level.
When to use:
Workflow:
Key principle: Let the user's feedback reveal their preferred engagement level rather than asking them to choose upfront.
Example interaction:
User: "Create a skill for API testing"
AI: [Autonomous create phase with progress indicators]
"I've created an api-testing skill for both platforms. Here's what I built:
**Key Decisions:**
- Platform: Both (you didn't specify, this maximizes flexibility)
- Scope: REST API testing with request validation and response checking
- Structure: Main instructions in SKILL.md, advanced patterns in REFERENCE.md
- Description: Triggers on 'API', 'endpoint', 'testing', or 'REST'
**What's included:**
- Request building and validation
- Response assertion patterns
- Error handling and logging
- Example test scenarios
What would you like to adjust?"
[User feedback determines next steps]
- "looks good" → Package immediately
- "add GraphQL support" → Make change, ask if ready
- "How does validation work?" → Switch to collaborative mode
Use Quick Create when:
Use Guided Create when:
Use Default (Adaptive) when:
You can switch modes mid-creation if user signals change in engagement:
From Quick to Guided:
[You're in quick create, packaging]
User: "Wait, can you explain why you structured it this way?"
→ Stop packaging, switch to guided mode, provide explanation
From Guided to Quick:
[You're asking detailed questions]
User: "Actually, just make the decisions and show me what you build"
→ Switch to quick create, proceed autonomously
From Default to either:
If engagement level is unclear:
Package immediately when:
Continue iterating when:
Initial Request: User: "Create a skill for reviewing Python code"
Phase 1 - Autonomous Create:
Creating Skill structure... ✓
Writing description and metadata... ✓
Generating code review instructions... ✓
Adding Python best practices... ✓
Creating example prompts... ✓
Phase 2 - Concise Summary: "✓ Created your code-reviewer Skill! Here's what I built:
Files created:
Key features:
Download: [Download code-reviewer.zip]
I can explain any decisions if you'd like. What would you like to adjust?"
Phase 3 - Engagement Detection:
Low engagement response: "Looks great!" → Package immediately, provide installation instructions
Medium engagement response: "Can you add type hint checking?" → Add type hints to checklist, show update, ask if ready
High engagement response: "Should we include async code patterns? What about testing coverage?" → Switch to collaborative mode, discuss options, get input on priorities
The context window is a public good. Your Skill shares it with system prompts, conversation history, other Skills' metadata, and the user's request. Be concise:
Good (concise): "Use pdfplumber for PDF text extraction" Bad (verbose): "PDF (Portable Document Format) files are common... you'll need a library... there are many options..."
Match specificity to task fragility:
Skills affect models differently. Test with Haiku, Sonnet, and Opus. What works for Opus may need more detail for Haiku.
First, ask which platform(s) the user is targeting:
Then gather requirements:
For Claude Code:
Personal Skills:
mkdir -p ~/.claude/skills/skill-name
Project Skills:
mkdir -p .claude/skills/skill-name
For claude.ai:
Create a local directory (will be ZIPped later):
mkdir -p skill-name
Directory contents (both platforms):
skill-name/
├── SKILL.md # Required: Main Skill file
├── reference.md # Optional: Supplemental information
├── examples.md # Optional: Extended examples
├── templates/ # Optional: Template files
│ └── template.txt
└── scripts/ # Optional: Executable code
├── helper.py
└── validate.py
The SKILL.md file must include:
For both platforms:
---
name: skill-name
description: What the Skill does and when to use it. Include specific triggers and contexts. Use third person. Max 1024 characters.
metadata:
version: 1.0.0
dependencies: package>=version, another-package>=version
---
For Claude Code only (add this field if needed):
allowed-tools: Read, Grep, Glob # Restrict which tools Claude can use
Platform Compatibility Notes:
claude.ai has strict frontmatter validation and only accepts these top-level keys: name, description, license, allowed-tools, metadata. This is why version and dependencies must be nested under the metadata field.
Claude Code is more permissive and will accept the metadata field without issues. While Claude Code's documentation shows version as a top-level field, using the metadata structure ensures your Skill works on both platforms.
Best Practice for Dual-Platform Support:
metadata field format shown above for maximum compatibilityallowed-tools field if targeting both platforms (Claude Code only)Name requirements (both platforms):
Description requirements (both platforms):
Dependencies handling:
python>=3.8, pandas>=1.5.0, requests>=2.28.0Tool restrictions (allowed-tools) - Claude Code ONLY:
allowed-tools: Read, Grep, Glob for read-only Skill# Skill Name
## Overview
Brief explanation of what the Skill does and its purpose.
## When to Use This Skill
- Specific scenario 1
- Specific scenario 2
- Specific scenario 3
## Instructions
Clear, step-by-step instructions for Claude to follow.
## Examples
Include example inputs and expected outputs.
## Resources
Reference any additional files in the Skill directory.
If the Skill requires additional information:
REFERENCE.md for supplemental contentresources/examples/resources/templates/For advanced Skills that need executable code:
.py) for data processing, analysis, or automation.js) for web-related tasksSupported languages:
Note: Claude and Claude Code can install packages from standard repositories when loading Skills.
Create ZIP file:
# From parent directory
zip -r skill-name.zip skill-name/
# Verify structure
unzip -l skill-name.zip
Expected structure:
skill-name.zip
└── skill-name/
├── SKILL.md
├── reference.md
└── scripts/
Share with users:
Team distribution:
Recommended: Share via Plugin Best for team distribution:
skills/ directoryAlternative: Share via Git (Project Skills) For project-specific Skills:
.claude/skills/skill-name/git add .claude/skills/ && git commit -m "Add skill"git pullPersonal Skills:
~/.claude/skills/If targeting both, provide:
allowed-tools)Test with matching requests: Skills are autonomously invoked—Claude decides when to use them based on the description.
Ask questions that match your description:
# If description mentions "PDF files"
"Can you help me extract text from this PDF?"
# Claude automatically uses your Skill if it matches
Verify Skill is loaded:
Ask Claude: "What Skills are available?"
For claude.ai:
For Claude Code:
ls ~/.claude/skills/skill-name/SKILL.md # Personal
ls .claude/skills/skill-name/SKILL.md # Project
claude --debug to see loading errorsCommon Debugging Steps:
---, no tabsFor comprehensive details, see REFERENCE.md.
Use consistent patterns:
Claude loads information in stages:
Keep Skill.md under 500 lines. Move details to separate files.
For multi-step tasks, provide checklists:
## Task workflow
Copy this checklist:
Progress:
**Step 1: Analyze input**
[Detailed instructions...]
Add validation cycles for quality:
1. Make changes
2. Run validation: `python validate.py`
3. If validation fails:
- Review errors
- Fix issues
- Run validation again
4. Only proceed when validation passes
Template pattern - Provide output format:
ALWAYS use this exact structure:
[template here]
Examples pattern - Show input/output pairs:
Example 1:
Input: [specific input]
Output: [expected output]
Conditional workflow - Guide decisions:
1. Determine type:
**Creating new?** → Follow creation workflow
**Editing existing?** → Follow editing workflow
\): Use forward slashes (/) always---
name: generating-commit-messages
description: Generates clear commit messages from git diffs. Use when writing commit messages or reviewing staged changes.
---
# Generating Commit Messages
## Instructions
1. Run `git diff --staged` to see changes
2. Suggest a commit message with:
- Summary under 50 characters
- Detailed description
- Affected components
---
name: code-reviewer
description: Review code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
allowed-tools: Read, Grep, Glob # Restrict to read-only operations
---
# Code Reviewer
## Instructions
1. Read target files using Read tool
2. Search for patterns using Grep
3. Find related files using Glob
4. Provide detailed feedback on code quality
pdf-processing/
├── SKILL.md
├── forms.md # Form-filling guide (loaded on-demand)
├── reference.md # API reference (loaded as needed)
└── scripts/
├── fill_form.py
└── validate.py
---
name: pdf-processing
description: Extract text, fill forms, merge PDFs. Use when working with PDF files, forms, or document extraction.
metadata:
dependencies: pypdf>=3.0.0, pdfplumber>=0.9.0
---
# PDF Processing
## Quick start
For form filling, see [forms.md](forms.md).
For API reference, see [reference.md](reference.md).
When adding scripts to Skills:
See templates/basic-skill-template.md for a minimal Skill structure suitable for simple instruction-based Skills.
See templates/advanced-skill-template.md for a complete Skill structure with resources and scripts.
For reference implementations, see:
When creating a Skill, provide:
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.