One tool to manage every AI agent's skills

Stop juggling skill directories across Claude Code, Codex, Cursor, Windsurf, and 10+ other AI agents.
agent-skill-manager (asm) gives you a single TUI and CLI to install, search, audit, and organize all your agent skills — everywhere.

Get Started in 30 Seconds →   |   Browse 2,800+ Skills Online →

🌐 ASM Catalog — Browse Skills in Your Browser

Don't want to install anything yet? Explore the full skill catalog online →

Search, filter by category or repo, and copy install commands — all from a single page. No signup, no backend, no tracking. Share filtered views via URL (e.g. ?q=code-review&cat=development).

Your AI agent skills are a mess

You use Claude Code at work, Codex for side projects, and OpenClaw for experiments. Each tool keeps skills in its own hidden directory with its own conventions. Here's what that looks like in practice:

• Skills scattered everywhere — ~/.claude/skills/, ~/.codex/skills/, ~/.openclaw/skills/, project-level .claude/skills/... you have the same skill installed three times and can't remember which version is where
• No visibility — there's no quick way to see what's installed, what's duplicated, or what's outdated across all your agents
• Installing is manual and risky — you clone repos, copy folders, hope the SKILL.md is valid, and pray you didn't just install something that exfiltrates your codebase

The more AI agents you use, the worse this gets. Every new tool adds another skill directory to babysit.

asm brings order to the chaos

agent-skill-manager is a single command that manages skills across every AI coding agent you use. One TUI. One CLI. Every agent.

• See everything at once — List, search, and filter skills across all providers and scopes from one dashboard. No more ls-ing through hidden directories.
• Install from GitHub in one command — asm install github:user/repo handles cloning, validation, and placement. Supports single-skill repos, multi-skill collections, subfolder URLs, and private repos via SSH.
• Catch problems before they bite — Built-in security scanning flags dangerous patterns (shell execution, network access, credential exposure, obfuscation) before you install. Duplicate audit finds and cleans redundant skills across providers.
• Create, test, and publish skills — Scaffold new skills with asm init, symlink them for live development with asm link, audit for security issues, verify metadata, and publish to the ASM Registry with a single command. See the full local dev workflow ↓
• Works with every major agent — 19 providers built-in: Claude Code, Codex, OpenClaw, Cursor, Windsurf, Cline, Roo Code, Continue, GitHub Copilot, Aider, OpenCode, Zed, Augment, Amp, Gemini CLI, Google Antigravity, Pi, Hermes, and a generic Agents provider. Add custom providers in seconds via config.
• Two interfaces, one tool — Full interactive TUI with keyboard navigation, search, and detail views. Or use the CLI with --json for scripting and automation.

asm stats — totals, disk usage, and per-provider breakdown at a glance

How it works

1. Install asm — one command via npm or curl
2. Run asm — it auto-discovers skills across all configured agent directories
3. Manage everything — install, search, inspect, audit, and uninstall skills from the TUI or CLI
4. Stay safe — security scan skills before installing, detect duplicates, and clean up with confidence

Start Managing Your Skills →

asm search code-review — finds installed skills and suggests new ones from indexed repos

Build, Test, and Ship Your Own Skills

asm isn't just for consuming skills — it's the complete toolkit for creating, developing, auditing, and testing skills locally before you share them.

1. Scaffold a new skill

Interactive mode — pick a target tool:

asm init my-skill

Scaffold directly into Claude Code:

asm init my-skill -p claude

Scaffold in a custom directory:

asm init my-skill --path ./skills

This creates a my-skill/SKILL.md with valid YAML frontmatter and a markdown template ready to fill in.

2. Develop with live reload via symlink

asm link creates a symlink from your local skill directory into an agent's skill folder. Because it's a symlink, every edit you make to the source is immediately visible to the agent — no reinstall needed.

Target a specific tool

# Link into Claude Code
asm link ./my-skill -p claude

# Link into Codex
asm link ./my-skill -p codex

# Interactive — pick the tool from a prompt
asm link ./my-skill

Link multiple skills at once

Pass several paths in a single command to link them all in one step:

asm link ./skill-a ./skill-b ./skill-c -p claude

You can also point at a folder that contains multiple skills (each in its own subdirectory with a SKILL.md):

# Link every skill found inside ./my-skills-folder
asm link ./my-skills-folder -p claude

Override the symlink name

asm link ./my-skill --name my-alias -p claude

Force-overwrite an existing symlink

