Focused plugin for creating Claude Code skills with interactive wizard and validation

version
1.0.0

Install

/plugin install skill-creator@agent-toolkit

Run it inside Claude Code after adding the marketplace with /plugin marketplace add TomazWang/agent-toolkit.

Contents

Discovered from source

Skills 4

Create Skill

Interactive wizard that guides you through creating a properly structured Claude Code skill.

When to Use

  • User invokes /skill-creator:create-skill <name>
  • User asks "create a skill"
  • User wants to add a skill to their plugin

Workflow

1. Invoke Skill Architect Agent

Use the skill-architect agent to help design the skill:

Agent asks:
1. What does this skill do? (Brief description)
2. When should it activate? (Triggering conditions)
3. Should users invoke it directly? (user-invocable)
4. What's the expected workflow? (Process steps)

2. Create Skill Structure

Based on architect's recommendations, create:

skills/<skill-name>/
  └── SKILL.md

3. Generate Frontmatter

---
name: skill-name
description: Brief description from step 1
user-invocable: false  # Only if auto-only
---

4. Add Content Template

# Skill Name

Brief overview.

## When to Use

[Triggering conditions from step 2]

## Overview

[Detailed explanation]

## Process

[Step-by-step workflow from step 4]

## Examples

[Concrete usage examples]

5. Save and Validate

  • Write SKILL.md file
  • Invoke skill-validator agent
  • Report any issues
  • Ask if user wants to make changes

Output

✓ Created skills/analyze-code/SKILL.md

Structure:
- Frontmatter: Valid
- When to Use: Clear triggers
- Content: Complete template

Next steps:
1. Fill in detailed content
2. Test with: /skill-creator:test analyze-code
3. Validate with: /skill-creator:validate-skill-structure analyze-code

Error Handling

  • Skill already exists: Ask to overwrite or choose new name
  • Invalid name: Suggest valid name (kebab-case)
  • Missing parent plugin: Ensure we're in a plugin directory

Skill Templates

When to Use

  • User invokes /skill-creator:templates
  • User asks "show me skill examples"
  • User wants a starting point

Available Templates

1. Auto-Activating Skill

Use when: Skill should trigger automatically based on context

---
name: auto-formatter
description: Automatically formats code when pasted
user-invocable: false
---

## When to Use

Auto-activates when:
- User pastes code block
- Code has formatting issues
- Keywords detected: "format", "clean up"

2. User-Invocable Skill

Use when: Skill is explicitly called by user

---
name: generate-docs
description: Generate documentation for code
---

## When to Use

- User invokes /plugin:generate-docs
- User asks "document this code"
- User requests documentation generation

3. Guide/Reference Skill

Use when: Skill provides learning material

---
name: design-patterns
description: Reference guide for design patterns
---

## When to Use

- User invokes /plugin:design-patterns
- User asks "what are design patterns?"
- Can reference during code review

4. Workflow Orchestrator

Use when: Skill manages multi-step workflow

---
name: orchestrator
description: Main workflow conductor
user-invocable: false
---

## When to Use

Auto-activates when:
- User invokes /plugin:start
- User begins structured workflow

5. Integration Skill

Use when: Skill integrates with another plugin

---
name: task-integration
description: Integrates with task-management plugin
user-invocable: false
---

## When to Use

Auto-activates when:
- task-management plugin detected
- User creates workflow tasks

Output

Shows template list with:

  • Template name
  • Use case
  • Complete example
  • When to use each pattern

Skill Validation

Schema-based skill validation for Claude Code skills.

When to Use

Auto-activates when:

  • User asks to "validate skill"
  • After creating or modifying a skill
  • User asks "check my skill"
  • Skill not working as expected

Validation Process

1. Locate Skill

# If in skill directory
/skill-creator:validate-skill-structure

# Or specify path
/skill-creator:validate-skill-structure skills/my-skill

2. Load Validation Schemas

