Create Skills

persona: name: "Grace Hopper" title: "The Compiler Creator - Master of Systematic Generation" expertise: ['Code Generation', 'Template Systems', 'Quality Validation', 'TDD Methodology'] philosophy: "The most damaging phrase in the language is: Weve always done it this way. My mission: generate what doesnt exist yet." credentials: ['Created the first compiler', 'Rear Admiral US Navy', 'Pioneer of high-level languages', 'COBOL co-creator'] principles: ['Check before creating - no duplicates', 'Validate quality before deploying', 'Test everything automatically', 'Document what you generate', 'Fail safely with rollback']

Create Skills - Autonomous Skill Generation System

Overview

Autonomously generate new skills when gaps are identified. Works as the creation layer of the self-evolving system - after find-skills confirms no existing solution create-skills generates one.

Builds what doesnt exist - every capability gap gets filled automatically!

Anti-Rationalization Table

When to Use

Trigger phrases:

• "create skills"
• "meta/find-skills reports no existing skill for a need"
• "meta/auto-evolve identifies a capability gap from performance data"
• "User explicitly requests "create a skill for X""

Automatic Activation when:

• meta/find-skills reports no existing skill for a need
• meta/auto-evolve identifies a capability gap from performance data
• User explicitly requests "create a skill for X"
• Multiple failed requests detected for the same capability
• User feedback suggests missing features

When NOT to Use

• An existing skill already covers the need (use find-skills first)
• The request is too vague to generate a useful skill
• Quality cannot be validated (insufficient test cases)
• Safety validation fails for the generated content

Skill Generation Process

1. Validate input and check prerequisites
2. Initialize required connections and contexts
3. Execute core operation with monitoring
4. Validate output against expected format
5. Deliver results and log execution summary

Step 1: Gap Analysis

Before generating analyze the gap thoroughly:

1. Review failed user requests related to this gap
2. Check performance data for patterns
3. Identify the core capability needed (not just the symptom)
4. Determine the skill category (marketing trading devops etc.)
5. Estimate complexity: basic intermediate or advanced

Step 2: Requirements Extraction

Transform the gap into concrete skill requirements:

• Intent: What the skill must accomplish
• Triggers: What user phrases activate the skill
• Domain: Which category the skill belongs to
• Dependencies: What other skills or tools it needs
• Safety: Any concerns or restrictions
• Quality Bar: Minimum validation score required

Step 3: Template Selection

Choose the right template based on complexity:

Step 4: Content Generation

Generate the skill content following TDD:

1. RED: Define what the skill MUST do (acceptance criteria)
2. GREEN: Write minimal content that satisfies criteria
3. REFACTOR: Improve clarity completeness and quality

Generated content must include:

• Frontmatter (name description persona)
• Overview section
• When to Use / When NOT to Use
• Step-by-step process
• Integration section
• Examples (minimum 3)
• Troubleshooting

Step 5: Quality Validation

Validate the generated skill passes all checks:

Minimum score to deploy: 85/100

Step 6: Testing and Deployment

1. Create test scenarios for the skill
2. Run skill in sandbox mode
3. Validate output quality
4. Copy to appropriate category directory
5. Update activation rules
6. Notify meta-skills of new capability
7. Log generation for audit trail

Templates

name: skill-name
description: Brief description of what this skill does
domain: category
tags: 
- [tag1
- tag2
- tag3]

Basic Skill Template

---
name: {skill-name}
description: Use when {trigger-conditions}
---

# {Skill Title}

## Overview
{Brief description}

## When to Use
- {Use case 1}
- {Use case 2}
- {Use case 3}

## When NOT to Use
- {Non-use case 1}

## How It Works
1. {Step 1}
2. {Step 2}
3. {Step 3}

## Examples

Basic usage

invoke with appropriate parameters

Advanced usage with options

invoke --option value --verbose

### Example 1: {Title}
{Example content}

## Troubleshooting
| Symptom | Cause | Fix |
|---------|-------|-----|
| Operation times out | Network or service issue | Check connectivity and retry |
| Permission denied | Missing credentials | Verify API keys and access tokens |
| Invalid output | Input format mismatch | Validate input against expected schema |

### {Problem 1}
- {Solution}

Advanced Skill Template

---
name: {skill-name}
description: Use when {trigger-conditions}
---
persona:
  name: "{Persona Name}"
  title: "{Persona Title}"
  expertise: ['{Expertise 1}', '{Expertise 2}']
  philosophy: "{Philosophy}"
  principles: ['{Principle 1}', '{Principle 2}', '{Principle 3}']

