playbooks

home / skills / beshkenadze / claude-skills-marketplace / skill-creator

skill-creator skill

/skills/meta/skill-creator

This skill helps you create Claude Agent Skills by guiding you through discovery, design, and generation to produce SKILL.md files.

npx playbooks add skill beshkenadze/claude-skills-marketplace --skill skill-creator

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
3.3 KB
---
name: skill-creator
description: Create new Claude Agent Skills. Use when asked to create, build, or develop a skill.
version: 1.0.0
---

# Skill Creator

## Overview

Guides users through creating well-structured Claude Agent Skills by gathering requirements, generating the skill structure, and producing properly formatted SKILL.md files.

## Instructions

When helping create a new skill, follow this workflow:

### Phase 1: Discovery

Ask the user about their skill requirements:

1. **Purpose**: "What should this skill help Claude do?"
2. **Trigger**: "When should Claude use this skill? What phrases or requests should activate it?"
3. **Scope**: "What are the boundaries? What should this skill NOT do?"
4. **Examples**: "Can you give me an example input and expected output?"

### Phase 2: Design

Based on discovery, determine:

1. **Skill name**: lowercase, hyphens, max 64 chars
2. **Category**: creative, development, enterprise, or document
3. **Description**: clear trigger-focused description (max 1024 chars)
4. **Structure**: simple (SKILL.md only) or advanced (with scripts/templates)

### Phase 3: Generation

Create the skill files:

1. Generate `SKILL.md` with proper frontmatter
2. Add clear instructions section
3. Include concrete examples
4. Add guidelines and constraints
5. Create supporting files if needed

### Phase 4: Review

Present the generated skill and:

1. Explain each section's purpose
2. Suggest improvements
3. Offer to refine based on feedback

## Output Format

### SKILL.md Template

```yaml
---
name: [skill-name]
description: [Clear description explaining what this skill does and when Claude should use it]
version: 1.0.0
---

# [Skill Name]

## Overview
[Brief description of purpose]

## Instructions
[Step-by-step guidance for Claude]

## Examples

### Example: [Use Case Name]

**Input:**
[Example user request]

**Output:**
[Expected response or action]

## Guidelines
[Constraints and best practices]
```

## Examples

### Example: Create a Code Review Skill

**User**: "I want a skill that reviews Python code for best practices"

**Response**:

Let me help you create a Python code review skill. I have a few questions:

1. Should it focus on any specific aspects (security, performance, style)?
2. What coding standards should it follow (PEP 8, type hints)?
3. Should it suggest fixes or just identify issues?

[After gathering requirements, generate the skill]

### Example: Create a Documentation Skill

**User**: "Create a skill for writing API documentation"

**Response**:

I'll help you build an API documentation skill. Let me understand your needs:

1. What format should the docs be in (Markdown, OpenAPI)?
2. Should it include code examples?
3. Any specific sections required (authentication, errors)?

## Guidelines

- Always start with discovery questions
- Generate complete, working skills
- Include realistic examples
- Explain design decisions
- Offer iteration opportunities
- Follow marketplace standards

## Checklist for Generated Skills

Before presenting a skill, verify:

- [ ] Name follows conventions (lowercase, hyphens, ≤64 chars)
- [ ] Description clearly explains trigger conditions
- [ ] Instructions are step-by-step and clear
- [ ] At least one concrete example included
- [ ] Guidelines cover edge cases
- [ ] No hardcoded secrets or credentials

Overview

This skill guides you through creating well-structured Claude Agent skills by gathering requirements, designing the skill package, generating a manifest and supporting files, and reviewing the result. It enforces naming, scope, example-driven design, and marketplace-ready standards. Use it to turn a concept into a ready-to-publish skill with clear instructions and examples.

How this skill works

It walks through four phases: discovery to capture purpose, triggers, scope, and examples; design to choose name, category, description, and structure; generation to create a manifest, instructions, examples, and supporting templates; and review to explain each section and iterate. The skill validates naming conventions, trigger clarity, example completeness, and guideline coverage to ensure quality and safety.

When to use it

  • When you need to build a new Claude Agent skill from idea to deliverable
  • When you want a consistent, marketplace-friendly skill package and manifest
  • When you need to convert user requirements into concrete examples and constraints
  • When you want automated checks for naming, scope, and edge-case guidance
  • When you need iterative refinement and review before publishing

Best practices

  • Start with focused discovery questions: purpose, trigger phrases, scope limits, and example input/output
  • Use a concise, trigger-focused description and a lowercase hyphenated name (≤64 chars)
  • Provide at least one realistic example with expected output and edge cases
  • Include clear constraints and forbidden actions to define safe boundaries
  • Separate simple skills (single manifest) from advanced ones that include scripts or templates
  • Run a final checklist: naming, trigger clarity, examples, guidelines, and no embedded secrets

Example use cases

  • Create a Python code-review skill that checks style, security, and suggests fixes with examples
  • Build an API documentation writer that outputs Markdown or OpenAPI snippets with authentication and error sections
  • Design a meeting-summary skill triggered by phrases like “summarize meeting” that respects confidentiality rules
  • Generate a content-style enforcer that rewrites copy to match brand voice and flagged constraints
  • Develop a data-cleaning assistant that provides transformation scripts and test cases

FAQ

What information do you need to start?

I need the skill purpose, trigger phrases, scope boundaries (what it should not do), and at least one example input with expected output.

How do you ensure the skill is safe and compliant?

I include explicit guidelines and forbidden actions, check for hardcoded secrets, and recommend privacy rules and scope limits during discovery.

Can I iterate after seeing the first draft?

Yes. I present the generated package, explain each section, and offer targeted refinements based on your feedback.