Skill Kit

Agent-first Skill inventory for local AI coding agents.

skit manages SKILL.md directories in one local store, then exposes them through simple CLI commands and symlinks.

---

Skill Kit is a small manager for Agent Skills. It is designed for an AI agent to operate directly: search for a capability, install the matching Skill, list what is available, and repair local state without needing an interactive package-manager session.

The problem it solves is local fragmentation. Codex reads ~/.codex/skills, Claude Code reads its own skills directory, Cursor has another location, and agents end up with separate copies of the same capability. skit keeps one machine-level Skill inventory and exposes it through the standard active skills directory:

${XDG_DATA_HOME:-~/.local/share}/skit/
├── manifest.json
└── skills/
    └── code-review/
        └── SKILL.md

~/.agents/skills/code-review -> ~/.local/share/skit/skills/code-review

Agent-specific directories are compatibility targets, not the core model. The core model is the store.

Design

skit deliberately avoids acting like a heavyweight package manager. A Skill is usually a directory of instructions and supporting files, not a compiled artifact with a meaningful update protocol.

That leads to a simple design:

• install Skills by copying them into the local skit store;
• record source, name, description, and active links in manifest.json;
• activate Skills with symlinks;
• export the manifest as skit.json when the setup should be shared;
• update by reinstalling from recorded sources.

The store is intentionally plain. skit records where a Skill came from and reinstalls from that source when asked; it does not build a second package system around hashes, locks, or garbage collection.

Text output is compact on purpose. It is meant for an active AI agent: high signal, low boilerplate, no repeated command essays. More detail is available through help, check, list --all, and --json.

Install

Install macOS/Linux with the project installer:

curl -fsSL https://raw.githubusercontent.com/vlln/skit/main/install.sh | sh

By default the binary is placed in $HOME/.local/bin. Set SKIT_BINDIR to install elsewhere:

SKIT_BINDIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/vlln/skit/main/install.sh | sh

Package-manager distribution can layer on the same release artifacts:

brew install <tap>/skit

From a checkout:

go build -o skit ./cmd/skit

Requirements are intentionally small: git for remote sources, and Go only when building from source.

Use

Install a Skill source:

skit install github:owner/repo@code-review

List the local skit inventory:

skit list

Search when the agent does not know the source yet:

skit search "code review"
skit search review --source github:owner/skills

Add a curated manifest as a named source for search and install:

skit source add skills-source https://raw.githubusercontent.com/vlln/skills-source/main/skit.json
skit search "pdf" --source skills-source
skit install skills-source/mineru-api

Manage sources:

skit source              # list sources
skit source remove <name>
skit source enable <name>
skit source disable <name>

Create a Skill repository:

skit init review

This creates:

review-skill/
├── README.md
└── skills/
    └── review/
        └── SKILL.md

Export the current inventory to a repository-friendly file:

skit export

Another agent can apply that setup from a checkout containing skit.json:

skit install

Preview first:

skit install --dry-run

Output Shape

Default output is short and stable enough for an LLM to read without wasting context.

$ skit search review --source ./skills
./skills/review    Review code changes before committing.

$ skit install ./skills/review
installed review
active ~/.agents/skills/review

$ skit list
review    active    Review code changes before committing.

list --all is the escape hatch for discovering Skills that already exist in agent directories but are not managed by skit:

managed
review    active    Review code changes before committing.

external
legacy-review    ~/.codex/skills/legacy-review    Legacy review workflow.

Sharing

The local database lives at:

${XDG_DATA_HOME:-~/.local/share}/skit/manifest.json

skit export writes the same manifest format to ./skit.json. Commit that file when a repository or team wants a shared Skill setup. Local Skills created with skit init should usually be committed as normal repository files under skills/; externally installed Skills belong in skit.json.

Example manifest:

{
  "schema": "skit.manifest/v1",
  "skills": {
    "review": {
      "name": "review",
      "description": "Review code changes before committing.",
      "source": {
        "type": "github",
        "locator": "owner/skills",
        "url": "https://github.com/owner/skills.git",
        "ref": "main",
        "subpath": "skills/review",
        "skill": "review"
      },
      "path": "skills/review",
      "agents": ["universal"]
    }
  }
}

Sources

Common source forms:

./skill
owner/repo
owner/repo@skill-name
owner/repo/path/to/skill
github:owner/repo#main@skill-name
https://github.com/owner/repo/tree/main/skills/review
https://skills.sh/owner/repo/skill-name
git@github.com:owner/repo.git

Use --skill <name> when an inline selector would be ambiguous. Use --all when the source contains multiple Skills and all of them should be installed.

GitHub private repositories are token-friendly. Credentials are resolved in this order:

1. SKIT_GITHUB_TOKEN
2. GITHUB_TOKEN
3. GH_TOKEN
4. gh auth token

Git prompts are disabled during fetches, so agent workflows fail instead of hanging for credentials.

Commands

The command surface is intentionally small.

Command	Purpose
skit search <query>	Find installable Skills.
skit install <source>	Install a source into the local store.
skit install	Apply ./skit.json if present.
skit list	Show the managed inventory.
skit list --all	Include unmanaged external Skills found on disk.
skit update [name]	Reinstall from recorded sources.
skit remove <name>	Remove from manifest, active link, and local store.
skit check	Validate manifest entries and active links.
skit export [path]	Write a shareable manifest, default ./skit.json.
skit source add [name] <url>	Register a manifest URL as a named search source.
skit source	List registered sources; remove, enable, disable.
skit init <name>	Create a Skill repository skeleton.

Useful flags:

--skill <names...> Select Skills from one source
--name <name>      Install one Skill under a local name
--all              Install all Skills from a source; with list, scan external dirs
--dir <path>       Download-only: copy skills to path, skip manifest and symlinks
--full-depth       Search recursively during source discovery
--force            Replace an existing non-symlink active path
--keep             Remove manifest/link state but keep the local copy
--dry-run          Preview manifest installation
--json             Print structured output for scripts

--agent <name> exists for compatibility when an agent requires a private skills directory. It is not the default workflow.

Safety

skit install, search, list, update, and check do not execute Skill code. Install copies files, validates basic Skill shape, records metadata, and creates symlinks.

The CLI rejects unsafe source subpaths, rejects non-regular files while copying, normalizes executable modes, and warns about suspicious content such as piping a network download into a shell.

Bundled Skills

This repository includes Skills for working with Skill repositories:

Skill	Description
search-skills	Find, evaluate, and install agent skills with skit.
make-skill	Create or revise Agent Skills repositories.

Install a bundled Skill from a published repository:

skit install owner/repo/skills/make-skill

Development

go test ./...
go build -o skit ./cmd/skit

Manual smoke:

go build -o ./skit-e2e ./cmd/skit
./skit-e2e init demo
./skit-e2e install ./demo-skill
./skit-e2e list
./skit-e2e check
./skit-e2e remove demo

License

MIT.