Skill Creator Studio

An interactive skill for creating new Claude Code skills through a guided, iterative process. Walks through skill design, drafting, testing, refinement, and publishing with best practices built into every step.

When to Use This Skill

Choose this skill when:

• Building a new Claude Code skill and want guided step-by-step help
• Iteratively refining a draft skill with testing and feedback
• Converting an existing workflow or checklist into a reusable skill
• Publishing skills to a team or community repository
• Learning skill design patterns through hands-on creation

Consider alternatives when:

• Need a reference on skill architecture → use a skill creation guide
• Building a skill framework or ecosystem → use a skill framework skill
• Installing existing skills → use a skill installer
• Working on MCP servers or hooks → use MCP or hooks skills

Quick Start

Copy
# Skill Creation Process

## Phase 1: Design
- What problem does this skill solve?
- Who is the target user?
- What inputs does the skill need?
- What outputs should it produce?
- What existing skills overlap?

## Phase 2: Draft
- Write the frontmatter (name, description)
- Define the purpose and scope
- Write step-by-step instructions
- Add rules and constraints
- Include 2-3 concrete examples

## Phase 3: Test
- Run the skill on a sample project
- Test with edge cases and unusual inputs
- Verify output format consistency
- Check for conflicts with other skills

## Phase 4: Refine
- Adjust instructions based on test results
- Tighten ambiguous wording
- Add error handling for common failures
- Simplify over-complicated steps

## Phase 5: Publish
- Add metadata (version, author, tags)
- Write installation instructions
- Create a changelog
- Share to repository or team

Core Concepts

Skill Design Canvas

Question	Purpose	Example
What does it do?	Core value proposition	"Generates API endpoint boilerplate"
When is it used?	Trigger conditions	"When creating a new REST endpoint"
What does it need?	Input requirements	"Route path, HTTP methods, handler logic"
What does it produce?	Output artifacts	"Route file, controller, tests, types"
What are the rules?	Constraints	"Follow project's existing patterns"
What can go wrong?	Error scenarios	"Missing project config, wrong framework"

Iterative Refinement Loop

Copy
# Test-Driven Skill Development

1. Write a test case (specific input → expected output)
2. Run the skill draft against the test case
3. Compare actual output to expected output
4. Identify gaps:
   - Missing output → add instruction step
   - Wrong format → tighten format rules
   - Inconsistent behavior → add explicit constraints
   - Edge case failure → add error handling
5. Update skill, re-run test
6. Repeat until all test cases pass consistently

Skill Prompt Engineering

Copy
# Effective skill instructions use:

## Concrete Actions (Good)
1. Read the file at `src/routes/index.ts` using the Read tool
2. Parse all exported route handlers matching: `router.(get|post|put|delete)`
3. For each handler, generate a test file at `tests/routes/{handler-name}.test.ts`

## Vague Directions (Bad)
- Look at the routing code
- Write appropriate tests
- Make sure everything works

## Template Variables (Good)
When the user specifies `--framework react`:
- Use `describe()` and `it()` from vitest
- Import from `@testing-library/react`
- Use `render()` and `screen` for component tests

## Static Assumptions (Bad)
- Always use Jest for testing
- Assume the project uses React

Configuration

Parameter	Type	Default	Description
creationMode	string	'guided'	Mode: guided (interactive) or express (minimal)
testCasesRequired	number	3	Minimum test cases before publishing
refinementIterations	number	2	Recommended refinement rounds
publishTarget	string	'local'	Target: local, team, or community
templateBase	string	'standard'	Starting template: standard, minimal, or advanced
documentationLevel	string	'full'	Docs: full, summary, or minimal

Best Practices

1. Start with a single, specific use case before generalizing — A skill that "generates any kind of test for any framework" will be mediocre at everything. Start with "generates vitest unit tests for React components," prove it works, then expand to other frameworks.

2. Write test cases before writing instructions — Define what success looks like with concrete examples. Then write instructions that produce those specific outputs. This prevents feature creep and ensures the skill actually works.

3. Use the "explain it to a colleague" test — If you can't explain what the skill does in two sentences, it's too complex. Split it into smaller, composable skills or narrow the scope.

4. Include negative examples ("don't do this") — Showing Claude what NOT to produce is as valuable as showing what to produce. Include examples of common mistakes and explicitly forbid them in the rules section.

5. Version your skills and maintain a changelog — When you update a skill, note what changed and why. Team members who rely on the skill need to know when behavior changes. Breaking changes deserve explicit communication.

Common Issues

Skill produces great results on first test, fails on real projects — Test projects are simpler than real ones. Test with: large files, unusual directory structures, multiple programming languages, and projects with existing partial implementations.

Instructions too long cause Claude to skip steps — Very long skill files can cause Claude to skim rather than follow every step. Keep instructions under 50 numbered steps. Split larger workflows into multiple skills that compose together.

Skill behavior changes after Claude model updates — Claude's interpretation of instructions can shift between model versions. Pin critical skills to specific phrasing that tests have validated, and re-test skills after model updates.