Template Skill Studio

A skill authoring environment for designing, testing, and publishing Claude Code skill templates with structured prompts, parameter validation, and reusable patterns.

When to Use

Choose Template Skill Studio when:

• Designing new Claude Code skill templates with structured prompt engineering
• Testing skill templates with various parameter combinations before publishing
• Building a team library of standardized development skill templates
• Converting existing workflows into reusable, parameterized skill files

Consider alternatives when:

• Running existing skills — use the skills directly without the studio
• Building CI/CD pipelines — use dedicated pipeline tools
• Creating documentation — use standard documentation generators

Quick Start

Copy
# Initialize a skills workspace
mkdir -p .claude/skills && cd .claude/skills

# Create a skill template
cat > api-endpoint.md << 'SKILL'
# API Endpoint Generator

Generate a complete REST API endpoint with controller, service, validation, and tests.

## Parameters
- `resource`: Resource name (singular, lowercase)
- `methods`: HTTP methods to implement (default: "GET,POST,PUT,DELETE")
- `auth`: Authentication required (default: true)
- `validation`: Include request validation (default: true)

## Instructions
1. Create the route file at `src/routes/{resource}.ts`
2. Create the controller at `src/controllers/{resource}Controller.ts`
3. Create the service at `src/services/{resource}Service.ts`
4. Create validation schemas at `src/validation/{resource}.ts`
5. Create tests at `tests/{resource}.test.ts`

Follow the project's existing patterns for error handling and response formatting.
SKILL

Copy
interface SkillTemplate {
  name: string;
  title: string;
  description: string;
  category: string;
  parameters: Parameter[];
  instructions: string;
  examples: Example[];
}

interface Parameter {
  name: string;
  type: 'string' | 'boolean' | 'number' | 'enum';
  required: boolean;
  default?: string;
  description: string;
  options?: string[];  // for enum type
}

interface Example {
  params: Record<string, string>;
  description: string;
}

class SkillStudio {
  private templates: Map<string, SkillTemplate> = new Map();

  createTemplate(config: Partial<SkillTemplate>): SkillTemplate {
    const template: SkillTemplate = {
      name: config.name || '',
      title: config.title || '',
      description: config.description || '',
      category: config.category || 'general',
      parameters: config.parameters || [],
      instructions: config.instructions || '',
      examples: config.examples || []
    };

    this.validateTemplate(template);
    this.templates.set(template.name, template);
    return template;
  }

  validateTemplate(template: SkillTemplate): void {
    if (!template.name) throw new Error('Template name required');
    if (!template.instructions) throw new Error('Instructions required');

    // Check for parameter references in instructions
    for (const param of template.parameters) {
      if (!template.instructions.includes(`{${param.name}}`)) {
        console.warn(`Parameter ${param.name} not referenced in instructions`);
      }
    }

    // Check for unreferenced placeholders
    const placeholders = template.instructions.match(/\{(\w+)\}/g) || [];
    for (const ph of placeholders) {
      const name = ph.slice(1, -1);
      if (!template.parameters.find(p => p.name === name)) {
        console.warn(`Placeholder {${name}} has no matching parameter`);
      }
    }
  }

  renderTemplate(name: string, params: Record<string, string>): string {
    const template = this.templates.get(name);
    if (!template) throw new Error(`Template ${name} not found`);

    // Apply defaults for missing params
    for (const param of template.parameters) {
      if (!(param.name in params) && param.default) {
        params[param.name] = param.default;
      }
      if (param.required && !(param.name in params)) {
        throw new Error(`Required parameter missing: ${param.name}`);
      }
    }

    let output = template.instructions;
    for (const [key, value] of Object.entries(params)) {
      output = output.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
    }
    return output;
  }

  exportToMarkdown(name: string): string {
    const t = this.templates.get(name);
    if (!t) throw new Error(`Template ${name} not found`);

    let md = `# ${t.title}\n\n${t.description}\n\n`;
    md += `## Parameters\n`;
    for (const p of t.parameters) {
      md += `- \`${p.name}\`: ${p.description}`;
      if (p.default) md += ` (default: ${p.default})`;
      if (p.required) md += ` *required*`;
      md += '\n';
    }
    md += `\n## Instructions\n${t.instructions}\n`;
    return md;
  }
}

Core Concepts

Skill Template Structure

Section	Purpose	Required
Title (H1)	Skill display name	Yes
Description	What the skill does	Yes
Parameters	Input variables with types	No
Prerequisites	Required project setup	No
Instructions	Step-by-step generation guide	Yes
Examples	Sample usage with expected output	Recommended
Notes	Edge cases and considerations	No

Parameter Types and Validation

Copy
const paramValidators = {
  string: (value: string, param: Parameter) => {
    if (param.required && !value) return 'Value required';
    return null;
  },
  boolean: (value: string) => {
    if (!['true', 'false'].includes(value)) return 'Must be true or false';
    return null;
  },
  number: (value: string) => {
    if (isNaN(Number(value))) return 'Must be a number';
    return null;
  },
  enum: (value: string, param: Parameter) => {
    if (param.options && !param.options.includes(value)) {
      return `Must be one of: ${param.options.join(', ')}`;
    }
    return null;
  }
};

Configuration

Option	Description	Default
template_dir	Directory for skill templates	".claude/skills"
output_format	Template output: markdown, yaml	"markdown"
validate_on_save	Validate templates when saved	true
parameter_delimiter	Variable placeholder format	"{}"
require_examples	Require at least one example	false
max_parameters	Maximum parameters per template	10
category_dirs	Organize by category subdirectories	true
export_format	Export format for sharing	"markdown"

Best Practices

1. Write instructions as clear step-by-step directives rather than vague descriptions; each step should describe exactly one action with the specific file path, naming convention, and pattern to follow
2. Provide at least one complete example showing the expected output for a specific set of parameter values so skill users can verify the output matches their expectations before applying it to real code
3. Use descriptive parameter names that explain their purpose in the context of the generated output — resourceName is clearer than name, and includeAuth is more informative than auth
4. Test templates against the actual project structure before sharing with the team; a template that references non-existent directories or incompatible patterns creates confusion and wastes time
5. Keep skill templates under version control alongside the project code so they evolve with architectural changes and remain compatible with the current codebase

Common Issues

Parameter values not substituting correctly: Placeholder syntax conflicts between the template engine and target code (e.g., JavaScript template literals use ${} which looks similar to {param}). Use a distinct delimiter pattern and escape literal braces in the template.

Generated code not matching project conventions: Templates created from scratch may not follow the existing project's naming, structure, or style conventions. Base templates on actual project files by copying an existing file and replacing specific values with parameters.

Templates becoming stale after refactoring: When the project structure changes (new directory layout, renamed modules), existing templates break silently. Add a smoke test that renders each template with example parameters and checks that referenced paths exist in the project.