asm link ./my-skill -p claude --force

Edit the source files — changes are reflected immediately in the agent. This is the fastest iteration loop for skill development.

3. Audit your skill for security issues

Audit an installed skill by name:

asm audit security my-skill

Audit a local directory:

asm audit security ./path/to/my-skill

Audit every installed skill:

asm audit security --all

The security scanner flags dangerous patterns — shell execution, network access, credential exposure, obfuscation, and external URLs — so you can catch problems before users install your skill.

4. Inspect and verify metadata

Check name, version, description, file count:

asm inspect my-skill

Machine-readable output for CI:

asm inspect my-skill --json

5. Test the install flow locally

Once your skill is on GitHub, verify that end users can install it cleanly.

Install your own skill as a user would:

asm install github:you/awesome-skill

Install to a specific tool:

asm install github:you/awesome-skill -p claude

Install a specific skill from a multi-skill repo:

asm install github:you/skills --path skills/awesome-skill

Force reinstall to test upgrades:

asm install github:you/awesome-skill --force

Non-interactive install (useful for CI):

asm install github:you/awesome-skill -p claude --yes --json

This catches issues that local development misses — broken repo structure, missing files, invalid frontmatter in a clean install context.

6. Publish to the ASM Registry

Once your skill is ready and on GitHub, submit it to the ASM Registry so anyone can install it by name:

asm publish ./my-skill

This runs a security audit, generates a signed manifest, forks the registry, and opens a pull request automatically. Once merged, your skill is globally discoverable:

# Anyone can install it by name — no URL needed
asm install my-skill

Preview what the manifest will look like before submitting:

asm publish --dry-run ./my-skill

Override security warnings (caution: review findings first):

asm publish --force ./my-skill

Skip confirmation in CI:

asm publish --yes ./my-skill

Requires: gh CLI authenticated with gh auth login. The publish command uses gh to fork the registry, create a branch, write the manifest, and open the PR — all without leaving your terminal.

Typical local development workflow

1. Scaffold — asm init awesome-skill -p claude
2. Edit your SKILL.md
3. Link for live testing — asm link ./awesome-skill -p claude
4. Test with your AI agent
5. Security audit — asm audit security awesome-skill
6. Verify metadata — asm inspect awesome-skill
7. Score quality — asm eval ./awesome-skill
8. Push to GitHub
9. Verify install flow — asm install github:you/awesome-skill
10. Publish to registry — asm publish ./awesome-skill

Whether you're building skills for yourself or publishing them for the community, asm gives you the full create → develop → audit → ship pipeline in one tool.

Skill Verification

Skills indexed by asm are automatically evaluated against a set of verification criteria. Skills that pass all criteria receive a verified badge in the catalog and "verified": true in the index JSON. Skills that fail any criterion are still indexed but marked as unverified.

Verification Criteria

A skill must satisfy all four of the following to be verified:

1. Valid frontmatter -- The SKILL.md file must contain YAML frontmatter with both a name and a description field. Empty or whitespace-only values fail this check.

2. Meaningful body content -- The markdown body (everything after the frontmatter block) must contain at least 20 characters of instruction text. A SKILL.md that is only frontmatter with no real guidance for the agent will fail.

3. No malicious patterns -- The full SKILL.md content is scanned for dangerous code patterns:

   • atob() calls (runtime base64 decoding / obfuscation)
   • Suspicious base64-encoded strings (40+ character base64 blocks with padding)
   • Hex-escape sequences (4+ consecutive \xNN escapes)
   • Hardcoded credentials (API_KEY, SECRET_KEY, or PASSWORD assignments)

4. Proper structure -- The skill directory must exist and contain a SKILL.md file that the ingestion pipeline can read.

How to Reproduce Locally

You can verify your skill before publishing:

# Index your repo -- verification runs automatically during ingestion
asm index ingest github:your-user/your-repo

# Check the output JSON for the verified field
asm index search "your-skill" --json

Each indexed skill in the output JSON includes "verified": true or "verified": false. If verification fails, the ingestion debug log (set ASM_DEBUG=1) prints the specific reasons.

Quality Evaluation (asm eval)

Static verification tells you the SKILL.md is well-formed. asm eval goes further: the built-in quality provider runs a scored rubric over structure, frontmatter, clarity, prompt engineering, context efficiency, safety, testability, and naming — and emits per-category scores plus concrete suggestions for improvement. Zero setup, zero API keys, zero external binaries.

