Skip to content

CLI reference

This page is generated from the help text of quiver on the main branch, which can be ahead of the latest release; the guides mark such commands Next release. Run quiver help <command> for the same text in your terminal.

Every command takes -v, --verbose to print more details, and -h, --help.

Assign skills to this project, or to every folder with --global.

A folder without .quiver.json is registered first; in a terminal it asks before, unless --yes is given. Commit the new file, so the project keeps its ID.

With --always the skills are also always-on: the assistant loads them before its first reply, from the next session on.

Terminal window
quiver add <id>... [flags]
FlagDescription
--alwaysalso make the skills always-on: loaded before the first reply
--globalchange the skills served in every folder
--project <string>project folder (default: the current folder)
-y, --yesregister a new project without asking

Examples

Terminal window
# Assign two skills to the project in this folder
quiver add pdf anthropic/docx
# Serve a skill in every folder, and load it before the first reply
quiver add caveman --global --always
# Assign to another project folder
quiver add tdd --project ~/code/api

Generate the autocompletion script for quiver for the specified shell. See each sub-command's help for details on how to use the generated script.

Terminal window
quiver completion [command]

Delete one of your own skills from the library and commit the removal in the Quiver home, so git history still has it. It asks first.

An assigned skill is not deleted unless --force is given; then it is also unassigned everywhere. To take a skill away from one project only, use quiver remove. Skills from sources cannot be deleted one by one: quiver source remove deletes the whole source.

Terminal window
quiver delete <id> [flags]
FlagDescription
--forcealso unassign the skill where it is assigned
-y, --yesdo not ask for confirmation

Examples

Terminal window
quiver delete old-draft
quiver delete release-notes --force --yes

Check the Quiver home, the library, the assignments and the Claude Code setup, and report each check as ok, warn or error. The last line, info, names the latest Quiver release (not with $QUIVER_NO_UPDATE_CHECK).

With --fix it applies the safe fixes: it creates missing parts of the Quiver home, commits uncommitted changes in local/, deletes folders left over from an interrupted source add or remove and pin folders no pin uses, and, after asking, unassigns skills that are not in the library and deletes copies of served skills that Claude Code also loads by itself. Copies committed in git and copies in plugins are only reported.

Terminal window
quiver doctor [flags]
FlagDescription
--fixapply the safe fixes

Examples

Terminal window
quiver doctor
quiver doctor --fix

Open a local skill's SKILL.md in $VISUAL or $EDITOR. When the editor closes, the skill is checked and the change is committed in the Quiver home.

Skills from sources are read-only: "quiver update" would overwrite edits.

Terminal window
quiver edit <id> [flags]

Examples

Terminal window
quiver edit release-notes

Copy a skill from a source into your own skills, so you can change it. Skills from sources are read-only, and quiver update replaces them with the upstream version.

The copy is named after the skill, or --as. Its frontmatter records where it came from (forkedFrom: <id>@<commit>). Wherever the original is assigned, globally or in a project, the copy takes its place, always-on marks included. From then on quiver edit changes what those projects get, and quiver update no longer does.

