Skip to content
Back to search

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.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/agentskillos--skillanything/badge.svg)](/listings/agentskillos--skillanything)

HTML

<a href="/listings/agentskillos--skillanything"><img src="/api/listings/agentskillos--skillanything/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

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)

  1. ---
  2. name: skill-anything
  3. description: >
  4. Automatically generate production-ready Skills for any software, API, CLI tool, library, workflow,
  5. or service. Use this skill whenever the user wants to create a skill from scratch for a target
  6. application, convert an existing tool into an agent-native skill, generate skills for multiple
  7. platforms (Claude Code, OpenClaw, Codex), or automate the full skill creation pipeline including
  8. analysis, design, implementation, testing, optimization, and multi-platform packaging. Also use
  9. when the user mentions "skill-anything", "generate a skill for", "make a skill from", "skillify",
  10. or wants to turn any software into an agent-ready skill. Even if they just say "create a skill
  11. for X" where X is any tool or API, this skill should trigger.
  12. ---
  13. # SkillAnything
  14. Automatically generate production-ready Skills for any target — software, API, CLI tool, library,
  15. workflow, or web service. SkillAnything runs a 7-phase pipeline that analyzes your target, designs
  16. the skill architecture, implements it, generates test cases, benchmarks performance, optimizes the
  17. description, and packages for multiple agent platforms.
  18. ## Quick Start
  19. **Fully automated** (one command):
  20. ```
  21. Give SkillAnything a target and it handles everything:
  22. - "Create a skill for the jq CLI tool"
  23. - "Generate a skill for the Stripe API"
  24. - "Turn this workflow into a multi-platform skill"
  25. ```
  26. The pipeline runs all 7 phases automatically. Results land in `sa-workspace/`.
  27. ## The 7-Phase Pipeline
  28. ```
  29. Phase 1: Analyze → Detect target type, extract capabilities → analysis.json
  30. Phase 2: Design → Map capabilities to skill architecture → architecture.json
  31. Phase 3: Implement → Generate SKILL.md + scripts + references → complete skill directory
  32. Phase 4: Test Plan → Auto-generate eval cases + trigger queries → evals.json
  33. Phase 5: Evaluate → Benchmark with/without skill, grade results → benchmark.json
  34. Phase 6: Optimize → Improve description via train/test loop → optimized SKILL.md
  35. Phase 7: Package → Multi-platform distribution packages → dist/
  36. ```
  37. See `METHODOLOGY.md` for the full pipeline specification.
  38. ## Usage Modes
  39. ### Auto Mode (default)
  40. Runs all 7 phases end-to-end. Provide the target and SkillAnything does the rest:
  41. ```
  42. Target: "the httpie CLI tool"
  43. → Analyzes httpie --help output, designs command structure, generates skill,
  44. creates tests, benchmarks, optimizes, packages for 4 platforms
  45. ```
  46. ### Interactive Mode
  47. Set `auto_mode: false` in `config.yaml`. SkillAnything pauses after each phase for review:
  48. - Phase 1 → "Here's what I found about the target. Look right?"
  49. - Phase 2 → "Here's the proposed skill architecture. Any changes?"
  50. - Phase 3 → "Draft skill ready for review."
  51. - ...continues with user feedback at each step
  52. ### Single Phase Mode
  53. Run any phase independently:
  54. ```bash
  55. python -m scripts.analyze_target --target "jq" --output analysis.json
  56. python -m scripts.design_skill --analysis analysis.json --output architecture.json
  57. python -m scripts.init_skill my-skill --template cli --output ./out
  58. python -m scripts.generate_tests --analysis analysis.json --skill-path ./out/my-skill
  59. python -m scripts.run_eval --eval-set evals.json --skill-path ./out/my-skill
  60. python -m scripts.run_loop --eval-set trigger-evals.json --skill-path ./out/my-skill --model <model>
  61. python -m scripts.package_multiplatform ./out/my-skill --platforms claude-code,openclaw,codex
  62. ```
  63. ## Configuration
  64. Edit `config.yaml` to customize the pipeline. Key settings:
  65. | Setting | Default | Description |
  66. |---------|---------|-------------|
  67. | `pipeline.auto_mode` | `true` | Run all phases or pause for review |
  68. | `target.type` | `auto` | Force target type: api, cli, library, workflow, service |
  69. | `platforms.enabled` | all 4 | Which platforms to package for |
  70. | `platforms.primary` | claude-code | Primary output platform |
  71. | `eval.max_optimization_iterations` | 5 | Max description optimization rounds |
  72. | `obfuscation.enabled` | `false` | Obfuscate original scripts with PyArmor |
  73. See `references/schemas.md` for the complete configuration schema.
  74. ## Platform Output
  75. | Platform | Install Path | Package Format |
  76. |----------|-------------|----------------|
  77. | Claude Code | `~/.claude/skills/<name>/` | Directory |
  78. | OpenClaw | `~/.openclaw/skills/<name>/` | Directory |
  79. | Codex | `~/.codex/skills/<name>/` | Directory + openai.yaml |
  80. | Generic | anywhere | `.skill` zip |
  81. See `references/platform-formats.md` for platform-specific format details.
  82. ## Evaluation and Benchmarking
  83. SkillAnything uses the same eval system as the Anthropic skill-creator:
  84. 1. **Test cases** with assertions → graded by `agents/grader.md`
  85. 2. **Benchmark** comparing with-skill vs baseline → `benchmark.json`
  86. 3. **Description optimization** with train/test split → prevents overfitting
  87. 4. **Interactive viewer** via `eval-viewer/generate_review.py`
  88. The eval loop is optional (`skip_eval: true` in config) for rapid prototyping.
  89. ## Scripts Reference
  90. | Script | Phase | Purpose |
  91. |--------|-------|---------|
  92. | `analyze_target.py` | 1 | Auto-detect and analyze target |
  93. | `design_skill.py` | 2 | Generate skill architecture from analysis |
  94. | `init_skill.py` | 3 | Scaffold skill directory from templates |
  95. | `generate_tests.py` | 4 | Auto-generate test cases and trigger queries |
  96. | `run_eval.py` | 5 | Test description triggering accuracy |
  97. | `aggregate_benchmark.py` | 5 | Aggregate benchmark statistics |
  98. | `generate_report.py` | 5-6 | Generate HTML optimization report |
  99. | `improve_description.py` | 6 | AI-powered description improvement |
  100. | `run_loop.py` | 6 | Full eval + improve optimization loop |
  101. | `quick_validate.py` | 7 | Validate SKILL.md structure |
  102. | `package_skill.py` | 7 | Package for single platform |
  103. | `package_multiplatform.py` | 7 | Package for all enabled platforms |
  104. | `obfuscate.py` | - | PyArmor wrapper for code protection |
  105. ## Agents
  106. Read these when spawning specialized subagents:
  107. | Agent | Purpose |
  108. |-------|---------|
  109. | `agents/analyzer.md` | Phase 1: Target analysis instructions |
  110. | `agents/designer.md` | Phase 2: Skill architecture design |
  111. | `agents/implementer.md` | Phase 3: Skill content writing |
  112. | `agents/grader.md` | Phase 5: Eval assertion grading |
  113. | `agents/comparator.md` | Phase 5: Blind A/B output comparison |
  114. | `agents/optimizer.md` | Phase 6: Description optimization orchestration |
  115. | `agents/packager.md` | Phase 7: Multi-platform packaging instructions |
  116. ## Target Types
  117. SkillAnything auto-detects the target type and adapts its analysis:
  118. | Type | Detection | Analysis Method |
  119. |------|-----------|-----------------|
  120. | API | URL with /api, OpenAPI spec, swagger | Fetch spec, extract endpoints |
  121. | CLI | Executable name, --help output | Run help, parse subcommands |
  122. | Library | Package name, import path | Read docs, parse public API |
  123. | Workflow | Step descriptions, sequence | Parse steps, map data flow |
  124. | Service | URL, web interface | Scrape docs, identify actions |
  125. ## Troubleshooting
  126. - **Phase 1 fails**: Target not found or inaccessible → provide `--target-type` override
  127. - **Low eval scores**: Description too vague → run Phase 6 optimization
  128. - **Platform packaging errors**: Missing required fields → check `references/platform-formats.md`
  129. - **PyArmor not found**: Install with `pip install pyarmor`
  130. ## License
  131. MIT License. See `NOTICE` for third-party attributions (CLI-Anything, Dazhuang Skill Creator,
  132. 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)

  1. <p align="center">
  2. <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"/>
  3. <br/>
  4. <img src="https://img.shields.io/badge/Python-3.9+-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python"/>
  5. <img src="https://img.shields.io/badge/License-MIT-green?style=flat-square" alt="License"/>
  6. <img src="https://img.shields.io/badge/Claude_Code-Compatible-7C3AED?style=flat-square" alt="Claude Code"/>
  7. <img src="https://img.shields.io/badge/OpenClaw-Compatible-FF6B35?style=flat-square" alt="OpenClaw"/>
  8. <img src="https://img.shields.io/badge/Codex-Compatible-10A37F?style=flat-square" alt="Codex"/>
  9. </p>
  10. <h1 align="center">SkillAnything</h1>
  11. <p align="center">
  12. <strong>Making ANY Software Skill-Native</strong>
  13. <br/>
  14. <em>The meta-skill that generates production-ready Skills for AI agent platforms.</em>
  15. </p>
  16. <p align="center">
  17. <a href="#quick-start">Quick Start</a> &bull;
  18. <a href="#the-7-phase-pipeline">Pipeline</a> &bull;
  19. <a href="#supported-platforms">Platforms</a> &bull;
  20. <a href="#architecture">Architecture</a> &bull;
  21. <a href="#examples">Examples</a> &bull;
  22. <a href="#attribution">Attribution</a>
  23. </p>
  24. ---
  25. ## What is SkillAnything?
  26. > **One target in, production-ready Skills out.**
  27. 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:
  28. ```
  29. Target: "jq"
  30. |
  31. v
  32. [Analyze] -> [Design] -> [Implement] -> [Test] -> [Benchmark] -> [Optimize] -> [Package]
  33. | |
  34. v v
  35. analysis.json dist/
  36. ├── claude-code/
  37. ├── openclaw/
  38. ├── codex/
  39. └── generic/
  40. ```
  41. No manual prompt engineering. No copy-paste between platforms. Just tell it what you want a skill for.
  42. ## Quick Start
  43. ### Install
  44. ```bash
  45. # Claude Code
  46. git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.claude/skills/skill-anything
  47. # OpenClaw
  48. git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.openclaw/skills/skill-anything
  49. # Codex
  50. git clone https://github.com/AgentSkillOS/SkillAnything.git ~/.codex/skills/skill-anything
  51. ```
  52. ### Use
  53. In Claude Code, just say:
  54. ```
  55. > Create a skill for the httpie CLI tool
  56. > Generate a multi-platform skill for the Stripe API
  57. > Turn this data pipeline workflow into a skill
  58. ```
  59. SkillAnything handles the rest.
  60. ### Run Individual Phases
  61. ```bash
  62. # Phase 1: Analyze a target
  63. python -m scripts.analyze_target --target "jq" --output analysis.json
  64. # Phase 2: Design architecture
  65. python -m scripts.design_skill --analysis analysis.json --output architecture.json
  66. # Phase 3: Scaffold skill
  67. python -m scripts.init_skill my-skill --template cli --output ./out
  68. # Phase 4: Generate test cases
  69. python -m scripts.generate_tests --analysis analysis.json --skill-path ./out/my-skill
  70. # Phase 5: Run evaluation
  71. python -m scripts.run_eval --eval-set evals.json --skill-path ./out/my-skill
  72. # Phase 6: Optimize description
  73. python -m scripts.run_loop --eval-set trigger-evals.json --skill-path ./out/my-skill --model claude-sonnet-4-20250514
  74. # Phase 7: Package for all platforms
  75. python -m scripts.package_multiplatform ./out/my-skill --platforms claude-code,openclaw,codex
  76. ```
  77. ## The 7-Phase Pipeline
  78. Inspired by [CLI-Anything](https://github.com/HKUDS/CLI-Anything)'s methodology, adapted for Skill generation:
  79. | Phase | Name | What It Does | Output |
  80. |:-----:|------|-------------|--------|
  81. | 1 | **Analyze** | Auto-detect target type, extract capabilities | `analysis.json` |
  82. | 2 | **Design** | Map capabilities to skill architecture | `architecture.json` |
  83. | 3 | **Implement** | Generate SKILL.md + scripts + references | Complete skill directory |
  84. | 4 | **Test Plan** | Auto-generate eval cases + trigger queries | `evals.json` |
  85. | 5 | **Evaluate** | Benchmark with/without skill, grade results | `benchmark.json` |
  86. | 6 | **Optimize** | Improve description via train/test loop | Optimized SKILL.md |
  87. | 7 | **Package** | Multi-platform distribution packages | `dist/` |
  88. ### Target Auto-Detection
  89. | Target Type | Detection Method | Example |
  90. |-------------|-----------------|---------|
  91. | CLI Tool | `which <name>` + `--help` parsing | `jq`, `httpie`, `ffmpeg` |
  92. | REST API | URL with OpenAPI/Swagger spec | Stripe API, GitHub API |
  93. | Library | Package name via pip/npm | `pandas`, `lodash` |
  94. | Workflow | Step-by-step description | ETL pipeline, CI/CD flow |
  95. | Service | URL with web docs | Slack, Notion |
  96. ## Supported Platforms
  97. <table>
  98. <tr>
  99. <td align="center"><strong>Claude Code</strong><br/><code>~/.claude/skills/</code></td>
  100. <td align="center"><strong>OpenClaw</strong><br/><code>~/.openclaw/skills/</code></td>
  101. <td align="center"><strong>OpenAI Codex</strong><br/><code>~/.codex/skills/</code></td>
  102. <td align="center"><strong>Generic</strong><br/><code>.skill</code> zip</td>
  103. </tr>
  104. <tr>
  105. <td align="center">Full support<br/>Hooks in frontmatter</td>
  106. <td align="center">Full support<br/>External settings.json</td>
  107. <td align="center">Full support<br/>openai.yaml companion</td>
  108. <td align="center">Full support<br/>Platform-agnostic</td>
  109. </tr>
  110. </table>
  111. ## Architecture
  112. ```
  113. SkillAnything/
  114. ├── SKILL.md # Main entry point (< 500 lines)
  115. ├── METHODOLOGY.md # Full 7-phase pipeline spec
  116. ├── config.yaml # Pipeline configuration
  117. │
  118. ├── agents/ # Subagent instructions
  119. │ ├── analyzer.md # Phase 1: Target analysis
  120. │ ├── designer.md # Phase 2: Skill design
  121. │ ├── implementer.md # Phase 3: Content writing
  122. │ ├── grader.md # Phase 5: Eval grading
  123. │ ├── comparator.md # Blind A/B comparison
  124. │ ├── optimizer.md # Phase 6: Description optimization
  125. │ └── packager.md # Phase 7: Multi-platform packaging
  126. │
  127. ├── scripts/ # Python automation core
  128. │ ├── analyze_target.py # [NEW] Target auto-detection
  129. │ ├── design_skill.py # [NEW] Architecture generation
  130. │ ├── init_skill.py # [NEW] Skill scaffolding
  131. │ ├── generate_tests.py # [NEW] Auto test generation
  132. │ ├── package_multiplatform.py # [NEW] Multi-platform packaging
  133. │ ├── obfuscate.py # [NEW] PyArmor wrapper
  134. │ ├── run_eval.py # Trigger evaluation
  135. │ ├── improve_description.py # AI-powered optimization
  136. │ ├── run_loop.py # Eval + improve loop
  137. │ ├── aggregate_benchmark.py # Benchmark statistics
  138. │ └── ... # + validators, reporters
  139. │
  140. ├── references/ # Documentation
  141. │ ├── platform-formats.md # Platform-specific specs
  142. │ ├── schemas.md # JSON schemas
  143. │ └── pipeline-phases.md # Phase details
  144. │
  145. ├── templates/ # Generation templates
  146. │ ├── skill-scaffold/ # Skill directory template
  147. │ └── platform-adapters/ # Platform-specific adapters
  148. │
  149. └── eval-viewer/ # Interactive eval review UI
  150. └── generate_review.py
  151. ```
  152. ## Examples
  153. ### Example 1: CLI Tool Skill
  154. ```
  155. > Create a skill for the jq CLI tool
  156. Phase 1: Analyzing jq... detected as CLI tool (confidence: 0.95)
  157. Phase 2: Designing skill architecture... tool-augmentation pattern
  158. Phase 3: Generating SKILL.md + 2 scripts + 1 reference
  159. Phase 4: Created 5 test cases + 20 trigger queries
  160. Phase 5: Benchmark: 87% pass rate (vs 42% baseline)
  161. Phase 6: Description optimized: 18/20 trigger accuracy
  162. Phase 7: Packaged for claude-code, openclaw, codex, generic
  163. Done! Skill at: sa-workspace/dist/
  164. ```
  165. ### Example 2: API Skill
  166. ```
  167. > Generate a skill for the Stripe API, focus on payments
  168. Phase 1: Fetching Stripe OpenAPI spec... 247 endpoints found
  169. Phase 2: Focusing on payment_intents, customers, charges
  170. Phase 3: Generated SKILL.md with auth setup + endpoint references
  171. ...
  172. ```
  173. ### Example 3: Workflow Skill
  174. ```
  175. > Turn this into a skill: fetch from Postgres, clean with pandas, upload to S3
  176. Phase 1: Detected workflow with 3 steps
  177. Phase 2: workflow-orchestrator pattern, 3 dependencies
  178. Phase 3: Step-by-step SKILL.md with error handling guidance
  179. ...
  180. ```
  181. ## Configuration
  182. Edit `config.yaml`:
  183. ```yaml
  184. pipeline:
  185. auto_mode: true # Full automation or interactive
  186. skip_eval: false # Skip phases 5-6 for rapid prototyping
  187. platforms:
  188. enabled: [claude-code, openclaw, codex, generic]
  189. primary: claude-code
  190. eval:
  191. max_optimization_iterations: 5
  192. runs_per_query: 3
  193. obfuscation:
  194. enabled: false # PyArmor protection for core scripts
  195. ```
  196. ## Code Protection
  197. SkillAnything supports code obfuscation for commercial distribution:
  198. ```bash
  199. # Obfuscate original scripts (Apache 2.0 derived files are excluded)
  200. python -m scripts.obfuscate --config config.yaml
  201. # Output: dist-protected/ with PyArmor-protected core + readable adapted scripts
  202. ```
  203. | Category | Files | Protection |
  204. |----------|-------|-----------|
  205. | SkillAnything Original | 6 scripts | PyArmor obfuscated |
  206. | Anthropic Adapted | 9 scripts | Source (Apache 2.0 requires it) |
  207. | Agent Instructions | 7 .md files | Readable (required by agents) |
  208. ## Attribution
  209. Built on the shoulders of giants:
  210. | Project | License | What We Used |
  211. |---------|---------|-------------|
  212. | [CLI-Anything](https://github.com/HKUDS/CLI-Anything) | MIT | 7-phase pipeline methodology |
  213. | [Dazhuang Skill Creator](https://github.com/DazhuangJammy/DazhuangSkill-Creator) | Apache 2.0 | Project structure pattern |
  214. | [Anthropic Skill Creator](https://github.com/anthropics) | Apache 2.0 | Eval/benchmark system, agent instructions |
  215. See [`NOTICE`](./NOTICE) for complete attribution details.
  216. ## Contributing
  217. We welcome contributions! Areas where help is needed:
  218. - New target type analyzers (e.g., GraphQL, gRPC)
  219. - Platform adapters for additional agent frameworks
  220. - Evaluation improvements and test case quality
  221. - Documentation and examples
  222. ## License
  223. MIT License -- see [`LICENSE`](./LICENSE) for details.
  224. ---
  225. <p align="center">
  226. <strong>SkillAnything</strong> -- Making ANY Software Skill-Native
  227. <br/>
  228. <sub>If CLI-Anything makes CLIs for software, SkillAnything makes Skills for everything.</sub>
  229. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.