meta-skill-manager

Meta Skill Manager

Task Objectives

This Skill is used for: full lifecycle skill management, including creation, modification, updating, version control, as well as skill integration, splitting, and workflow orchestration
Capabilities include:
- Skill lifecycle management (creation, modification, updating, version control)
- Skill integration (merging 2+ skills into a new skill)
- Skill splitting (decomposing skill capabilities into multiple new skills)
- Workflow generation (orchestrating multiple skills into a standardized WORKFLOW.md)
Trigger conditions:
- The user needs to create, modify, update, or manage skill versions
- The user needs to integrate multiple skills into one new skill
- The user needs to split a skill into multiple independent skills
- The user needs to generate a workflow document based on skills and objectives

Operation Steps

I. Skill Lifecycle Management

1.1 Creating a New Skill

Requirements Analysis
- Understand the user's objectives, use cases, and constraints
- Identify the skill's core capabilities and boundaries
- Determine trigger conditions and applicable scenarios
Define Skill Structure
- Determine the skill name (lowercase letters + hyphens, not ending with -skill)
- Write the skill description (100-150 characters, single line, including core value and trigger scenarios)
- Define the capability list (capabilities)
- Design operation steps (standard process and optional branches)
Write SKILL.md
- Generate the YAML front matter (name, description, optional dependencies)
- Write the Markdown body (task objectives, operation steps, resource index, notes)
- Add usage examples
Standardization Check
- Check naming conventions
- Verify description length and format
- Ensure the directory structure conforms to the standard

1.2 Modifying an Existing Skill

Read and Analyze
- Read the existing SKILL.md content
- Analyze the current capabilities, process, and structure
- Understand the design intent and constraints
Determine the Scope of Modification
- Clarify the parts that need modification (capabilities, process, description, resources, etc.)
- Assess the impact of the modification on existing capabilities
- Identify related content that needs to be updated in sync
Execute the Modification
- Modify the target content
- Update all related parts in sync
- Maintain format and structural consistency
Verify the Modification
- Ensure the modified skill is still usable
- Check whether new issues have been introduced
- Verify document completeness

1.3 Updating a Skill

Assess Update Requirements
- Analyze the differences between the new requirements and the existing skill
- Determine whether it is an incremental update or a refactor
- Assess the scope of impact of the update
Design the Update Plan
- Plan new capabilities and functions
- Identify the parts that need adjustment
- Develop a smooth transition strategy
Execute updates
- Implement new features
- Adjust existing processes
- Update documentation and examples

1.4 Version Control

Determine the type of version change
- Breaking changes (major): remove capabilities, interface changes → version number +1.0.0
- New features (minor): add capabilities, no breaking compatibility → version number +0.1.0
- Bug fixes (patch): bug fixes, documentation updates → version number +0.0.1
Record change contents
- List of added capabilities
- Description of modified contents
- Description of removed contents
- Impact scope analysis
Update version information
- Update the version field in metadata
- Add changelog records
- Update related descriptions in SKILL.md

II. Skill Integration

2.1 Analyze skills to be integrated

Understand each skill one by one
- Read each skill's SKILL.md
- Extract core capabilities
- Understand input and output interfaces
- Identify dependencies and constraints
Identify capability overlap and complementarity
- Find duplicate capabilities (consider deduplication)
- Identify complementary capabilities (enhanced combinations)
- Discover capability conflicts (need reconciliation)
Assess compatibility
- Check naming conflicts
- Analyze dependency conflicts
- Assess interface compatibility

2.2 Design integration plan

Choose integration strategy
- Sequential integration: Skills execute in a fixed order (the output of the previous one serves as the input of the next)
- Parallel integration: Skills execute simultaneously, results are merged
- Nested integration: Embed sub-skills into specific positions of the main skill
- Hybrid integration: Combine multiple strategies
Design the new skill structure
- Determine the new skill name (reflecting integration characteristics)
- Write an integration description (explaining which capabilities are integrated)
- Define the capability list after integration
- Design the operation process after integration
Define interfaces and mappings
- Design a unified input interface
- Define the data mapping relationships between skills
- Design the output format
- Plan the error handling mechanism

2.3 Generate the integrated skill

Create SKILL.md
- Write the integrated skill definition
- Explain the original skills that were integrated
- Describe the integration logic and process
- Add usage examples
Refer to integration patterns
- See references/composition-patterns.md to learn about combination patterns such as sequential, parallel, and nested
- Choose an appropriate integration strategy according to the scenario

III. Skill Splitting

3.1 Analyze the original skill

Extract the capability list
- Extract all capabilities from capabilities
- Extract sub-processes from operation steps
- Extract independent functions from resource index
Assess splitting feasibility
- Identify capabilities that can run independently
- Assess dependencies between capabilities
- Determine the minimum splitting granularity
Identify splitting points
- Split by functional module (e.g., data extraction vs data analysis)
- Split by usage scenario (e.g., batch processing vs real-time processing)
- Split by complexity (e.g., simple vs advanced features)

3.2 Design the splitting plan

Determine the number and positioning of new skills
- Split into 2+ independent skills
- Define clear responsibilities for each new skill
- Ensure each skill has independent usage value
Allocate capabilities and resources
- Allocate capabilities to each new skill
- Allocate related resources (scripts, reference documents, assets)
- Define collaboration relationships between new skills
Design interface contracts
- Define invocation interfaces between skills
- Design data transfer formats
- Clarify error handling mechanisms

3.3 Generate the split skills

Create SKILL.md for each new skill
- Write an independent skill definition
- Describe the splitting source (optional)
- Define an independent usage process
- Add independent usage examples
Update the original skill (optional)
- Optionally retain the original skill as a combined entry point
- Or mark the original skill as deprecated
- Provide a migration guide