# Score the skill and print recommendations
asm eval ./my-skill

# CI-friendly machine-readable output
asm eval ./my-skill --machine

# Apply deterministic auto-fixes to SKILL.md
asm eval ./my-skill --fix

# List registered eval providers
asm eval-providers list

The eval surface is a pluggable provider framework: each provider implements a common EvalProvider contract and resolves via semver range. See docs/eval-providers.md for the provider model.

ASM Registry — Install and Publish Skills by Name

The ASM Registry is the curated index of community-published skills. Once a skill is listed, anyone can install it by name — no GitHub URL needed.

Install from the registry

# Install by bare name (searches the registry)
asm install code-review

# Install by scoped name (author/skill — always unambiguous)
asm install luongnv89/code-review

# Force a fresh registry fetch (bypasses the 1-hour cache)
asm install code-review --no-cache

asm install resolves the name against the registry index, downloads the manifest, clones the exact pinned commit, and installs the skill to your agent.

Publish your skill to the registry

asm publish ./my-skill

The publish pipeline:

1. Validates your SKILL.md frontmatter (name, description, version)
2. Security audit — blocks dangerous skills automatically; warns on risky patterns
3. Generates a manifest with the current commit SHA and a skill_path for multi-skill repos
4. Opens a PR against luongnv89/asm-registry via the gh CLI

The registry CI validates schema, checks author identity, runs a duplicate check, typosquat detection, and an independent security scan before any maintainer reviews. Once merged, the index rebuilds automatically and your skill is live.

How registry resolution works

When you run asm install code-review:

1. asm fetches the registry index (cached for 1 hour at ~/.config/agent-skill-manager/registry-cache.json)
2. Finds the manifest for code-review — including the pinned commit and skill_path
3. Clones the repository at that exact commit and navigates to the skill subdirectory
4. Installs as if you had run asm install github:author/repo#commit:skill_path

If multiple authors publish a skill with the same name, asm shows a disambiguation prompt. Use a scoped name (author/skill) to skip it.

Get Started in 30 Seconds

npm (recommended)

npm install -g agent-skill-manager

Runs on Node.js ≥ 18 for both the CLI and the interactive TUI. No other runtime required.

One-liner install

curl -sSL https://raw.githubusercontent.com/luongnv89/agent-skill-manager/main/install.sh | bash

This installs agent-skill-manager globally. Then just run:

asm

See All Commands →

Shadowed installs

If you have multiple asm binaries on PATH (for example, a leftover install from an older package manager), shells resolve whichever appears first and a fresh upgrade can be silently shadowed.

Diagnose: asm --version detects and warns when it sees multiple asm binaries on PATH. For a full report, run asm doctor — it lists the resolved path and any shadowed installs.

Fix: remove the stale install with your package manager, then re-run asm --version to confirm only one binary is left.

Open-Source Skill Collections

A curated list of skill repositories you can install with a single command. Over 2,800 skills available across these collections:

Last updated: 2026-03-28

Install any collection with an interactive picker:

asm install github:anthropics/skills

Or install everything at once:

asm install github:anthropics/skills --all

asm inspect oss-ready — version, creator, and every tool installation at once

Supported Agent Tools

asm ships with 19 built-in providers, all enabled by default. Disable any you don't need via asm config edit.

Disable a provider — opens config in $EDITOR, set "enabled": false for any provider:

asm config edit

Need a tool not listed? Add a custom provider entry to the config.

FAQ

Is it free? Yes. asm is MIT licensed and free forever. No accounts, no telemetry, no paywalls.

Is it actively maintained? Yes — actively developed with frequent tagged releases (45 and counting, latest v2.10.0). Check the changelog for the full history.

Which AI agents does it support? 19 providers built-in: Claude Code, Codex, OpenClaw, Cursor, Windsurf, Cline, Roo Code, Continue, GitHub Copilot, Aider, OpenCode, Zed, Augment, Amp, Gemini CLI, Google Antigravity, Pi, Hermes, and a generic Agents provider. All 19 are enabled by default; disable any you don't need via asm config edit. You can also add any custom agent that stores skills as directories with a SKILL.md file.

How does it compare to managing skills manually? Manual management means remembering where each agent stores skills, cloning repos by hand, checking for duplicates yourself, and having no security scanning. asm automates all of that with one command.

asm audit — finds duplicate groups and tells you exactly which to keep

Can I use it with private repos? Yes. Use --transport ssh or --transport auto to clone private repos via SSH.

