meta-skill-creator

Meta Skill Creator

Task Objective

This Skill is used to: create, manage, and optimize other skills, providing full lifecycle management from basic definitions to advanced composition
Capabilities include: structured skill generation, introspection analysis, modular composition, iterative optimization, version control, safety alignment checks
Trigger conditions: the user needs to create a new skill, analyze an existing skill, compose multiple skills, optimize skill design, or manage skill versions

Dependency description: the dependency packages and versions required by the scripts
```
pyyaml>=6.0
```

Standard process:
1. Requirements analysis and context understanding
  - The agent analyzes user goals, history, and constraints
  - Combine with references/skill-standards.md to determine the skill type and specification
2. Basic capability execution
  - Generate skill definition: call scripts/generate_skill.py to generate a standardized YAML front matter and structure
  - Format validation: call scripts/validate_skill.py to check format compliance and safety rules
3. Advanced capability execution (as needed)
  - Skill composition: call scripts/compose_skills.py to implement skill nesting, reuse, and concatenation
  - Version management: call scripts/version_skill.py to handle skill version iteration and difference comparison
  - Introspection analysis: the agent analyzes skill capability boundaries, optimization points, and composition possibilities
4. Optimization and iteration
  - The agent adjusts the skill design based on feedback, referring to references/composition-patterns.md
  - Execute safety alignment checks, referring to references/security-guidelines.md
Optional branches:
- When creating a basic skill: execute steps 1-2
- When composing multiple skills: execute steps 1-3 (including composition)
- When optimizing an existing skill: execute steps 1-2-4 -When iterating versions: execute steps 1-2-3 (version management)-4

Required scripts:
- scripts/generate_skill.py (Purpose and parameters: generate a standardized skill definition, accepting parameters such as skill_name, description, capabilities, dependencies)
- scripts/validate_skill.py (Purpose and parameters: validate skill format and safety rules, accepting parameters such as skill_definition, check_security=True)
- scripts/compose_skills.py (Purpose and parameters: compose multiple skills, accepting parameters such as skills_list, composition_mode)
- scripts/version_skill.py (Purpose and parameters: manage skill versions, accepting parameters such as action, skill_path, target_version)
Domain references:
- references/skill-standards.md (When to read: refer to format specifications when generating skill definitions)
- references/composition-patterns.md (When to read: refer to composition patterns when composing skills)
- references/security-guidelines.md (When to read: refer to alignment rules when validating skill safety)

Make full use of the agent's language understanding and reasoning capabilities for requirements analysis, creative design, and introspection evaluation
Call scripts only for technical operations involving structured data processing, format validation, composition logic, etc.
Content such as skill descriptions, process design, and optimization suggestions is generated directly by the agent and does not require script processing
When composing skills, pay attention to module boundaries to avoid capability coupling
Version management follows semantic versioning specifications and records the impact scope of each change

Basic Creation: The user says "create a data cleaning skill". The agent analyzes the requirements → calls generate_skill.py to generate a definition → the agent supplements the process description.
Skill Composition: The user says "combine data processing and report generation". The agent analyzes the composition strategy → calls compose_skills.py → the agent adjusts the interface definition.
Version Iteration: The user says "add a logging feature to this skill". The agent designs the change → calls version_skill.py to record the version → generates a new definition.