Meta Skill (ms) CLI
Meta Skill
Meta Skill (ms) keeps skills locally in SQLite and Git, searches them with a hybrid index and serves agents over MCP
- 210 ★ on the repository
- Last commit
Extended access
Why this level
- Reads agent sessions to mine skills and writes a local SQLite database and Git archive
- The MCP server hands skill text to the agent, and skills from third-party bundles can carry prompt injection
Install
- Works in
Manual install
cargo install --path .Run in a clone of the repository, Rust required. Verifying signed binaries is described in `docs/published-release-checks.md`.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Reads agent sessions to mine skills and writes a local SQLite database and Git archive
- The MCP server hands skill text to the agent, and skills from third-party bundles can carry prompt injection
This is third-party code. Review the repository files before installing.
What it does
Meta Skill, the `ms` command, is a Rust skill manager for coding agents. It stores every skill twice: in SQLite for fast queries and in a Git archive for history and audit. If the database is corrupted, skills are rebuilt from Git. Skills come from handwritten `SKILL.md` files, from agent sessions through the CASS integration (`ms build --from-cass "error handling" --since "7 days"`), from bundles and from other machines through `ms sync`. Search is hybrid: BM25 plus deterministic hash embeddings, fused with Reciprocal Rank Fusion. `ms suggest` picks skills for the context, and `ms load` can pack a skill to a given token count with contracts for debugging, refactoring and learning. Built-in protection looks for prompt injection in skill text and blocks dangerous commands. `ms graph insights` shows dependencies and cycles, and usefulness metrics accumulate from feedback. For agents the server starts with `ms mcp serve` (stdio for Claude Code or `--port` for HTTP).
Who it is for. Developers with dozens of personal and team skills who need search, versions and context-based selection instead of a folder of files.
Good fit when
- Skills piled up and the agent loads the wrong ones or too many tokens
- Recurring techniques from recent sessions should be pulled out and written up as a skill
- A skill set must live the same on several machines and keep a change history
- You want to see dependency chains between skills and spot cycles
- Skills arrive from external bundles and you want an injection check before loading
Not a fit when
- You have three or four skills: a plain folder and an ordinary installer are simpler
- You need a shared cloud catalog: `ms` keeps everything local and syncs through Git
- A Rust build is not an option for you: the README's main method is `cargo install --path .`
- You need a ready-made skill collection: the project manages skills and you create the set yourself
Example request
Index my skills, find the ones about Rust error handling and load the best one within 2,000 tokensLimitations
- The main install builds the project from source with `cargo install --path .`, so Rust is required. The README also covers verifying signed binaries.
- The license is not detected in GitHub metadata, so read the `LICENSE` file before company use.
- Some features lean on the author's neighbouring tools, for example CASS for mining sessions and `bv` for dependency graph analysis.
- The feature set is large and the docs are long, so start with `ms init`, `ms index` and `ms search`.
How to disable. Remove the `ms mcp serve` entry from the MCP client settings and delete the binary. Data lives in the local `.ms/` folder (SQLite and a Git archive), which can be deleted by hand. Your `SKILL.md` files are not changed by it.
FAQ
What is Meta Skill and how does it differ from a skills folder?
It is a manager with an SQLite database, a Git archive, hybrid search and context-based skill selection. A folder holds files, while `ms` tells you which ones are needed now and in what size.
How do I connect Meta Skill to Claude Code?
Run `ms mcp serve`: the server works over stdio and serves skills to the agent as tools. For other integrations an HTTP mode is available with the `--port` flag.
How does search work?
Lexical BM25 is merged with semantics from deterministic hash embeddings through Reciprocal Rank Fusion. No external embedding models are needed and results are reproducible.
How do I fit a skill into a token limit?
`ms load <skill> --pack 800` squeezes a skill to 800 tokens, and `--contract debug` picks a debugging preset. Refactor, learn and quickref modes exist too.
Can I sync skills across machines?
Yes, `ms sync` synchronizes through Git with conflict resolution strategies.
Discussion
No questions or reviews yet.
Related
CLI toolsA CLI and MCP server for Agent Skills: spec validation, installs from GitHub and on-demand loading of the right skill
A meta-skill that turns a workflow into an agent skill: prior-art search, trigger evaluation and publication to GitHub
A desktop app and CLI to install, sync and organize agent skills across Claude Code, Codex, Cursor and other tools
Skill search from inside the conversation: the agent finds a SKILL.md, reads it and applies it with no prior install
A command-line skill manager: installs skills from a marketplace, GitHub, private Git and npm into 45 agents' folders and scans them first
A Rust tool with its own window: scans Codex, Claude Code and Gemini CLI skills, checks risks and enables or disables them
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| Meta Skill (ms) (this card) | no | 210 | |
| SkillKit | no | 1,572 | installs skills from repositories and converts formats rather than keeping a searchable context-aware database |
| Agent Skill Manager | no | 966 | installs skills and vets them before install, with no database search or token packing |
README in short
The README starts with a one-line install and a link to verifying signed binaries, then describes the platform: a capabilities table, a quick example and the architectural rationale. Sections cover dual storage, hash embeddings, bandit optimization, security and the MCP server, followed by skill sources and a command reference.