Is it safe to install skills from GitHub? asm includes built-in security scanning that flags dangerous patterns (shell execution, network access, credential exposure, obfuscation) before installation. Run asm audit security github:user/repo to scan any skill before installing.

asm audit security oss-ready — flags external URLs, shell execution, and credential access

What's the SKILL.md format? Every skill is a directory containing a SKILL.md file with YAML frontmatter (name, description, version) followed by markdown instructions the AI agent loads at runtime. Run asm init my-skill to scaffold one.

Start Managing Your Skills Today

You're already using AI agents. You're already installing skills. The only question is whether you keep doing it manually — or let asm handle it.

MIT licensed. Free forever. One install command.

Install agent-skill-manager →

asm

-h, --help             Show help for any command
-v, --version          Print version and exit
--json                 Output as JSON (list, search, inspect, audit)
-s, --scope <scope>    Filter: global, project, or both (default: both)
--sort <field>         Sort by: name, version, or location (default: name)
-y, --yes              Skip confirmation prompts
--no-color             Disable ANSI colors

asm list --scope global --sort location

asm list --summary            # counts by tool/scope/effort only
asm list --compact            # one line per skill
asm list --group-by tool      # group rows under tool headers
asm list --limit 20           # show only the first 20 rows

asm search "code review" --json

asm inspect my-skill

asm audit --yes

asm audit security github:user/repo

asm audit security --all

asm eval ./my-skill

asm eval-providers list

asm init my-skill -p claude

# Link globally (available in all projects)
asm link ./my-skill -p claude

# Link multiple skills at once
asm link ./skill-a ./skill-b -p claude

asm audit security my-skill

asm inspect my-skill --json

asm uninstall old-skill --yes

asm index ingest github:anthropics/skills

asm index search "frontend design" --json

asm bundle list --predefined

asm bundle install frontend-dev

asm bundle install ./my-bundle.json

asm bundle create my-workflow
asm bundle export my-workflow ./my-workflow.json

asm install github:user/my-skill

asm install github:user/my-skill#v1.0.0 -p claude

asm install github:user/skills --path skills/code-review

asm install github:user/skills --all -p claude -y

asm install github:user/skills

asm install https://github.com/user/skills/tree/main/skills/agent-config

asm install github:user/skills#main:skills/agent-config

asm install github:user/private-skill --transport ssh

asm install github:user/private-skill -t auto

asm install github:user/skills --method vercel --skill my-skill

asm install https://github.com/user/skills -m vercel --skill my-skill -y

asm install github:user/my-skill --name custom-name

asm install github:user/my-skill --force

asm install github:user/my-skill -p claude --yes --json

{
  "version": 1,
  "providers": [
    {
      "name": "claude",
      "label": "Claude Code",
      "global": "~/.claude/skills",
      "project": ".claude/skills",
      "enabled": true
    },
    {
      "name": "codex",
      "label": "Codex",
      "global": "~/.codex/skills",
      "project": ".codex/skills",
      "enabled": true
    },
    {
      "name": "openclaw",
      "label": "OpenClaw",
      "global": "~/.openclaw/skills",
      "project": ".openclaw/skills",
      "enabled": true
    },
    {
      "name": "agents",
      "label": "Agents",
      "global": "~/.agents/skills",
      "project": ".agents/skills",
      "enabled": true
    },
    {
      "name": "cursor",
      "label": "Cursor",
      "global": "~/.cursor/rules",
      "project": ".cursor/rules",
      "enabled": false
    },
    {
      "name": "windsurf",
      "label": "Windsurf",
      "global": "~/.windsurf/rules",
      "project": ".windsurf/rules",
      "enabled": false
    },
    {
      "name": "cline",
      "label": "Cline",
      "global": "~/Documents/Cline/Rules",
      "project": ".clinerules",
      "enabled": false
    },
    {
      "name": "roocode",
      "label": "Roo Code",
      "global": "~/.roo/rules",
      "project": ".roo/rules",
      "enabled": false
    },
    {
      "name": "continue",
      "label": "Continue",
      "global": "~/.continue/rules",
      "project": ".continue/rules",
      "enabled": false
    },
    {
      "name": "copilot",
      "label": "GitHub Copilot",
      "global": "~/.github/instructions",
      "project": ".github/instructions",
      "enabled": false
    },
    {
      "name": "aider",
      "label": "Aider",
      "global": "~/.aider/skills",
      "project": ".aider/skills",
      "enabled": false
    },
    {
      "name": "opencode",
      "label": "OpenCode",
      "global": "~/.config/opencode/skills",
      "project": ".opencode/skills",
      "enabled": false
    },
    {
      "name": "zed",
      "label": "Zed",
      "global": "~/.config/zed/prompt_overrides",
      "project": ".zed/rules",
      "enabled": false
    },
    {
      "name": "augment",
      "label": "Augment",
      "global": "~/.augment/rules",
      "project": ".augment/rules",
      "enabled": false
    },
    {
      "name": "amp",
      "label": "Amp",
      "global": "~/.amp/skills",
      "project": ".amp/skills",
      "enabled": false
    },
    {
      "name": "gemini",
      "label": "Gemini CLI",
      "global": "~/.gemini/skills",
      "project": ".gemini/skills",
      "enabled": false
    },
    {
      "name": "antigravity",
      "label": "Google Antigravity",
      "global": "~/.antigravity/skills",
      "project": ".antigravity/skills",
      "enabled": false
    }
  ],
  "customPaths": [],
  "preferences": {
    "defaultScope": "both",
    "defaultSort": "name"
  }
}

