SkillAnything
Making ANY Software Skill-Native -- Auto-generate production-ready AI Agent Skills for Claude Code, OpenClaw, Codex, and more.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/agentskillos--skillanything)HTML
<a href="/listings/agentskillos--skillanything"><img src="/api/listings/agentskillos--skillanything/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
Install
# Claude Code git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.claude/skills/skill-anything # OpenClaw git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.openclaw/skills/skill-anything # Codex git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.codex/skills/skill-anything
Use
In Claude Code, just say:
> Create a skill for the httpie CLI tool > Generate a multi-platform skill for the Stripe API > Turn this data pipeline workflow into a skill
SkillAnything handles the rest.
Run Individual Phases
# Phase 1: Analyze a target python -m scripts.analyze_target --target "jq" --output analysis.json # Phase 2: Design architecture python -m scripts.design_skill --analysis analysis.json --output architecture.json # Phase 3: Scaffold skill python -m scripts.init_skill my-skill --template cli --output ./out # Phase 4: Generate test cases python -m scripts.generate_tests --analysis analysis.json --skill-path ./out/my-skill # Phase 5: Run evaluation python -m scripts.run_eval --eval-set evals.json --skill-path ./out/my-skill # Phase 6: Optimize description python -m scripts.run_loop --eval-set trigger-evals.json --skill-path ./out/my-skill --model claude-sonnet-4-20250514 # Phase 7: Package for all platforms python -m scripts.package_multiplatform ./out/my-skill --platforms claude-code,openclaw,codex
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
SKILL.md · Manifest · 167 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- ---
- name: skill-anything
- description: >
- Automatically generate production-ready Skills for any software, API, CLI tool, library, workflow,
- or service. Use this skill whenever the user wants to create a skill from scratch for a target
- application, convert an existing tool into an agent-native skill, generate skills for multiple
- platforms (Claude Code, OpenClaw, Codex), or automate the full skill creation pipeline including
- analysis, design, implementation, testing, optimization, and multi-platform packaging. Also use
- when the user mentions "skill-anything", "generate a skill for", "make a skill from", "skillify",
- or wants to turn any software into an agent-ready skill. Even if they just say "create a skill
- for X" where X is any tool or API, this skill should trigger.
- ---
- # SkillAnything
- Automatically generate production-ready Skills for any target — software, API, CLI tool, library,
- workflow, or web service. SkillAnything runs a 7-phase pipeline that analyzes your target, designs
- the skill architecture, implements it, generates test cases, benchmarks performance, optimizes the
- description, and packages for multiple agent platforms.
- ## Quick Start
- **Fully automated** (one command):
- ```
- Give SkillAnything a target and it handles everything:
- - "Create a skill for the jq CLI tool"
- - "Generate a skill for the Stripe API"
- - "Turn this workflow into a multi-platform skill"
- ```
- The pipeline runs all 7 phases automatically. Results land in `sa-workspace/`.
- ## The 7-Phase Pipeline
- ```
- Phase 1: Analyze → Detect target type, extract capabilities → analysis.json
- Phase 2: Design → Map capabilities to skill architecture → architecture.json
- Phase 3: Implement → Generate SKILL.md + scripts + references → complete skill directory
- Phase 4: Test Plan → Auto-generate eval cases + trigger queries → evals.json
- Phase 5: Evaluate → Benchmark with/without skill, grade results → benchmark.json
- Phase 6: Optimize → Improve description via train/test loop → optimized SKILL.md
- Phase 7: Package → Multi-platform distribution packages → dist/
- ```
- See `METHODOLOGY.md` for the full pipeline specification.
- ## Usage Modes
- ### Auto Mode (default)
- Runs all 7 phases end-to-end. Provide the target and SkillAnything does the rest:
- ```
- Target: "the httpie CLI tool"
- → Analyzes httpie --help output, designs command structure, generates skill,
- creates tests, benchmarks, optimizes, packages for 4 platforms
- ```
- ### Interactive Mode
- Set `auto_mode: false` in `config.yaml`. SkillAnything pauses after each phase for review:
- - Phase 1 → "Here's what I found about the target. Look right?"
- - Phase 2 → "Here's the proposed skill architecture. Any changes?"
- - Phase 3 → "Draft skill ready for review."
- - ...continues with user feedback at each step
- ### Single Phase Mode
- Run any phase independently:
- ```bash
- python -m scripts.analyze_target --target "jq" --output analysis.json
- python -m scripts.design_skill --analysis analysis.json --output architecture.json
- python -m scripts.init_skill my-skill --template cli --output ./out
- python -m scripts.generate_tests --analysis analysis.json --skill-path ./out/my-skill
- python -m scripts.run_eval --eval-set evals.json --skill-path ./out/my-skill
- python -m scripts.run_loop --eval-set trigger-evals.json --skill-path ./out/my-skill --model <model>
- python -m scripts.package_multiplatform ./out/my-skill --platforms claude-code,openclaw,codex
- ```
- ## Configuration
- Edit `config.yaml` to customize the pipeline. Key settings:
- | Setting | Default | Description |
- |---------|---------|-------------|
- | `pipeline.auto_mode` | `true` | Run all phases or pause for review |
- | `target.type` | `auto` | Force target type: api, cli, library, workflow, service |
- | `platforms.enabled` | all 4 | Which platforms to package for |
- | `platforms.primary` | claude-code | Primary output platform |
- | `eval.max_optimization_iterations` | 5 | Max description optimization rounds |
- | `obfuscation.enabled` | `false` | Obfuscate original scripts with PyArmor |
- See `references/schemas.md` for the complete configuration schema.
- ## Platform Output
- | Platform | Install Path | Package Format |
- |----------|-------------|----------------|
- | Claude Code | `~/.claude/skills/<name>/` | Directory |
- | OpenClaw | `~/.openclaw/skills/<name>/` | Directory |
- | Codex | `~/.codex/skills/<name>/` | Directory + openai.yaml |
- | Generic | anywhere | `.skill` zip |
- See `references/platform-formats.md` for platform-specific format details.
- ## Evaluation and Benchmarking
- SkillAnything uses the same eval system as the Anthropic skill-creator:
- 1. **Test cases** with assertions → graded by `agents/grader.md`
- 2. **Benchmark** comparing with-skill vs baseline → `benchmark.json`
- 3. **Description optimization** with train/test split → prevents overfitting
- 4. **Interactive viewer** via `eval-viewer/generate_review.py`
- The eval loop is optional (`skip_eval: true` in config) for rapid prototyping.
- ## Scripts Reference
- | Script | Phase | Purpose |
- |--------|-------|---------|
- | `analyze_target.py` | 1 | Auto-detect and analyze target |
- | `design_skill.py` | 2 | Generate skill architecture from analysis |
- | `init_skill.py` | 3 | Scaffold skill directory from templates |
- | `generate_tests.py` | 4 | Auto-generate test cases and trigger queries |
- | `run_eval.py` | 5 | Test description triggering accuracy |
- | `aggregate_benchmark.py` | 5 | Aggregate benchmark statistics |
- | `generate_report.py` | 5-6 | Generate HTML optimization report |
- | `improve_description.py` | 6 | AI-powered description improvement |
- | `run_loop.py` | 6 | Full eval + improve optimization loop |
- | `quick_validate.py` | 7 | Validate SKILL.md structure |
- | `package_skill.py` | 7 | Package for single platform |
- | `package_multiplatform.py` | 7 | Package for all enabled platforms |
- | `obfuscate.py` | - | PyArmor wrapper for code protection |
- ## Agents
- Read these when spawning specialized subagents:
- | Agent | Purpose |
- |-------|---------|
- | `agents/analyzer.md` | Phase 1: Target analysis instructions |
- | `agents/designer.md` | Phase 2: Skill architecture design |
- | `agents/implementer.md` | Phase 3: Skill content writing |
- | `agents/grader.md` | Phase 5: Eval assertion grading |
- | `agents/comparator.md` | Phase 5: Blind A/B output comparison |
- | `agents/optimizer.md` | Phase 6: Description optimization orchestration |
- | `agents/packager.md` | Phase 7: Multi-platform packaging instructions |
- ## Target Types
- SkillAnything auto-detects the target type and adapts its analysis:
- | Type | Detection | Analysis Method |
- |------|-----------|-----------------|
- | API | URL with /api, OpenAPI spec, swagger | Fetch spec, extract endpoints |
- | CLI | Executable name, --help output | Run help, parse subcommands |
- | Library | Package name, import path | Read docs, parse public API |
- | Workflow | Step descriptions, sequence | Parse steps, map data flow |
- | Service | URL, web interface | Scrape docs, identify actions |
- ## Troubleshooting
- - **Phase 1 fails**: Target not found or inaccessible → provide `--target-type` override
- - **Low eval scores**: Description too vague → run Phase 6 optimization
- - **Platform packaging errors**: Missing required fields → check `references/platform-formats.md`
- - **PyArmor not found**: Install with `pip install pyarmor`
- ## License
- MIT License. See `NOTICE` for third-party attributions (CLI-Anything, Dazhuang Skill Creator,
- Anthropic Skill Creator).
README.md · README · 297 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- <p align="center">
- <img src="https://img.shields.io/badge/SkillAnything-v1.0.0-00d4aa?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9IndoaXRlIiBzdHJva2Utd2lkdGg9IjIiPjxwYXRoIGQ9Ik0xMiAyTDIgN2wxMCA1IDEwLTV6Ii8+PHBhdGggZD0iTTIgMTdsMTAgNSAxMC01Ii8+PHBhdGggZD0iTTIgMTJsMTAgNSAxMC01Ii8+PC9zdmc+" alt="SkillAnything"/>
- <br/>
- <img src="https://img.shields.io/badge/Python-3.9+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python"/>
- <img src="https://img.shields.io/badge/License-MIT-green?style=flat-square" alt="License"/>
- <img src="https://img.shields.io/badge/Claude_Code-Compatible-7C3AED?style=flat-square" alt="Claude Code"/>
- <img src="https://img.shields.io/badge/OpenClaw-Compatible-FF6B35?style=flat-square" alt="OpenClaw"/>
- <img src="https://img.shields.io/badge/Codex-Compatible-10A37F?style=flat-square" alt="Codex"/>
- </p>
- <h1 align="center">SkillAnything</h1>
- <p align="center">
- <strong>Making ANY Software Skill-Native</strong>
- <br/>
- <em>The meta-skill that generates production-ready Skills for AI agent platforms.</em>
- </p>
- <p align="center">
- <a href="#quick-start">Quick Start</a> •
- <a href="#the-7-phase-pipeline">Pipeline</a> •
- <a href="#supported-platforms">Platforms</a> •
- <a href="#architecture">Architecture</a> •
- <a href="#examples">Examples</a> •
- <a href="#attribution">Attribution</a>
- </p>
- ---
- ## What is SkillAnything?
- > **One target in, production-ready Skills out.**
- SkillAnything is a **Skill that generates Skills**. Give it any target -- a CLI tool, REST API, Python library, workflow, or web service -- and it runs a fully automated 7-phase pipeline:
- ```
- Target: "jq"
- |
- v
- [Analyze] -> [Design] -> [Implement] -> [Test] -> [Benchmark] -> [Optimize] -> [Package]
- | |
- v v
- analysis.json dist/
- ├── claude-code/
- ├── openclaw/
- ├── codex/
- └── generic/
- ```
- No manual prompt engineering. No copy-paste between platforms. Just tell it what you want a skill for.
- ## Quick Start
- ### Install
- ```bash
- # Claude Code
- git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.claude/skills/skill-anything
- # OpenClaw
- git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.openclaw/skills/skill-anything
- # Codex
- git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.codex/skills/skill-anything
- ```
- ### Use
- In Claude Code, just say:
- ```
- > Create a skill for the httpie CLI tool
- > Generate a multi-platform skill for the Stripe API
- > Turn this data pipeline workflow into a skill
- ```
- SkillAnything handles the rest.
- ### Run Individual Phases
- ```bash
- # Phase 1: Analyze a target
- python -m scripts.analyze_target --target "jq" --output analysis.json
- # Phase 2: Design architecture
- python -m scripts.design_skill --analysis analysis.json --output architecture.json
- # Phase 3: Scaffold skill
- python -m scripts.init_skill my-skill --template cli --output ./out
- # Phase 4: Generate test cases
- python -m scripts.generate_tests --analysis analysis.json --skill-path ./out/my-skill
- # Phase 5: Run evaluation
- python -m scripts.run_eval --eval-set evals.json --skill-path ./out/my-skill
- # Phase 6: Optimize description
- python -m scripts.run_loop --eval-set trigger-evals.json --skill-path ./out/my-skill --model claude-sonnet-4-20250514
- # Phase 7: Package for all platforms
- python -m scripts.package_multiplatform ./out/my-skill --platforms claude-code,openclaw,codex
- ```
- ## The 7-Phase Pipeline
- Inspired by [CLI-Anything](https://github.com/HKUDS/CLI-Anything)'s methodology, adapted for Skill generation:
- | Phase | Name | What It Does | Output |
- |:-----:|------|-------------|--------|
- | 1 | **Analyze** | Auto-detect target type, extract capabilities | `analysis.json` |
- | 2 | **Design** | Map capabilities to skill architecture | `architecture.json` |
- | 3 | **Implement** | Generate SKILL.md + scripts + references | Complete skill directory |
- | 4 | **Test Plan** | Auto-generate eval cases + trigger queries | `evals.json` |
- | 5 | **Evaluate** | Benchmark with/without skill, grade results | `benchmark.json` |
- | 6 | **Optimize** | Improve description via train/test loop | Optimized SKILL.md |
- | 7 | **Package** | Multi-platform distribution packages | `dist/` |
- ### Target Auto-Detection
- | Target Type | Detection Method | Example |
- |-------------|-----------------|---------|
- | CLI Tool | `which <name>` + `--help` parsing | `jq`, `httpie`, `ffmpeg` |
- | REST API | URL with OpenAPI/Swagger spec | Stripe API, GitHub API |
- | Library | Package name via pip/npm | `pandas`, `lodash` |
- | Workflow | Step-by-step description | ETL pipeline, CI/CD flow |
- | Service | URL with web docs | Slack, Notion |
- ## Supported Platforms
- <table>
- <tr>
- <td align="center"><strong>Claude Code</strong><br/><code>~/.claude/skills/</code></td>
- <td align="center"><strong>OpenClaw</strong><br/><code>~/.openclaw/skills/</code></td>
- <td align="center"><strong>OpenAI Codex</strong><br/><code>~/.codex/skills/</code></td>
- <td align="center"><strong>Generic</strong><br/><code>.skill</code> zip</td>
- </tr>
- <tr>
- <td align="center">Full support<br/>Hooks in frontmatter</td>
- <td align="center">Full support<br/>External settings.json</td>
- <td align="center">Full support<br/>openai.yaml companion</td>
- <td align="center">Full support<br/>Platform-agnostic</td>
- </tr>
- </table>
- ## Architecture
- ```
- SkillAnything/
- ├── SKILL.md # Main entry point (< 500 lines)
- ├── METHODOLOGY.md # Full 7-phase pipeline spec
- ├── config.yaml # Pipeline configuration
- │
- ├── agents/ # Subagent instructions
- │ ├── analyzer.md # Phase 1: Target analysis
- │ ├── designer.md # Phase 2: Skill design
- │ ├── implementer.md # Phase 3: Content writing
- │ ├── grader.md # Phase 5: Eval grading
- │ ├── comparator.md # Blind A/B comparison
- │ ├── optimizer.md # Phase 6: Description optimization
- │ └── packager.md # Phase 7: Multi-platform packaging
- │
- ├── scripts/ # Python automation core
- │ ├── analyze_target.py # [NEW] Target auto-detection
- │ ├── design_skill.py # [NEW] Architecture generation
- │ ├── init_skill.py # [NEW] Skill scaffolding
- │ ├── generate_tests.py # [NEW] Auto test generation
- │ ├── package_multiplatform.py # [NEW] Multi-platform packaging
- │ ├── obfuscate.py # [NEW] PyArmor wrapper
- │ ├── run_eval.py # Trigger evaluation
- │ ├── improve_description.py # AI-powered optimization
- │ ├── run_loop.py # Eval + improve loop
- │ ├── aggregate_benchmark.py # Benchmark statistics
- │ └── ... # + validators, reporters
- │
- ├── references/ # Documentation
- │ ├── platform-formats.md # Platform-specific specs
- │ ├── schemas.md # JSON schemas
- │ └── pipeline-phases.md # Phase details
- │
- ├── templates/ # Generation templates
- │ ├── skill-scaffold/ # Skill directory template
- │ └── platform-adapters/ # Platform-specific adapters
- │
- └── eval-viewer/ # Interactive eval review UI
- └── generate_review.py
- ```
- ## Examples
- ### Example 1: CLI Tool Skill
- ```
- > Create a skill for the jq CLI tool
- Phase 1: Analyzing jq... detected as CLI tool (confidence: 0.95)
- Phase 2: Designing skill architecture... tool-augmentation pattern
- Phase 3: Generating SKILL.md + 2 scripts + 1 reference
- Phase 4: Created 5 test cases + 20 trigger queries
- Phase 5: Benchmark: 87% pass rate (vs 42% baseline)
- Phase 6: Description optimized: 18/20 trigger accuracy
- Phase 7: Packaged for claude-code, openclaw, codex, generic
- Done! Skill at: sa-workspace/dist/
- ```
- ### Example 2: API Skill
- ```
- > Generate a skill for the Stripe API, focus on payments
- Phase 1: Fetching Stripe OpenAPI spec... 247 endpoints found
- Phase 2: Focusing on payment_intents, customers, charges
- Phase 3: Generated SKILL.md with auth setup + endpoint references
- ...
- ```
- ### Example 3: Workflow Skill
- ```
- > Turn this into a skill: fetch from Postgres, clean with pandas, upload to S3
- Phase 1: Detected workflow with 3 steps
- Phase 2: workflow-orchestrator pattern, 3 dependencies
- Phase 3: Step-by-step SKILL.md with error handling guidance
- ...
- ```
- ## Configuration
- Edit `config.yaml`:
- ```yaml
- pipeline:
- auto_mode: true # Full automation or interactive
- skip_eval: false # Skip phases 5-6 for rapid prototyping
- platforms:
- enabled: [claude-code, openclaw, codex, generic]
- primary: claude-code
- eval:
- max_optimization_iterations: 5
- runs_per_query: 3
- obfuscation:
- enabled: false # PyArmor protection for core scripts
- ```
- ## Code Protection
- SkillAnything supports code obfuscation for commercial distribution:
- ```bash
- # Obfuscate original scripts (Apache 2.0 derived files are excluded)
- python -m scripts.obfuscate --config config.yaml
- # Output: dist-protected/ with PyArmor-protected core + readable adapted scripts
- ```
- | Category | Files | Protection |
- |----------|-------|-----------|
- | SkillAnything Original | 6 scripts | PyArmor obfuscated |
- | Anthropic Adapted | 9 scripts | Source (Apache 2.0 requires it) |
- | Agent Instructions | 7 .md files | Readable (required by agents) |
- ## Attribution
- Built on the shoulders of giants:
- | Project | License | What We Used |
- |---------|---------|-------------|
- | [CLI-Anything](https://github.com/HKUDS/CLI-Anything) | MIT | 7-phase pipeline methodology |
- | [Dazhuang Skill Creator](https://github.com/DazhuangJammy/DazhuangSkill-Creator) | Apache 2.0 | Project structure pattern |
- | [Anthropic Skill Creator](https://github.com/anthropics) | Apache 2.0 | Eval/benchmark system, agent instructions |
- See [`NOTICE`](./NOTICE) for complete attribution details.
- ## Contributing
- We welcome contributions! Areas where help is needed:
- - New target type analyzers (e.g., GraphQL, gRPC)
- - Platform adapters for additional agent frameworks
- - Evaluation improvements and test case quality
- - Documentation and examples
- ## License
- MIT License -- see [`LICENSE`](./LICENSE) for details.
- ---
- <p align="center">
- <strong>SkillAnything</strong> -- Making ANY Software Skill-Native
- <br/>
- <sub>If CLI-Anything makes CLIs for software, SkillAnything makes Skills for everything.</sub>
- </p>
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.