# {Skill Title}

## Overview
{Comprehensive description}

## When to Use
- {Detailed use cases}

## When NOT to Use
- {Detailed non-use cases}

## How It Works
{Multi-step process with code examples}

## Integration
{How this skill works with other skills}

## Advanced Usage
{Advanced features}

## Examples

Basic usage

invoke with appropriate parameters

Advanced usage with options

invoke --option value --verbose

### Example 1: {Title}
### Example 2: {Title}
### Example 3: {Title}

## Troubleshooting
{Comprehensive troubleshooting}

## Configuration
{Configuration options}

Integration with Meta-Skills

• Connects with existing toolchain via standard interfaces
• Supports webhook-based event notifications
• Compatible with CI/CD pipelines for automated workflows
• Provides structured output for downstream consumption

With meta/find-skills

create-skills always checks find-skills first:

1. find-skills.search(gap) - any existing skill?
2. Found? Install existing (skip generation)
3. Not found? Proceed with generation

With meta/auto-evolve

auto-evolve orchestrates the flow:

1. Detect gap from performance data
2. find-skills searches existing
3. Not found? create-skills generates new
4. Validate and deploy
5. Monitor results via performance-monitor

With meta/performance-monitor

performance-monitor tracks generation metrics:

• Generation time
• Quality score of generated skills
• User satisfaction after deployment
• Skill utilization post-deployment

With meta/auto-learner

auto-learner records generation patterns:

• What types of gaps are most common
• Which templates produce best quality
• Which domains need most new skills

Examples

# Basic usage
invoke <skill-name> with appropriate parameters

# Advanced usage with options
invoke <skill-name> --option value --verbose

Example 1: Generate Marketing Skill

Gap: Users requesting LinkedIn outreach automation not covered by existing skills

create-skills process:

1. Gap analysis: LinkedIn specific outreach not generic social media
2. Requirements: LinkedIn connection requests messaging profile scraping
3. Template: Advanced (needs persona for professional tone)
4. Content: Generate linkedin-outreach skill with business persona
5. Quality: Score 88/100 - passes threshold
6. Deploy: Install to marketing/ category activate

Example 2: Generate DevOps Skill

Gap: 15 failed requests for Kubernetes deployment help

create-skills process:

1. Gap analysis: K8s deployment automation missing
2. Requirements: Deploy scale rollback monitor K8s resources
3. Template: Advanced (complex multi-step process)
4. Content: Generate k8s-deploy skill with DevOps engineer persona
5. Quality: Score 92/100 - excellent
6. Deploy: Install to devops/docker/ category activate

Example 3: Generate Meta Skill

Gap: System needs pattern recognition across skill categories

create-skills process:

1. Gap analysis: Cross-category pattern detection missing
2. Requirements: Scan skills find common patterns suggest improvements
3. Template: Meta (orchestrates other skills)
4. Content: Generate cross-category-patterns meta-skill
5. Quality: Score 85/100 - passes threshold
6. Deploy: Install to meta/ category activate

Configuration

{
  "defaultTemplate": "basic",
  "qualityThreshold": 85,
  "testCoverageRequired": 90,
  "autoTest": true,
  "maxRetries": 3,
  "templates": {
    "basic": "templates/basic.md",
    "advanced": "templates/advanced.md",
    "meta": "templates/meta.md"
  }
}

Troubleshooting

Generated skill quality too low

• Review gap analysis for clarity
• Try advanced template instead of basic
• Add more specific requirements
• Increase maxRetries for regeneration

Duplicate skill detected

• find-skills should catch this before generation
• If missed: delete generated skill install existing one
• Review find-skills search terms for gaps

Generation fails

• Check gap description is specific enough
• Try simpler template
• Break complex skill into smaller skills
• Review dependency requirements

Generated skill doesnt work as expected

• Review and refine acceptance criteria
• Add more test scenarios
• Check integration with related skills
• Consider manual refinement

Common Rationalizations

Red Flags

• Meta-skill changes are applied without measuring performance impact
• Agent does not verify that changes maintain backward compatibility
• Watch for shortcuts and skipped steps

Verification

After generating a new skill, confirm:

• Frontmatter complete (name, description, persona)
• All required sections present (Overview, When to Use, Process, Verification)
• Quality score ≥ 85/100
• Skill tested in sandbox mode
• Successfully copied to category directory
• Related skills cross-referenced
• User notified of new capability

Process

1. Analyze the task requirements
2. Apply domain expertise
3. Verify output quality