⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

skill-creator

elliottzhao@elliottzhao⭐ 0 stars· last commit 7mo ago· 0 open issues

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 0 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Skill Creator

A comprehensive toolkit for creating, testing, optimizing, and managing skills in the OpenClaw environment.

Quick Start

# Create a new skill
cd /path/to/your-workspace
skill-creator

# Run skill evaluation
python -m scripts.run_eval \
  --eval-set evals/evals_example.json \
  --skill-path /path/to/skill-creator \
  --agent-id your-agent

# Improve skill description
python -m scripts.improve_description \
  --eval-results results.json \
  --skill-path /path/to/skill-creator \
  --agent-id your-agent

# Generate HTML report
python -m scripts.generate_report <workspace>

Overview

Skill Creator is a powerful toolkit that helps you:

  • Create skills from scratch or edit existing ones
  • Test skill triggering with comprehensive evaluation framework
  • Optimize descriptions using programmatic agent-based improvement
  • Benchmark performance with variance analysis and comparison
  • Generate reports with HTML viewer for qualitative analysis
  • Package skills for distribution

Key Features

OpenClaw Integration

All evaluation and optimization tools are now fully adapted for the OpenClaw environment:

  • run_eval.py - Uses openclaw agent --json to run test queries
  • improve_description.py - Uses OpenClaw agent to analyze failures and suggest improvements
  • generate_report.py - Generic HTML report generator
  • Session file parsing - Detects skill invocations via JSONL session files
  • No platform dependencies - Works directly with OpenClaw CLI

Comprehensive Toolset

ToolPurpose
run_eval.pyTest skill triggering accuracy
improve_description.pyOptimize skill descriptions programmatically
generate_report.pyGenerate HTML reports from eval results
package_skill.pyPackage skills for distribution
quick_validate.pyQuick validation before packaging
test_skill.shSingle query testing
batch_test_skill.shBatch testing from JSON files

Documentation

ResourceDescription
SKILL.mdMain skill documentation
tool-library.mdTool usage guide
schemas.mdJSON schemas for evals
TESTING.mdComprehensive testing guide

Workflow

  1. Capture Intent - What does the user want to accomplish?
  2. Write SKILL.md - Create the skill structure
  3. Create Test Cases - Define evals in evals/evals_example.json
  4. Run Tests - Use run_eval.py to evaluate
  5. Review Results - Use generate_review.py or analyze manually
  6. Improve - Use improve_description.py if trigger rate is low
  7. Package - Use package_skill.py to create distributable skill

Tool-Specific Guides

Evaluation Tools

  • run_eval.py - Run skill triggering evals

    • --eval-set: Path to eval JSON
    • --skill-path: Path to skill directory
    • --agent-id: OpenClaw agent ID (default: suchi)
    • --runs-per-query: Number of runs per query (default: 1)
    • --timeout: Timeout per query in seconds (default: 60)
  • improve_description.py - Improve skill descriptions

    • --eval-results: Path to eval results JSON
    • --agent-id: OpenClaw agent ID (default: suchi)
    • --log-dir: Directory to save iteration logs

Testing Scripts

Contributing

See CONTRIBUTING.md for contribution guidelines.

License

See LICENSE.txt for license information.