---
name: my-skill
description: "A short description of what this skill does"
license: "MIT"
compatibility: "Claude Code, Codex"
allowed-tools: Bash Read Grep Glob WebFetch
effort: medium
metadata:
  version: 1.0.0
  creator: "Your Name <you@example.com>"
---

# my-skill

Describe what this skill does here.

## When to Use

- Trigger conditions for this skill

## Instructions

- Step-by-step instructions for the agent

asm init my-skill

asm init my-skill -p claude

git clone https://github.com/luongnv89/agent-skill-manager.git
cd agent-skill-manager
npm install

npm run build

npm start

curl -sSL https://raw.githubusercontent.com/luongnv89/agent-skill-manager/main/install.sh -o install.sh

less install.sh

bash install.sh

agent-skill-manager/
├── bin/                       # CLI entry point (source)
│   └── agent-skill-manager.ts
├── dist/                      # Built bundle (npm package ships this)
│   └── agent-skill-manager.js
├── scripts/
│   └── build.ts               # Build script with version injection
├── src/
│   ├── index.tsx              # TUI app bootstrap & keyboard handling (ink)
│   ├── cli.ts                 # CLI command parser & dispatcher
│   ├── config.ts              # Config loading & saving
│   ├── scanner.ts             # Skill directory scanning & filtering
│   ├── auditor.ts             # Duplicate detection & reporting
│   ├── installer.ts           # GitHub skill installation pipeline
│   ├── uninstaller.ts         # Safe skill removal logic
│   ├── formatter.ts           # Output formatting (tables, detail, JSON)
│   ├── utils/
│   │   ├── types.ts           # Shared TypeScript types
│   │   ├── colors.ts          # TUI color palette
│   │   ├── version.ts         # Version constant
│   │   ├── frontmatter.ts     # SKILL.md frontmatter parser
│   │   └── editor.ts          # $EDITOR command parser
│   └── views/
│       ├── dashboard.tsx      # Main dashboard layout
│       ├── skill-list.tsx     # Scrollable skill list
│       ├── skill-detail.tsx   # Skill detail view
│       ├── confirm.tsx        # Uninstall confirmation dialog
│       ├── duplicates.tsx     # Duplicate audit view
│       ├── config.tsx         # In-TUI config editor
│       └── help.tsx           # Help view
├── docs/                      # Extended documentation
│   ├── ARCHITECTURE.md        # System design & data flow
│   ├── DEVELOPMENT.md         # Local setup & debugging
│   ├── DEPLOYMENT.md          # Publishing & CI pipeline
│   ├── CHANGELOG.md           # Version history
│   └── brand_kit.md           # Logo, colors, typography
├── assets/
│   ├── logo/                  # SVG logos (full, mark, wordmark, icon, favicon)
│   └── screenshots/           # TUI screenshots
├── install.sh                 # One-command installer (curl | bash)
├── package.json
├── tsconfig.json
└── README.md

Acknowledgements

Contributors

Dependencies

Roadmap

Track our progress and upcoming features on the project kanban board. See prd.md for the full product requirements and tasks.md for the sprint-based development plan.

Contributing

Contributions are welcome! See CONTRIBUTING.md for guidelines.

License

MIT — free to use, modify, and distribute. See the LICENSE file for details.