Terminal window
quiver fork <source/skill> [flags]
FlagDescription
--as <string>name of the local copy (default: the skill's name)

Examples

Terminal window
quiver fork anthropic/pdf
quiver fork acme/review --as team-review

Print the always-on skills of a session's folder for an assistant's hook. Assistants run these commands from their hooks when a session or a sub-agent starts; you do not need to run them yourself.

The command reads the hook's JSON on stdin, finds the project of the session's folder (or of $QUIVER_PROJECT) and prints the text of its always-on skills, global ones first, and then the id and description of its other skills, in the assistant's format. An assistant passes only so much text from one hook, so the text is split into parts: the hook of part N prints part N, and quiver install gives the assistant as many hooks as the text takes. It never fails a session: on an error it prints what it knows and logs to ~/.quiver/logs/hook.log.

Terminal window
quiver hook [command]

Examples

Terminal window
# What Claude Code's SessionStart hook runs
echo '{"cwd": "'"$PWD"'"}' | quiver hook session-start claude-code

Print the always-on skills for the assistant's SessionStart hook, in its format. <assistant> is one of: antigravity, claude-code, codex, cursor, vscode. [part] is the number of the part to print, 1 when it is left out. The hook's JSON comes on stdin; its folder is the session's.

Terminal window
quiver hook session-start <assistant> [part] [flags]

Examples

Terminal window
# What Claude Code's SessionStart hook runs
echo '{"cwd": "'"$PWD"'"}' | quiver hook session-start claude-code

Print the always-on skills for the assistant's SubagentStart hook, in its format. <assistant> is one of: antigravity, claude-code, codex, cursor, vscode. [part] is the number of the part to print, 1 when it is left out. The hook's JSON comes on stdin; its folder is the session's.

Terminal window
quiver hook subagent-start <assistant> [part] [flags]

Examples

Terminal window
# What Claude Code's SubagentStart hook runs
echo '{"cwd": "'"$PWD"'"}' | quiver hook subagent-start claude-code

Move skills into the library and assign them to the project of the current folder, or to every folder.

quiver import the .claude/skills of this project (--deep: every folder of it)
quiver import <folder> every skill in the folder and its subfolders
quiver import <skill> one skill: its SKILL.md, its folder or a markdown file

A skill is a folder with a SKILL.md, or a markdown file of any name whose frontmatter has a description. Its name is the one in the frontmatter, or the folder or file name; --name sets another one when importing one skill. Markdown files without frontmatter, such as READMEs, are not skills. Skills without a description are skipped and listed at the end.

For each skill it asks where to assign it and a new name if the name is taken. --global makes every folder the default. With --yes it asks nothing: taken names are skipped.

After a skill is imported, its original is deleted, so the assistant does not load it twice; the copy in the library is committed in its git. An original committed in the git of a project is kept unless you say so, because teammates who do not use Quiver may need it; --yes keeps it too. --keep keeps every original.

Terminal window
quiver import [<folder> | <skill>] [flags]
FlagDescription
--deepwithout a folder: search every folder of this project, not only .claude/skills
--globalassign to every folder by default, instead of the project
--keepkeep every original
--name <string>name in the library, when importing one skill
-y, --yesask nothing; delete the originals that are not committed in git

Examples

Terminal window
# Import the .claude/skills of the project in this folder
quiver import
# Import every skill in a folder and its subfolders, and ask nothing
quiver import ~/Downloads/skill-pack --yes
# Import and keep the originals
quiver import --keep
# Import one skill under another name
quiver import ~/Downloads/greeter/SKILL.md --name demo
quiver import notes/review.md

Create the Quiver home and anything missing in it. Existing files are never overwritten.

In a terminal it then offers the rest of the setup, one step at a time; each can be skipped:

1. set up the MCP server and the hooks in your assistants (quiver install)
2. import the skills in ~/.claude/skills, for every folder
3. import the skills in the .claude/skills of the project in this folder

With --yes, or when not run in a terminal, it only creates the home.

Terminal window
quiver init [flags]
FlagDescription
-y, --yesask nothing; only create the home

Examples

Terminal window
quiver init
# Only create the home
quiver init --yes

Register the MCP server, and add the session-start hook where the assistant has one, in every supported assistant that is installed, or only in the assistants named. Some assistants use Quiver's skills only when you ask for them in the prompt; quiver install says which. For any other assistant, add the entry that quiver mcp config prints to its MCP config.

Supported assistants: claude-code, codex, cursor, claude-desktop, antigravity, vscode

Run it again after moving the quiver binary: a registration that points to another binary is replaced. In the assistants' JSON files, every other key is kept, and the old file is saved next to it with the suffix .quiver-backup.

Terminal window
quiver install [assistant...] [flags]

Examples

Terminal window
quiver install
# Only Cursor
quiver install cursor
# Claude Code and Claude Desktop
quiver install claude-code claude-desktop

List every skill in the library: your own (source "local") and those from sources. ASSIGNED says whether a skill is global and how many projects have it. Skills that cannot be loaded are listed as warnings at the end.

To see what one folder gets, use quiver status; for one skill, quiver where.

Terminal window
quiver list [flags]
FlagDescription
--jsonprint JSON
--source <string>only skills from this source ("local" for your own skills)
--unassignedonly skills that are not assigned anywhere

Examples

Terminal window
quiver list
quiver list --source local
quiver list --unassigned
quiver list --json

Run the MCP server on stdin and stdout. Assistants start this command; you do not need to run it yourself. Register it once with: quiver install

The server serves the skills of the project in its working directory, or in $QUIVER_PROJECT when that is set. It logs to ~/.quiver/logs.

Terminal window
quiver mcp [flags]
quiver mcp [command]

Examples

Terminal window
# What Claude Code runs after quiver install
quiver mcp

Print the mcpServers entry that starts this quiver, for an assistant that quiver install does not set up. Add it to that assistant's MCP config. Nothing is changed.

Terminal window
quiver mcp config [flags]

Examples

Terminal window
quiver mcp config

Create a local skill in the Quiver home and assign it to this project, to every folder with --global, or nowhere with --none.

Without --description the new SKILL.md opens in $VISUAL or $EDITOR.

A folder without .quiver.json is registered first; in a terminal it asks before, unless --yes is given.

Terminal window
quiver new <name> [flags]
FlagDescription
--description <string>one sentence on when the assistant should use the skill; skips the editor
--globalchange the skills served in every folder
--nonecreate the skill without assigning it
--project <string>project folder (default: the current folder)
-y, --yesregister a new project without asking

Examples

Terminal window
# Write the skill in your editor; it is served in this project
quiver new release-notes
# Create it without an editor, for every folder
quiver new commit-style --global --description "Write commit messages in our style."

Keep a skill from a source at one commit of the source: its current commit, or the one given (a hash, tag or branch). quiver update then leaves the skill alone, so its text changes only when you decide. The pin applies everywhere the skill is assigned, and its ID stays the same.

The commit is checked out into ~/.quiver/sources/.pins. Older commits are downloaded first when the source does not have them yet. quiver unpin goes back to the source's current version. To change the skill itself, use quiver fork instead.

Terminal window
quiver pin <source/skill> [<commit>] [flags]

Examples

Terminal window
quiver pin anthropic/pdf
quiver pin acme/review 3f2a9c1

List registered projects: name, ID, number of skills and folders. Folders that no longer exist are marked (missing).

Terminal window
quiver projects [flags]
quiver projects [command]
FlagDescription
--jsonprint JSON

Examples

Terminal window
quiver projects
quiver projects --json
quiver projects rename app-k3f9q2 web
quiver projects forget old-site

Remove a project and its skill assignments from the registry. The project's .quiver.json is left alone, so using the folder again registers it again with the same ID and no skills.

Terminal window
quiver projects forget <id|name> [flags]
FlagDescription
-y, --yesdo not ask for confirmation

Examples

Terminal window
quiver projects forget old-site
quiver projects forget app-k3f9q2 --yes

Change the name Quiver shows for a project. The name is only a label; the project keeps its ID and skills.

Terminal window
quiver projects rename <id|name> <new-name> [flags]

Examples

Terminal window
quiver projects rename app-k3f9q2 web
quiver projects rename web web-frontend

Run inside a project folder that was copied with its .quiver.json. The folder gets a new ID and starts with the skills of the original; after that, changing one copy's skills does not change the other's.

Terminal window
quiver projects split [flags]

Examples

Terminal window
cp -R ~/code/app ~/code/app-v2
cd ~/code/app-v2
quiver projects split

Unassign skills from this project, or from every folder with --global. The skills stay in the library.

With --always only the always-on mark is removed; the skills stay assigned.

Terminal window
quiver remove <id>... [flags]
FlagDescription
--alwaysonly remove the always-on mark and keep the skills assigned
--globalchange the skills served in every folder
--project <string>project folder (default: the current folder)

Examples

Terminal window
quiver remove pdf
quiver remove caveman --global
# Keep the skill assigned, but stop loading it before the first reply
quiver remove caveman --global --always

Search the IDs, names and descriptions of every skill in the library, ignoring case. Exact names come first, then names that start with the text, then names that contain it, then descriptions. HERE says whether a skill is served in this folder: global or project.

Terminal window
quiver search <text> [flags]
FlagDescription
--jsonprint JSON

Examples

Terminal window
quiver search pdf
quiver search "pull request" --json

Show a skill of the library: its ID and name, where it comes from (local, or the source and its commit), its folder, where it is assigned and whether it is always-on there, its extra files, then the text of its SKILL.md.

Terminal window
quiver show <id> [flags]
FlagDescription
--jsonprint JSON

Examples

Terminal window
quiver show pdf
quiver show anthropic/docx --json

A source is a git repository with skills, such as a team's shared skills. Its skills get IDs like <source>/<skill>. They are read-only: quiver update pulls new versions.

Add only sources you trust. Their skills give instructions to your assistant and can include scripts.

Terminal window
quiver source [command]

Examples

Terminal window
quiver source add anthropics/skills --name anthropic
quiver source list
quiver source remove anthropic

Clone a repository and add its skills to the library.

<repo> is owner/repo (GitHub), host/owner/repo, a git URL or a local path. The source name defaults to the repository owner.

Terminal window
quiver source add <repo> [flags]
FlagDescription
--name <string>source name (default: the repository owner)

Examples

Terminal window
# GitHub owner/repo
quiver source add anthropics/skills --name anthropic
# Any git URL, or a local folder
quiver source add git@github.com:acme/skills.git
quiver source add ~/code/team-skills

List the sources: name, number of skills, the commit in use and when it was made, and the repository.

Terminal window
quiver source list [flags]

Examples

Terminal window
quiver source list

Delete a source and its skills. It refuses while skills from the source are assigned, unless --force is given.

Terminal window
quiver source remove <name> [flags]
FlagDescription
--forceunassign the source's skills first

Examples

Terminal window
quiver source remove acme
quiver source remove acme --force

Show the project in this folder and the skills the MCP server serves here.

Like the server, it uses $QUIVER_PROJECT instead of the current folder when it is set.

Terminal window
quiver status [flags]
FlagDescription
--jsonprint JSON

Examples

Terminal window
quiver status
QUIVER_PROJECT=~/code/api quiver status
quiver status --json

Sync the Quiver home with a git remote, so every machine has the same local skills, sources and assignments. Set it up once per machine with quiver sync init <git-remote>; use a private repository.

quiver sync commits the changes on this machine, pulls the others with rebase and pushes. When registry.json or config.json changed on both machines, the changes are merged: a skill assigned on either machine stays assigned. Any other conflict stops the sync with nothing pulled or pushed, and says how to resolve it. Sources added on another machine are cloned afterwards.

Whatever another machine pushed becomes live here, so when it makes a skill always-on, changes the files of an always-on skill or adds a source, sync lists those changes and asks before it pulls. --yes takes them without asking; without a terminal and without --yes, sync pulls nothing.

Only local/, config.json and registry.json are synced. sources/ is cloned again from config.json, and the folders where each project was seen stay on each machine.

Terminal window
quiver sync [flags]
quiver sync [command]
FlagDescription
-y, --yestake changes to always-on skills and sources without asking

Examples

Terminal window
quiver sync init git@github.com:me/quiver-home.git
quiver sync

Turn the Quiver home into a git repository with <git-remote> as its remote, and push it. The history of local/ is kept; local/ stops being a repository of its own.

Run it on every machine with the same remote. When the remote already holds another machine's home, this machine's skills, sources and assignments are merged with it. If the same local skill differs on both, it stops and changes nothing.

Terminal window
quiver sync init <git-remote> [flags]
FlagDescription
-y, --yestake changes to always-on skills and sources without asking

Examples

Terminal window
quiver sync init git@github.com:me/quiver-home.git

Remove the MCP server and Quiver's hooks from every supported assistant that is installed, or only from the assistants named. The Quiver home and its skills are not touched.

Supported assistants: claude-code, codex, cursor, claude-desktop, antigravity, vscode

Terminal window
quiver uninstall [assistant...] [flags]

Examples

Terminal window
quiver uninstall
# Only Claude Desktop
quiver uninstall claude-desktop

Remove the pin of a source skill, so it is served from the source's current version again and quiver update changes it as usual.

Terminal window
quiver unpin <source/skill> [flags]

Examples

Terminal window
quiver unpin anthropic/pdf

Pull the latest skills of the given sources, or of every source. For each source it first downloads the new commits without applying them, and lists the skills that would be added, changed or removed. For each assigned skill that changes, it lists the changed files, and marks scripts (such as .sh, .py and .js files, and executable files) as "needs review": the assistant may run them. --diff shows the whole change of those skills.

When an assigned skill would change or go away, it asks before it applies the changes; --yes applies them without asking. Changes to skills that are not assigned are applied right away. Pinned skills are left alone.

A source whose history was rewritten (force-pushed) is not updated; run again with --reset to take the remote history.

Terminal window
quiver update [<name>...] [flags]
FlagDescription
--diffshow the whole change of each assigned skill that changes
--resetreplace a rewritten history (after a force-push) with the remote one
-y, --yesapply the changes without asking

Examples

Terminal window
quiver update
quiver update anthropic --diff
quiver update --yes
quiver update acme --reset

Show where a skill is assigned: "global" if it is served in every folder, then each project that has it, with its folders.

Terminal window
quiver where <id> [flags]
FlagDescription
--jsonprint JSON

Examples

Terminal window
quiver where pdf
quiver where anthropic/docx --json