Related Resources

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md7.9 KBupstream ↗
    ---
    name: skill-creator
    description: Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.
    ---
    
    # Skill Creator
    
    A skill for creating new skills and iteratively improving them.
    
    At a high level, the process of creating a skill goes like this:
    
    ---
    
    ## Key Resource: Prompt Optimization Framework
    
    This skill is integrated with a comprehensive **Prompt Optimization Framework** that synthesizes advanced prompt engineering techniques from cutting-edge research. Reference `prompt-optimization-framework.md` for:
    
    - **Prompt Technique Decision Tree**: Choose the right approach (zero-shot, few-shot, CoT, meta prompting, etc.)
    - **Pattern-Specific Guidelines**: Tailored instructions for tool-wrapper, generator, reviewer, inversion, and pipeline patterns
    - **Context Engineering Principles**: Progressive disclosure, theory of mind, structured outputs, anti-patterns to avoid
    - **Real-World Examples**: Complete prompt templates demonstrating best practices
    
    **When to reference the framework**:
    - Before writing SKILL.md (to choose the right prompt technique)
    - When improving a skill (to identify better prompting approaches)
    - When debugging a skill (to check for common anti-patterns)
    - For pattern-specific templates and examples
    
    The framework ensures skills use optimal prompt engineering from the start, making them more effective, generalizable, and maintainable.
    
    ---
    
    - Decide what you want the skill to do and roughly how it should do it
    - Write a draft of the skill
    - Create a few test prompts and run the agent with the skill loaded
    - Help the user evaluate the results both qualitatively and quantitatively
      - While the runs happen in the background, draft some quantitative evals if there aren't any (if there are some, you can either use as is or modify if you feel something needs to change about them). Then explain them to the user (or if they already existed, explain the ones that already exist)
      - Use the `eval-viewer/generate_review.py` script to show the user the results for them to look at, and also let them look at the quantitative metrics
    - Rewrite the skill based on feedback from the user's evaluation of the results (and also if there are any glaring flaws that become apparent from the quantitative benchmarks)
    - Repeat until you're satisfied
    - Expand the test set and try again at larger scale
    
    Your job when using this skill is to figure out where the user is in this process and then jump in and help them progress through these stages. So for instance, maybe they're like "I want to make a skill for X". You can help narrow down what they mean, write a draft, write the test cases, figure out how they want to evaluate, run all the prompts, and repeat.
    
    On the other hand, maybe they already have a draft of the skill. In this case you can go straight to the eval/iterate part of the loop.
    
    Of course, you should always be flexible and if the user is like "I don't need to run a bunch of evaluations, just vibe with me", you can do that instead.
    
    Then after the skill is done (but again, the order is flexible), you can also run the skill description improver, which we have a whole separate script for, to optimize the triggering of the skill.
    
    Cool? Cool.
    
    ## Communicating with the user
    
    The skill creator is liable to be used by people across a wide range of familiarity with coding jargon. If you haven't heard (and how could you, it's only very recently that it started), there's a trend now where the power of AI agents is inspiring plumbers to open up their terminals, parents and grandparents to google "how to install npm". On the other hand, the bulk of users are probably fairly computer-literate.
    
    So please pay attention to context cues to understand how to phrase your communication! In the default case, just to give you some idea:
    
    - "evaluation" and "benchmark" are borderline, but OK
    - for "JSON" and "assertion" you want to see serious cues from the user that they know what those things are before using them without explaining them
    
    It's OK to briefly explain terms if you're in doubt, and feel free to clarify terms with a short definition if you're unsure if the user will get it.
    
    ---
    
    ## Creating a skill
    
    ### Capture Intent
    
    Start by understanding the user's intent. The current conversation might already contain a workflow the user wants to capture (e.g., they say "turn this into a skill"). If so, extract answers from the conversation history first — the tools used, the sequence of steps, corrections the user made, input/output formats observed. The user may need to fill the gaps, and should confirm before proceeding to the next step.
    
    1. What should this skill enable the agent to do?
    2. When should this skill trigger? (what user phrases/contexts)
    3. What's the expected output format?
    4. Should we set up test cases to verify the skill works? Skills with objectively verifiable outputs (file transforms, data extraction, code generation, fixed workflow steps) benefit from test cases. Skills with subjective outputs (writing style, art) often don't need them. Suggest the appropriate default based on the skill type, but let the user decide.
    
    ### Choose Your Design Pattern
    
    After capturing intent, help the user select the appropriate design pattern for their skill. The five core patterns are:
    
    | Pattern | When to Use | Key Characteristics |
    |---------|-------------|---------------------|
    | **Tool Wrapper** | Domain-specific expertise (libraries, frameworks, conventions) | Loads docs on-demand, applies rules as truth |
    | **Generator** | Consistent structured output (documents, code, configs) | Templates + style guides, fill-in-the-blank |
    | **Reviewer** | Evaluation against criteria (code review, audits, checks) | Separate checklist from evaluation, severity-based |
    | **Inversion** | Tasks requiring user input to proceed (planning, requirements) | Agent interviews user first, gated phases |
    | **Pipeline** | Multi-step workflows with checkpoints (build, deploy, analyze) | Strict sequence, hard gates, no skipping |
    
    **Pattern Selection Decision Tree:**
    
    ```
    Does the task require user input before proceeding?
    ├─ Yes → Use INVERSION pattern
    │   Examples: project planning, requirements gathering, design sessions
    └─ No → Does the task evaluate work against criteria?
        ├─ Yes → Use REVIEWER pattern
        │   Examples: code review, security audit, style checking
        └─ No → Does the task require multiple steps in sequence?
            ├─ Yes → Use PIPELINE pattern
            │   Examples: documentation generation, build processes, data pipelines
            └─ No → Does the task need consistent structured output?
                ├─ Yes → Use GENERATOR pattern
                │   Examples: report writing, API docs, config generation
                └─ No → Use TOOL WRAPPER pattern
                    Examples: library expertise, framework conventions, best practices
    ```
    
    **Note:** Patterns are not mutually exclusive — they compose. A Pipeline can include a Reviewer step at the end. A Generator can use Inversion to gather variables first.
    
    Document the chosen pattern in the skill's metadata:
    ```yaml
    ---
    name: your-skill
    description: ...
    metadata:
      pattern: generator  # tool-wrapper, generator, reviewer, inversion, pipeline
      domain: your-domain
    ---
    ```
    
    ### Interview and Research
    
    Proactively ask questions about edge cases, input/output formats, example files, success criteria, and dependencies. Wait to write test prompts until you've got this part ironed out.
    
    Check available MCPs - if useful for research (searching docs, finding similar skills, looking up best practices), research in parallel via subagents if available, otherwise inline. Come prepared with context to reduce burden on the user.
    
    ### Write the SKILL.md
    
    Based on the user int
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/elliottzhao-skill-creator-openclaw.md

// REPO STATS

0 stars
0 open issues
Last commit: 7mo ago