Read schemas from skills/validation/schema/:

  • skill-frontmatter.md - SKILL.md frontmatter validation
  • skill-structure.md - Folder and file structure validation
  • when-to-use.md - "When to Use" section requirements
  • content-quality.md - Content completeness and clarity

3. Run Validation Checks

Checks:

  1. Folder structure (skill-structure.md)
  2. SKILL.md frontmatter (skill-frontmatter.md)
  3. "When to Use" section (when-to-use.md)
  4. Content quality (content-quality.md)

4. Report Results

Validating: my-skill/

Structure
=========
✓ Is a directory (not flat .md file)
✓ Contains SKILL.md (uppercase)
✓ Folder name matches skill name

Frontmatter
===========
✓ Valid YAML syntax
✓ name: my-skill (kebab-case)
✓ description: Clear and concise (42 chars)
⚠ user-invocable: Consider adding 'false' if auto-only

"When to Use"
=============
✓ Section present
✓ Clear triggering conditions
✓ User invocation format included
✓ Auto-activation keywords listed

Content Quality
===============
✓ Clear purpose statement
✓ Step-by-step process
✓ Examples provided
⚠ Consider adding edge cases

Summary
=======
✓ 12 passed
⚠ 2 warnings
✗ 0 errors

Ready to use!

Validation Levels

✓ PASS - Skill is ready to use ⚠ WARNING - Works but has recommendations ✗ ERROR - Critical issues, must fix

Schema Files

All schemas are in skills/validation/schema/:

skill-frontmatter.md

Defines valid SKILL.md frontmatter:

  • Required: name (kebab-case), description
  • Optional: user-invocable (false for auto-only)

skill-structure.md

Defines folder structure:

  • Must be directory (not flat .md)
  • Must contain SKILL.md (uppercase)
  • Folder name must match skill name

when-to-use.md

Defines "When to Use" section:

  • Required section
  • Clear triggering conditions
  • User invocation format
  • Auto-activation keywords

content-quality.md

Defines content requirements:

  • Clear purpose
  • Step-by-step process
  • Examples
  • Edge cases

Integration

Works with:

  • skill-validator agent (uses schemas)
  • skill-creator:create (creates valid structure)
  • skill-creator:edit (validates after editing)

Validate Skill

Validates a skill for correct structure and best practices.

When to Use

  • User invokes /skill-creator:validate-skill-structure <skill>
  • After creating or editing a skill
  • Before committing skill

Validation Process

1. Invoke Skill Validator Agent

Use skill-validator agent to check:

Structure:

  • ✓ Skill is in folder (not flat .md)
  • ✓ Contains SKILL.md file
  • ✓ File is readable

Frontmatter:

  • ✓ Valid YAML syntax
  • ✓ Has name field
  • ✓ Has description field
  • ✓ user-invocable set correctly
    • false only if truly auto-only
    • Missing or true if user can invoke

Content:

  • ✓ Has "When to Use" section
  • ✓ Clear triggering conditions
  • ✓ Examples provided
  • ✓ Process/workflow defined

Naming:

  • ✓ Folder name matches skill name
  • ✓ Uses kebab-case
  • ✓ No special characters

2. Report Findings

Validating: skills/analyze-code/

✓ Structure: Valid
✓ Frontmatter: Valid
✓ When to Use: Clear triggers
⚠ Missing examples section

Issues:
1. Add concrete usage examples

Suggestions:
- Add "## Examples" section
- Show before/after scenarios

3. Offer Fixes

For common issues, offer automatic fixes:

  • Add missing sections
  • Fix frontmatter format
  • Correct user-invocable flag

Output Levels

✓ PASS - Skill is ready to use ⚠ WARNING - Skill works but has suggestions ✗ ERROR - Skill has critical issues

Common Issues

Missing user-invocable:

  • If skill auto-activates, add user-invocable: false
  • If user invokes, no flag needed

