Advanced Skill Platform

A meta-skill for creating, managing, and organizing Claude Code skills — reusable prompt templates that automate common development workflows and coding patterns.

When to Use

Choose Advanced Skill Platform when:

• Creating reusable Claude Code skill templates for team workflows
• Organizing and categorizing a library of development automation skills
• Building parameterized skill templates with variable substitution
• Managing skill dependencies and composing multi-step skill pipelines

Consider alternatives when:

• Writing a one-off prompt — just type it directly without creating a skill
• Building full automation pipelines — use CI/CD tools or task runners
• Creating project documentation — use standard documentation tools

Quick Start

Copy
# Create a skill directory structure
mkdir -p .claude/skills/{templates,generators,reviewers}

# Create a basic skill file
cat > .claude/skills/templates/component.md << 'EOF'
# Component Generator

Create a new React component with the following structure:

## Parameters
- `name`: Component name (PascalCase)
- `type`: functional | class (default: functional)
- `withTests`: true | false (default: true)

## Template
Generate these files:
1. `src/components/{name}/{name}.tsx` - Component implementation
2. `src/components/{name}/{name}.test.tsx` - Test file
3. `src/components/{name}/index.ts` - Barrel export
EOF

Copy
const fs = require('fs');
const path = require('path');

class SkillManager {
  constructor(skillsDir = '.claude/skills') {
    this.skillsDir = skillsDir;
    this.skills = new Map();
  }

  loadSkills() {
    const categories = fs.readdirSync(this.skillsDir, { withFileTypes: true })
      .filter(d => d.isDirectory())
      .map(d => d.name);

    for (const category of categories) {
      const catPath = path.join(this.skillsDir, category);
      const files = fs.readdirSync(catPath).filter(f => f.endsWith('.md'));

      for (const file of files) {
        const content = fs.readFileSync(path.join(catPath, file), 'utf-8');
        const name = path.basename(file, '.md');
        this.skills.set(name, {
          name,
          category,
          content,
          metadata: this.parseMetadata(content)
        });
      }
    }
  }

  parseMetadata(content) {
    const titleMatch = content.match(/^# (.+)/m);
    const paramMatch = content.match(/## Parameters\n([\s\S]*?)(?=\n##)/);
    return {
      title: titleMatch ? titleMatch[1] : 'Untitled',
      parameters: paramMatch ? this.extractParams(paramMatch[1]) : []
    };
  }

  extractParams(paramBlock) {
    const params = [];
    const lines = paramBlock.split('\n').filter(l => l.startsWith('- '));
    for (const line of lines) {
      const match = line.match(/- `(\w+)`:\s*(.+)/);
      if (match) {
        params.push({ name: match[1], description: match[2] });
      }
    }
    return params;
  }

  executeSkill(name, params = {}) {
    const skill = this.skills.get(name);
    if (!skill) throw new Error(`Skill not found: ${name}`);

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

  listSkills(category = null) {
    const results = [];
    for (const [name, skill] of this.skills) {
      if (!category || skill.category === category) {
        results.push({
          name,
          category: skill.category,
          title: skill.metadata.title,
          params: skill.metadata.parameters.length
        });
      }
    }
    return results;
  }
}

Core Concepts

Skill Categories

Category	Purpose	Examples
Templates	Code generation patterns	Component, API endpoint, test file
Generators	Multi-file project scaffolding	Feature module, microservice
Reviewers	Code review checklists	Security review, performance audit
Converters	Code transformation	JS to TS, REST to GraphQL
Analyzers	Code analysis patterns	Dependency graph, complexity report
Fixers	Automated code fixes	Lint fix, import organization

Composable Skill Pipeline

Copy
class SkillPipeline {
  constructor() {
    this.steps = [];
  }

  addStep(skillName, params = {}, condition = null) {
    this.steps.push({ skillName, params, condition });
    return this;
  }

  async execute(context, skillManager) {
    const results = [];
    for (const step of this.steps) {
      if (step.condition && !step.condition(context)) {
        continue;
      }
      const output = skillManager.executeSkill(step.skillName, {
        ...step.params,
        ...context
      });
      results.push({ skill: step.skillName, output });
      context.previousOutput = output;
    }
    return results;
  }
}

// Usage: create a feature generation pipeline
const pipeline = new SkillPipeline()
  .addStep('component', { name: 'UserProfile', withTests: true })
  .addStep('api-endpoint', { method: 'GET', path: '/users/:id' })
  .addStep('integration-test', { endpoint: '/users/:id' });

Configuration

Option	Description	Default
skills_directory	Root directory for skill files	".claude/skills"
file_format	Skill file format: md, yaml, json	"md"
parameter_syntax	Variable placeholder syntax	"{paramName}"
enable_composition	Allow skill pipelines	true
validate_params	Validate required parameters	true
default_category	Default category for new skills	"templates"
max_skill_size	Maximum skill file size (bytes)	50000
cache_parsed_skills	Cache parsed skill metadata	true

Best Practices

1. Keep skills focused on a single responsibility — a skill that generates a component should not also create the API endpoint; compose focused skills in pipelines instead of building monolithic templates
2. Document parameters clearly with types, defaults, and examples so team members can use skills without reading the implementation; the parameter section is the user interface of your skill
3. Include example outputs in the skill file so users can preview what the skill generates before running it and verify the output matches their expectations
4. Version your skills alongside code in the .claude/skills directory so they evolve with the codebase and are always compatible with the current project structure
5. Start with concrete, team-specific skills rather than trying to build generic ones; a skill that generates components matching your exact project conventions is more valuable than a generic component generator

Common Issues

Parameter substitution conflicts: Curly braces {param} in skill templates can conflict with code syntax in languages like JavaScript or template literals. Use a unique delimiter like {{param}} or <%param%> that does not collide with the target language's syntax.

Skills becoming outdated as project evolves: Skills reference specific file paths, naming conventions, and architectural patterns that change over time. Review skills quarterly, test them against the current codebase, and update paths and patterns to match the latest project structure.

Over-engineering skill abstractions: Building a skill framework with inheritance, conditionals, and complex logic defeats the purpose of simple reusable templates. Keep skills as straightforward markdown instructions that Claude can follow; complexity should be in the output, not in the skill specification itself.