⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
skill-creator
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.
// RATINGS
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- Usesopenclaw agent --jsonto run test queriesimprove_description.py- Uses OpenClaw agent to analyze failures and suggest improvementsgenerate_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
| Tool | Purpose |
|---|---|
run_eval.py | Test skill triggering accuracy |
improve_description.py | Optimize skill descriptions programmatically |
generate_report.py | Generate HTML reports from eval results |
package_skill.py | Package skills for distribution |
quick_validate.py | Quick validation before packaging |
test_skill.sh | Single query testing |
batch_test_skill.sh | Batch testing from JSON files |
Documentation
| Resource | Description |
|---|---|
SKILL.md | Main skill documentation |
tool-library.md | Tool usage guide |
schemas.md | JSON schemas for evals |
TESTING.md | Comprehensive testing guide |
Workflow
- Capture Intent - What does the user want to accomplish?
- Write SKILL.md - Create the skill structure
- Create Test Cases - Define evals in
evals/evals_example.json - Run Tests - Use
run_eval.pyto evaluate - Review Results - Use
generate_review.pyor analyze manually - Improve - Use
improve_description.pyif trigger rate is low - Package - Use
package_skill.pyto 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
- test_skill.sh - Single query testing
- batch_test_skill.sh - Batch testing from JSON
Contributing
See CONTRIBUTING.md for contribution guidelines.
License
See LICENSE.txt for license information.
Related Resources
- Prompt Optimization Framework - Advanced prompt engineering techniques
- Tool Library - Complete tool reference guide
- Schemas - JSON schema definitions
// 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 intREADME.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/elliottzhao-skill-creator-openclaw.md