Vague "When to Use":

  • Be specific about triggers
  • Include keywords
  • Define clear activation patterns

Missing examples:

  • Add concrete scenarios
  • Show input/output
  • Demonstrate usage

Agents 2

Skill Architect Agent

Specialized agent for designing Claude Code skill structure and triggering patterns.

Your Role

You help users design effective skills by:

  1. Understanding skill purpose
  2. Defining clear triggering conditions
  3. Deciding user-invocable setting
  4. Structuring content

Process

1. Understand Purpose

Ask clarifying questions:

Q1: What does this skill do?

  • Get brief, clear description
  • Understand core functionality
  • Identify target use case

Q2: What problem does it solve?

  • Understand why it's needed
  • Identify user pain points

2. Define Triggering Conditions

Ask about activation:

Q3: When should this skill activate?

Options:

  • User invokes explicitly → /plugin:skill-name
  • Auto-activates on keywords → Specific phrases trigger it
  • Auto-activates on context → Detects patterns/situations
  • Both → Can be invoked OR auto-activates

Q4: What are the triggering keywords/patterns?

  • List specific phrases
  • Define context patterns
  • Identify clear signals

3. Decide user-invocable Setting

Based on Q3:

If ONLY auto-activates (no user invocation):

user-invocable: false

If user CAN invoke (with or without auto-activation):

# No user-invocable field (defaults to true)

Guideline:

  • Most skills should be user-invocable
  • Only add user-invocable: false if truly internal/auto-only
  • When in doubt, allow user invocation

4. Structure Content

Recommend content sections:

Required:

  • When to Use (triggering conditions)
  • Overview (what it does)
  • Process/Workflow (step-by-step)

Optional:

  • Examples (highly recommended)
  • Integration (if works with other plugins)
  • Error Handling
  • Configuration

5. Generate Template

Create SKILL.md template:

---
name: skill-name
description: [from Q1]
user-invocable: false  # Only if needed
---

# Skill Name

[Overview from Q1-Q2]

## When to Use

[Triggering conditions from Q3-Q4]

## Overview

[Detailed explanation]

## Process

[Step-by-step workflow]

## Examples

[Concrete scenarios]

Output Format

Skill Architecture Plan
=======================

Name: analyze-code
Description: Analyzes code for patterns and improvements
Purpose: Help users improve code quality

Triggering:
- User invokes: /plugin:analyze-code
- Auto-activates when: User asks "analyze this code"
- Keywords: "analyze", "review", "check code"

user-invocable: true (can be invoked)

Content Structure:
1. When to Use - Clear triggers
2. Overview - What it analyzes
3. Process - Step-by-step analysis
4. Examples - Before/after code

Template generated at: skills/analyze-code/SKILL.md

Best Practices

DO:

  • Ask clarifying questions
  • Be specific about triggers
  • Recommend user-invocable unless truly internal
  • Include examples in template

DON'T:

  • Make assumptions without asking
  • Use vague triggering conditions
  • Default to user-invocable: false without reason
  • Skip examples

Skill Validator Agent

Specialized agent for validating Claude Code skill correctness and best practices.

Your Role

You validate skills for:

  1. Correct structure
  2. Valid frontmatter
  3. Clear triggering conditions
  4. Best practices compliance

Validation Checklist

1. Structure Check

✓ Folder Structure:

skills/skill-name/
  └── SKILL.md

Errors:

  • ✗ Flat file: skills/skill-name.md (should be folder)
  • ✗ Wrong filename: skills/skill-name/skill.md (should be SKILL.md)
  • ✗ Missing SKILL.md

2. Frontmatter Check

Required Fields:

---
name: skill-name          # ✓ Required
description: Brief text   # ✓ Required
user-invocable: false    # Optional (only if auto-only)
---

Validations:

  • ✓ Valid YAML syntax
  • ✓ name matches folder name
  • ✓ description is brief and clear
  • ✓ user-invocable: false only if skill is auto-only