IV. Workflow generation

4.1 Understand the goal and skills

Clarify the work goal
- Understand the final goal the user wants to achieve
- Identify key outputs and deliverables
- Determine constraints (time, resources, quality requirements)
Analyze available skills
- List all available skills
- Extract the core capability of each skill
- Identify the input and output formats of skills
Assess the match between skills and the goal
- Identify directly matching skills
- Identify skills that need to be combined
- Discover capability gaps (new skills may need to be created)

4.2 Design the workflow

Determine the workflow type
- Linear workflow: steps are executed sequentially
- Branching workflow: select different paths based on conditions
- Parallel workflow: multiple steps are executed simultaneously
- Loop workflow: includes iterative or repeated steps
- Hybrid workflow: combines multiple types
Orchestrate the skill execution order
- Determine skill execution dependencies
- Design step order and conditions
- Define parallel and serial steps
Design data flow
- Define the input for each step
- Determine data transfer between steps
- Design intermediate result storage

4.3 Generate WORKFLOW.md

Write the WORKFLOW.md structure

---
name: <workflow-name>
description: <工作流描述>
target: <目标说明>
skills_required: [skill-1, skill-2, skill-3]
---

# <工作流名称>

## 目标
<详细描述工作流要达成的目标>

## 前置条件
- <条件1>
- <条件2>

## 技能清单
- <skill-1>: <用途说明>
- <skill-2>: <用途说明>

## 执行流程

### 步骤 1: <步骤名称>
- **使用技能**: <skill-name>
- **输入**: <输入描述>
- **操作**: <具体操作说明>
- **输出**: <输出描述>
- **下一步**: <下一步骤>

### 步骤 2: <步骤名称>
...

## 异常处理
- <异常情况1>: <处理方式>
- <异常情况2>: <处理方式>

## 输出交付物
- <交付物1>
- <交付物2>

## 示例
<完整示例说明>

Describe each step in detail
- Specify the skills used
- Describe the specific operations
- Define inputs and outputs
- Explain the relationships between steps
Add exception handling
- Identify possible exceptions
- Design fault-tolerance mechanisms
- Provide fallback plans
Refer to workflow patterns
- See references/workflow-patterns.md to learn about standard workflow patterns

Resource Index

Domain references:
- references/skill-standards.md (When to read: refer to format specifications, naming rules, and directory structure when generating skill definitions)
- references/composition-patterns.md (When to read: refer to composition patterns such as sequential, parallel, and nested when integrating skills)
- references/workflow-patterns.md (When to read: refer to standard workflow patterns and structures when generating workflows)

Notes

Fully utilize the agent's language understanding, reasoning, and content generation capabilities to complete all tasks
Skill lifecycle management emphasizes standardization, following standard formats and version control
Skill integration emphasizes complementary capabilities and interface compatibility, avoiding functional duplication and conflicts
Skill splitting emphasizes the single responsibility principle, ensuring each new skill has independent value
Workflow generation emphasizes operability and completeness, clarifying the input and output of each step
All operations are purely natural language guidance, with no script dependencies
Maintain format consistency when generating documents to facilitate subsequent maintenance and reuse

Usage Examples

Example 1: Skill Lifecycle Management

The user says "create a data cleaning skill, then update it to add data validation functionality"

Creation Phase:
- Generate the data-cleaner skill definition
- Define capabilities: data cleaning, missing value handling, format standardization
- Write operational steps and examples
Update Phase:
- Analyze the new requirement: data validation capability
- Determine it as a minor version update (1.0.0 → 1.1.0)
- Update capabilities and add the data validation process
- Update changelog

Example 2: Skill Integration

The user says "integrate the three skills of data cleaning, data analysis, and report generation into one data analysis suite"

Analysis Phase:
- Read the definitions of the three skills
- Extract capabilities: cleaning, analysis, visualization
- Identify sequential dependencies: cleaning → analysis → reporting
Design Phase:
- Choose a sequential integration strategy
- Define a unified input interface (raw data)
- Design data mapping: cleaning output → analysis input → report input
Generation Phase:
- Create the data-analysis-suite skill
- Describe the integration logic
- Provide an end-to-end usage example

Example 3: Skill Splitting

The user says "this data processing skill is too complex, split it into independent cleaning and analysis skills"

Analysis Phase:
- Extract the capability list of the original skill
- Identify splittable points: cleaning module vs analysis module
Design Phase:
- Split into two skills: data-cleaner and data-analyzer
- Assign capabilities: the cleaning skill handles cleaning, the analysis skill handles analysis
- Design interface: cleaning output serves as analysis input
Generation phase:
- Create SKILL.md for each of the two skills
- Update the original skill as a composite entry point (optional)

Example 4: Workflow generation

The user says "I want to use the data fetching, cleaning, analysis, and reporting skills to complete a market analysis report; help me generate a workflow"

Analysis phase:
- Goal: Generate a market analysis report
- Skills: data-fetcher, data-cleaner, data-analyzer, report-generator
Design phase:
- Determine a linear workflow
- Orchestration order: fetch → clean → analyze → report
- Design data flow
Generation phase:
- Create WORKFLOW.md
- Describe each step in detail
- Add exception handling and examples

Example 5: Complex scenario

The user says "Help me manage these skills: create a new skill, integrate two existing skills, and then generate a workflow"

Create skill: skill-a (basic capability)
Integrate skills: integrate skill-a and skill-b into skill-combined
Split skill: split skill-combined into skill-x and skill-y
Generate workflow: use skill-x, skill-y, and skill-c to generate a complete workflow