crew helps teams share agent skills.
Easily discover and share skills across your team. One command to install. The same skills on every laptop, in every coding agent. Updated automatically.
Install Crew
$ curl -fsSL https://crew.logic.inc/install.sh | sh $ crew version crew 0.3.1 (darwin-arm64)
A single binary. Drops itself in ~/.local/bin/crew, plus whatever skills you install go under ~/.crew/ and into your agents' skills directories. Nothing else. Uninstall with rm -rf ~/.crew && rm ~/.local/bin/crew.
What is Crew?
Crew turns any git repo into a registry of agent skills.
Push a SKILL.md. Share a link. That's the package index. No servers, no accounts, no hosted registry.
Your team has great skills. You should have all of them.
Right now, the best prompts and agent playbooks either sit on one person's machine or get copy-pasted through gists and Slack messages that nobody keeps current. Crew gives them a home, a way to be shared, and kept up to date. Anyone can publish. Anyone can install.
Publish a skill.
Any git repo with a SKILL.md at the root is installable. Push to GitHub, send the link — crew install @you/skill and your friend has it.
Your skills repo is your registry.
Point crew at a shared repo — a tap — and everyone on the team pulls the same skills, reviewed in PRs, versioned in git. Onboarding is one command.
Discover what actually works.
Browse the default core tap and community taps for battle-tested skills — review conventions, language idioms, framework playbooks. Fork, tweak, publish your own.
Find, install, update. Repeat.
Four everyday motions. No manifest to learn, no plugins to configure — commands that do what they say, across every agent you use.
Find great skills.
Search across your team's private tap, the default core collection, and anything else you've added. Browse what your team, favorite engineers, and the broader community are publishing.
Tap into more sources.
A tap is any git repo full of skills. Add your team's repo, a community collection, your own private one — crew tap add once, and every skill inside is searchable and installable.
Install into every agent.
One crew install copies the skill into Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Goose, and every other agent on your machine. Grab one skill, or a whole collection at once.
Dependencies, handled.
Skills can depend on other skills. Crew walks the graph and installs everything they need. A single "team baseline" meta-skill can pull in a dozen others in one command.
Stay current automatically.
crew update pulls the latest versions of everything. Flip on autoupdate and a background job keeps every agent fresh in the background.
Three ways to point at a skill.
A reference is anything you can hand to crew install — and anything another skill can list as a dependency. The grammar is small on purpose.
Local path
./my-skill
A directory on your machine. Detected by leading ./, ../, /, or ~. Tilde expands, relatives resolve against cwd.
- crew install ./founding-engineer
- crew install ~/code/team-skills/code-review
Git source
@owner/repo
Any reachable git URL. No tap setup required. @owner/repo is GitHub shorthand; full https:// and git@ URLs work for anywhere else. Append @ref to pin, //subpath to scope.
- crew install @acme/skills
- crew install @acme/skills@v1.2.0
- crew install @acme/skills//engineers/founding
Tap source
founding-engineer
A skill inside a configured tap. Bare names search every tap — including the default core tap, which ships with a curated set of battle-tested skills. Qualify with tap/name to be explicit. Pin with @v1.0.
- crew install founding-engineer
- crew install core/founding-engineer
- crew install acme/code-review@v1.0
What using it actually feels like.
Six commands that cover 90% of needs.
# Find a skill across every tap you've added. $ crew search engineer 3 matches for "engineer" core founding-engineer Ship like a founding engineer: bias to action, small PRs, obvious code. staff-engineer Design docs, RFC etiquette, cross-team technical leadership. acme platform-engineer Team conventions for infra work and on-call handoffs. # Install one — it lands in every agent on your machine. $ crew install founding-engineer ✓ founding-engineer@a1b2c3d installed in 5 agents # Install straight from a repo, pinned to a tag, at a subpath. $ crew install @acme/skills@v1.2.0//engineers/founding # See what's installed. $ crew list Installed skills (3) founding-engineer core a1b2c3d 5 agents code-review core d4e5f6a 5 agents platform-engineer acme@v1.2.0 9c8b7a6 5 agents Run `crew info <name>` to see more about any of these. # Pull the latest versions of everything. $ crew update ✓ founding-engineer a1b2c3d → e8f9a01 (5 agents) ✓ code-review up to date ✓ platform-engineer pinned @ v1.2.0, skipped # Run crew update in the background every 4 hours. $ crew autoupdate enable ✓ Autoupdate enabled checking every 4 hours see progress in `crew autoupdate status`
Everything the CLI can do.
Every command accepts --scope, --agent, --dry-run, --json, --quiet, --verbose, --yes, and --force where they apply. Run crew help <command> for examples.
Managing skills
Discovery
~/.crew/taps/. Name defaults to the repo name.crew update for that.Agents & automation
crew update --quiet on an interval (default 4h).Housekeeping
crew binary itself to the latest release. --check reports without downloading.Meta
A tap is just a git repo full of skills.
No hosted registry, no server, no account. Your team's skills repo is the package index. Fork it, branch it, review it in pull requests, and crew update pulls it like any other.
Repository shape
acme-skills/ ├── README.md # optional, informational ├── founding-engineer/ │ └── SKILL.md ├── code-review/ │ └── SKILL.md ├── platform-engineer/ │ ├── SKILL.md │ └── playbook.md └── docs/ └── contributing.md # ignored by crew search
Any top-level directory with a valid SKILL.md is a skill. Everything else is ignored. You can still nest things — but only the top level is indexed.
Day one for a new teammate
$ crew tap add @acme/skills ✓ cloned acme → ~/.crew/taps/acme (42 skills) $ crew install acme/team-baseline # meta-skill pulling in everything the team considers standard # (e.g. founding-engineer, code-review, pr-descriptions, on-call…) ✓ resolved 14 dependencies ✓ installed across every detected agent $ crew autoupdate enable ✓ agent loaded · keeps skills current every 4h
A meta-skill is an ordinary skill whose body describes the team's conventions and whose dependencies list pulls in the rest. Onboarding becomes one command.
Fun for the whole team.
The best skills on your team are trapped on the other engineers' computers. Crew gives your team a shared shelf — a private git repo that everyone installs from, reviews in PRs, and keeps in sync without thinking about it.
One repo, every laptop
Your team's skills repo is your registry.
Point crew at a private GitHub repo once. Every new skill that lands on main shows up in everyone's crew search. No internal tool to build. No package server to run.
Onboarding, one command
New hires are productive on day one.
Publish a team-baseline meta-skill that depends on everything you consider standard — review checklists, on-call playbooks, style guides. A single crew install catches them up.
Review in PRs
Skills get better like code does.
Propose a change to the team's prompt library the same way you propose a change to anything else — a branch, a PR, comments, squash-merge. Everyone pulls the update on their next crew update.
Private by default
Internal stays internal.
Crew clones taps with whatever git credentials you already have. Your private repo stays private — crew never phones home, never uploads, never indexes anything outside the machines you install it on.
# Monday, 9:04am. A new engineer opens their laptop. $ crew tap add @acme/skills ✓ cloned acme → 42 skills available $ crew install acme/team-baseline ✓ resolved 14 dependencies ✓ installed across every detected agent # Monday, 9:06am. They know how the team ships code.
Crew is a file copier.
Crew is a file copier. It doesn't execute your skills, your taps, or anything they pull in. It leaves a paper trail you can audit, and it refuses to overwrite anything it didn't install itself.
No symlinks, ever.
Every install is a file copy. Upgrades atomically rename into place. You can rm -rf a skill with no side effects.
Never executes anything.
No post-install hooks, no build steps, no user-supplied scripts run by crew. It copies files. Agents are what run them.
Tracks what it wrote.
Every installed skill gets a .crew.json marker with its source, ref, SHA, and content hash. Removing a skill removes only what crew created.
Detects your edits.
On re-install, crew re-hashes the destination. If you've customized a managed skill, the install is refused — unless you pass --force.
Concurrency-safe.
Every write takes an advisory lock on state.json.lock. The background autoupdater and your interactive shell can't stomp on each other.
Reproducible versions.
Tags and branches resolve to full 40-char commit SHAs at install time. The SHA — not the tag — is what's recorded.
Owns only ~/.crew/.
Crew writes to its own directory and to each agent's skills directory. It won't touch your global AGENTS.md, settings JSON, or anything else.
Auditable.
crew doctor reconciles state, markers, and agent directories. --repair fixes drift without ever touching files you edited.
No proprietary manifest. Just SKILL.md.
Crew reads the Agent Skills specification directly. Crew-specific metadata lives under metadata.crew so the skill stays fully spec-compliant — readable by any agent, not just the ones crew installs into.
--- name: founding-engineer description: Ship like a founding engineer. Use when scoping, writing, or reviewing code at an early-stage company. license: MIT metadata: crew: homepage: https://github.com/jane/founding-engineer dependencies: - code-review - @acme/skills//code-review@v1.0 --- # Founding engineer mode Bias to action. The second-best solution shipped this week beats the perfect one shipped next month. Prefer small, obvious PRs over clever ones. Delete code aggressively. Write the boring version first. # ...the rest of the skill body is whatever the agent needs to read.
homepage
Shown by crew info so people can find your docs.
dependencies
Other skills to pull in — by name, git URL, or path. Walked transitively.
versions
Every install pins to a git commit SHA. Pin to a tag with @v1.0.
Things people ask about crew.
How is this different from skills.sh or `gh skill`?
They're great projects too — different takes on the same problem. Crew leans hard into team workflows. A few things that are particular to crew:
- Taps. Point crew at a git repo once; every skill in it is searchable and installable. You can even just install the entire tap, and as skills are added to that tap, they'll get added to your machine when you run
crew update. - Skill dependencies. Skills can depend on other skills. Crew walks the graph and installs everything they need. A single
team-baselinemeta-skill can pull in a dozen others. - Background autoupdate.
crew autoupdate enablesets up a launchd agent that keeps every skill current. - Local-edit protection. Crew hashes what it installs and refuses to clobber your edits on re-install — so you can tweak a skill in place and not lose your work the next time something updates.
- Private-first. Crew clones taps with whatever git credentials are on the machine — SSH, GitHub tokens, Enterprise hosts. No hosted middleman.
How does crew work with a private team skills repo?
Same as any private git repo you clone. Add it as a tap: crew tap add git@github.com:acme/skills.git. Crew uses whatever credentials your git already has — SSH keys, personal access tokens, GitHub Enterprise hosts. Nothing gets uploaded anywhere; there's no intermediary registry.
Every main-merge automatically becomes installable team-wide. Pair it with crew autoupdate enable and everyone stays in sync without thinking about it.
Skills can depend on other skills?
Yes. A SKILL.md's frontmatter can list metadata.crew.dependencies — an array of skill references in any form the CLI accepts. Crew walks the graph transitively and installs every dep before the parent.
The most useful pattern is a "meta-skill" — a single skill whose body describes a team's conventions and whose dependencies list pulls in the real working skills. Onboarding a new engineer becomes one command.
Does one install really cover every coding agent?
Yes. crew install founding-engineer copies the skill into Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Goose, and every other supported agent that's detected on the machine. Agents that share a convention (e.g. most read ~/.agents/skills/) get one physical copy; the install summary reports each adapter by name.
Don't have one of them? It's skipped silently. Add the agent later, run crew update, and it catches up.
Why copies instead of symlinks?
Symlinks break the moment two agents resolve a skill differently, or a user pins one agent to an older ref. Copies are dumb, predictable, and safe: each agent's directory is self-sufficient. The marginal disk cost is negligible — skills are markdown.
What happens if I edit an installed skill?
.crew.json marker at install time. On the next crew install or crew update, it recomputes the hash. If it differs, crew refuses to overwrite your changes and reports customized. You pass --force to override, or copy your edits into a new skill and install that instead.How do I add support for a new agent?
detect, user_path, project_path, install, uninstall, list_installed. Register it. The install pipeline is tool-agnostic; adapters just know where the files go.Is there a hosted registry?
core is a plain git repo. Anyone can host a tap — your team, your company, yourself. Crew never phones home.How does crew update know when to skip a skill?
--force. Skills pinned to a tag are re-resolved: if the tag moved and --force is given, the new commit is installed. Everything else (branches, default branches, bare tap references) updates to whatever the ref resolves to now.What about Linux? Windows?
Future work. The v1 spec is macOS-only because launchd is the autoupdate mechanism and each agent adapter encodes platform-specific paths. Nothing in the core design is Mac-specific; it's a scope decision, not a technical one.
Can a skill depend on another skill in a different tap?
Yes. Dependency references are full skill references — any form the CLI accepts. You can depend on a bare name (resolved across taps), a qualified tap name, a git URL with a ref, or a subpath inside a monorepo.
Does project scope interact with git?
--scope project writes into the agent's project-local skills directory relative to your current working directory. Whether you commit that directory is up to you. Many teams do; it means cloning a repo gives you its skills, no crew install required.Works with every Mac agent that speaks the spec.
Any agent coder that reads the Agent Skills spec is a valid target. Crew auto-detects the ones you already have and quietly skips the rest.
Don't see yours? Its adapter probably takes an afternoon to write — §7.1 in the PRD walks you through it.