Common Issues:

  • ✗ YAML syntax errors
  • ✗ Name mismatch (folder vs frontmatter)
  • ✗ Missing description
  • ✗ Unnecessary user-invocable: false

3. Content Check

Required Sections:

"When to Use" section:

  • ✓ Present
  • ✓ Lists clear triggers
  • ✓ Specifies activation patterns

Examples:

## When to Use

- User invokes /plugin:skill-name
- User asks "analyze code"
- Keywords: "analyze", "review"

Issues:

  • ✗ Missing "When to Use"
  • ✗ Vague triggers ("use when appropriate")
  • ✗ No activation patterns

4. user-invocable Logic Check

Guideline:

  • If skill is only auto-activated → user-invocable: false
  • If skill can be invoked by user → No flag (or true)

Check "When to Use" section:

Example 1: Auto-only

## When to Use

Auto-activates when:
- System detects pattern X
- Context Y is present

→ ✓ Should have user-invocable: false

Example 2: User-invocable

## When to Use

- User invokes /plugin:skill
- User asks "do X"

→ ✓ Should NOT have user-invocable: false

Example 3: Both

## When to Use

- User invokes /plugin:skill
- OR auto-activates when keyword detected

→ ✓ Should NOT have user-invocable: false

5. Best Practices Check

Recommendations:

✓ Examples section:

  • Shows concrete usage
  • Before/after scenarios
  • Multiple use cases

✓ Clear process:

  • Step-by-step workflow
  • Numbered steps
  • Decision points

✓ Error handling:

  • Edge cases
  • Error messages
  • Fallbacks

Validation Levels

PASS ✓

All required elements present and correct:

✓ Structure: Valid
✓ Frontmatter: Valid
✓ When to Use: Clear
✓ user-invocable: Correct
✓ Examples: Present

WARNING ⚠

Skill works but has suggestions:

✓ Structure: Valid
✓ Frontmatter: Valid
✓ When to Use: Clear
⚠ Examples: Missing
⚠ Process: Could be clearer

ERROR ✗

Critical issues preventing skill from working:

✗ Structure: Flat file (should be folder)
✗ Frontmatter: Invalid YAML
✓ When to Use: Clear

Output Format

Validating: skills/analyze-code/

Structure
=========
✓ Folder structure: skills/analyze-code/
✓ SKILL.md exists

Frontmatter
===========
✓ Valid YAML
✓ name: analyze-code (matches folder)
✓ description: Present
⚠ user-invocable: false (unnecessary - skill can be invoked)

Content
=======
✓ When to Use: Clear triggers
✓ Overview: Present
✓ Process: Step-by-step
⚠ Examples: Missing

Issues
======
1. user-invocable set to false but "When to Use" shows user invocation
2. Missing examples section

Suggestions
===========
1. Remove `user-invocable: false` (skill is user-invocable)
2. Add "## Examples" section with usage scenarios

Result: ⚠ WARNING (2 issues, 2 suggestions)

Auto-Fix Suggestions

For common issues, suggest automatic fixes:

Issue: Missing user-invocable

Auto-fix available:
Add `user-invocable: false` to frontmatter?
This skill appears to be auto-only based on "When to Use"

Issue: Wrong user-invocable

Auto-fix available:
Remove `user-invocable: false` from frontmatter?
This skill shows user invocation in "When to Use"

Best Practices

DO:

  • Validate against actual skill content
  • Provide specific, actionable feedback
  • Suggest auto-fixes for common issues
  • Explain WHY something is wrong

DON'T:

  • Be overly strict on style
  • Flag minor formatting issues
  • Suggest user-invocable: false by default
  • Fail validation for warnings

Sponsors

Details

Marketplace
TomazWang/agent-toolkit
Source
plugins/skill-creator
Author
Agent Toolkit
Category
Meta
Keywords
skills, development, tools, creation

More from TomazWang/agent-toolkit

All 6