Integration Guide
Connect SkillRepo to your IDE so AI agents can discover and activate skills automatically. The fastest way to get started is a single command:
npx skillrepo initThis auto-detects your IDEs, validates your access key, and writes the correct MCP configuration for each one. It works for individual developers and teams alike.
On this page
How It Works
SkillRepo exposes an MCP (Model Context Protocol) server that IDEs connect to over HTTP. The skillrepo CLI wires two pieces together: an MCP config for each detected IDE, and a local copy of your library synced from the registry. Run npx skillrepo init and both are set up in one shot.
1. MCP server connection
A JSON config that tells your IDE where the SkillRepo MCP server lives and how to authenticate. The CLI writes this to your IDE's project-level or global MCP settings file depending on which IDE(s) it detects.
2. Local skill sync
Your library — the set of skills you've subscribed to — is pulled to disk so agents can activate them without hitting the network for the SKILL.md body on every session. The CLI writes skills to .claude/skills/<name>/ (project scope) or ~/.claude/skills/<name>/ (with --global). Run skillrepo update periodically to pull new versions, or use add/remove to change what's in your library.
| IDE | MCP Config File | Skill Location |
|---|---|---|
| Claude Code | .mcp.json | .claude/skills/<name>/ |
| Cursor | .cursor/mcp.json | skills/<name>/ (fallback) |
| VS Code | .vscode/mcp.json | skills/<name>/ (fallback) |
| Windsurf | ~/.codeium/windsurf/mcp_config.json | skills/<name>/ (fallback) |
Claude Code is the only vendor with a documented skills-directory convention. The other three currently fall back to a project-level skills/ folder; if that folder is newly created by the CLI, /skills/ is added to your .gitignore so your library isn't committed by accident.
CLI Command Reference
The skillrepo CLI ships seven commands. All commands read credentials from ~/.claude/skillrepo/config.json, the SKILLREPO_ACCESS_KEY environment variable, or the--key flag — in that order.
| Command | What it does |
|---|---|
skillrepo init | First-run setup. Validates your access key, auto-detects IDEs, writes the MCP config for each, and pulls your library. Idempotent — safe to re-run. Use --force to rotate credentials or --ide claude for headless CI. |
skillrepo update | Sync your library against the registry. Uses delta sync (ETag + since filter) so repeat runs are cheap. Handles tombstones — skills removed from the library are deleted locally. |
skillrepo get @owner/name | Fetch a single skill by identifier. Does NOT mutate your library — pure read + local write. Useful for previewing a skill before adding it. |
skillrepo add @owner/name | Add a skill to your library and pull it locally. Requires a write-scoped access key. Idempotent — adding an already-present skill re-fetches the current version. |
skillrepo remove @owner/name | Remove a skill from your library and delete the local directory. Requires a write-scoped access key. |
skillrepo list | Render your library as a table. Pass --json for machine-readable output. |
skillrepo search <query> | Search the public registry by keyword. Use --limit to cap results and --json for scripting. |
Every command supports --help (per-command options), --verbose (stack traces on error, including retry attempts), --global (target ~/.claude/skills/ instead of the project), and --json (structured output).
Read-only commands (init, update, get, list, search) automatically retry transient server failures (429, 502, 503, 504, and network errors) with exponential backoff. Write commands (add, remove) are single-shot to keep behavior predictable.
Team Setup
RecommendedConfigure SkillRepo once in your shared repository so every team member gets a working integration automatically when they clone or pull. No per-developer IDE setup required.
The npx skillrepo init command and the Setup Wizard both produce the same result: MCP config files committed to a shared repository so every team member gets the same IDE wiring on clone. The CLI is the recommended approach as it handles all IDEs in one step and also pulls the library.
Prerequisites
- A SkillRepo account on the Business or Enterprise tier
- An access key with at least
registry:readscope - Owner or admin role on the account
Create a shared access key
Go to Settings → Access Keys and create a new key with the registry:read scope. Name it descriptively so its purpose is clear, for example team-shared-key or ci-readonly.
Key security
A read-scoped key can only discover and read skills -- it cannot create, update, or delete anything. This is the minimum scope needed for IDE integration. If your team also publishes skills through MCP, use registry:read,registry:write instead.
Run npx skillrepo init
Run the setup command from your project root. It auto-detects installed IDEs, validates your access key, writes the MCP config for each IDE, sets the access-key env var in .env.local, and pulls your library to disk.
npx skillrepo initYou can also pass the key directly for non-interactive setup:
npx skillrepo init --key sk_live_abc123 --yesThe CLI writes the access key to .env.local (which should be gitignored). Each team member sets their own key when they run the command, or the team can share a single read-scoped key.
Manual configuration (if you cannot use npx)
If npx is not available in your environment, create the config files manually. Use an environment variable for the key so it stays out of version control.
Claude Code — .mcp.json
{
"mcpServers": {
"skillrepo": {
"type": "http",
"url": "https://skillrepo.dev/api/mcp",
"headers": {
"Authorization": "Bearer ${SKILLREPO_ACCESS_KEY}"
}
}
}
}Cursor — .cursor/mcp.json
{
"mcpServers": {
"skillrepo": {
"url": "https://skillrepo.dev/api/mcp",
"headers": {
"Authorization": "Bearer ${env:SKILLREPO_ACCESS_KEY}"
}
}
}
}VS Code + Copilot — .vscode/mcp.json
{
"inputs": [
{
"id": "skillrepo-api-key",
"type": "promptString",
"description": "SkillRepo access key (sk_live_...)",
"password": true
}
],
"servers": {
"skillrepo": {
"type": "http",
"url": "https://skillrepo.dev/api/mcp",
"headers": {
"Authorization": "Bearer ${input:skillrepo-api-key}"
}
}
}
}VS Code uses servers (not mcpServers) and prompts for the access key via an inputs entry since it does not support environment variable expansion in MCP config.
After creating the config manually, run skillrepo update to pull your library to disk.
Commit the MCP config files
Commit the MCP config files the CLI generated. This is what makes the integration zero-setup for the rest of the team — when someone clones the repo, their IDE picks up these files automatically.
# Commit only the MCP config files
git add .mcp.json .cursor/mcp.json .vscode/mcp.json
git commit -m "chore: add SkillRepo MCP integration"Do NOT commit .env.local (contains the access key), .claude/skills/ (each developer pulls their own library via skillrepo update), or .claude/settings.local.json. The CLI adds these to .gitignore automatically on first run.
Team members clone and run npx skillrepo init
When team members clone the repository or pull the latest changes, they run npx skillrepo init to add their own access key. The CLI detects the existing config files, merges in any updates, and writes the developer's key to .env.local.
Developers who prefer not to use npx can set the environment variable manually instead:
echo 'SKILLREPO_ACCESS_KEY=sk_live_their_key' >> .env.localKeeping the library current
Run skillrepo update to pull new versions of every skill in your library. The sync uses ETag caching and delta responses so repeat runs are cheap — a no-op update returns 304 Not Modified and touches no files. A good cadence is once per workday, or wire it into your shell startup if you want it automatic.
When you want to add or remove specific skills from your library, use skillrepo add @owner/name and skillrepo remove @owner/name. Both require a write-scoped access key and update the registry, not just your local copy.
Enterprise Setup
Enterprise tierFor organizations that manage developer tooling centrally, MCP configuration can be deployed through IT administration tools rather than committed to individual repositories. This ensures consistent configuration across all projects and teams.
Managed MCP configuration
Instead of committing .mcp.json or .cursor/mcp.json to every repository, enterprise teams can deploy a global MCP configuration to each developer's machine via IT management tools (MDM, configuration management, or dotfiles repositories).
Shared access keys
Enterprise accounts can create organization-wide access keys that are distributed alongside the managed config. Use a read-scoped key for broad distribution, and set the SKILLREPO_ACCESS_KEY environment variable in the managed environment profile so developers do not need to configure it individually.
IDE-specific enterprise settings
| IDE | Enterprise Configuration |
|---|---|
| Claude Code | Coming soon — requires OAuth integration via the Anthropic Console. Contact your Anthropic account representative for early access. |
| Cursor | Use Cursor's Enterprise MCP admin settings to push MCP server configurations to all seats in your organization. Managed configs appear alongside any project-level configs. |
| Windsurf | Use Windsurf's Team MCP whitelist to pre-approve the SkillRepo MCP endpoint for all team members. Whitelisted servers connect automatically without per-user approval. |
| VS Code + Copilot | Use GitHub Copilot MCP policies to manage allowed MCP servers at the organization level. Policies are enforced through the GitHub organization settings and apply to all members. |
Enterprise tier required
Managed MCP configuration and organization-wide access keys require the Enterprise tier. Contact us at enterprise@skillrepo.dev for pricing and setup assistance.
Per-Developer Setup
If you are setting up SkillRepo for yourself rather than a team, or want to add it to a personal project, follow these steps.
- 1
Run
npx skillrepo initRun the setup command from your project directory. It will prompt for your access key if one is not already set. If you do not have a key yet, create one at Settings → Access Keys. See the Getting Started guide for details.
npx skillrepo initThe CLI auto-detects your IDEs, writes the MCP config and the
.env.localaccess-key file for each one, and pulls your library to disk at.claude/skills/. Runskillrepo updateperiodically to stay current. - 2
Done -- start using skills
Your IDE can now discover and activate skills from your SkillRepo library. Skill content loads live via MCP on each use, and cached copies on disk keep activations fast even when offline.
Manual setup (if you cannot use npx)
If npx is not available, you can configure your IDE manually:
- Create an access key at Settings → Access Keys
- Add the MCP config file for your IDE following the Connecting Your IDE instructions, or use the manual snippets in the Team Setup section above
- Run
skillrepo updateto pull your library to disk
FAQ
Do team members need their own access keys?
Yes — each team member runs npx skillrepo init with their own key. The MCP config is committed to the repo (shared), but the access key lives in each developer's local ~/.claude/skillrepo/config.json and .env.local, both of which are gitignored by the CLI.
What if I add new skills to the library?
Run skillrepo update to pull the latest state of your library. The sync is delta-based, so if you added one skill, only that skill's files are written. Removed skills (tombstones from the server) are deleted locally on the next update. If you want to add a specific skill to your library, use skillrepo add @owner/name instead of re-running init.
Can I use multiple IDEs in the same project?
Yes. npx skillrepo init detects every installed IDE and writes the correct MCP config for each in a single run — .mcp.json for Claude Code, .cursor/mcp.json for Cursor, .vscode/mcp.json for VS Code, and ~/.codeium/windsurf/mcp_config.json for Windsurf. Per-vendor confirmation prompts let you opt out of any one target.
What about Windsurf or other IDEs?
Windsurf is first-class — the CLI writes ~/.codeium/windsurf/mcp_config.json when it detects a Windsurf install. For IDEs the CLI doesn't recognize, run skillrepo init from an empty directory and the CLI prints a copy-pasteable MCP config blob, or pass --ide all to wire up every supported vendor regardless of detection.
What should I commit vs. gitignore?
Commit the MCP config files (.mcp.json, .cursor/mcp.json, .vscode/mcp.json) so every team member gets the same IDE wiring on clone. Gitignore .env.local (contains your access key) and .claude/skills/ (each developer pulls their own library via skillrepo update, and committing the synced content would produce merge noise every time any skill version bumped). The CLI manages the gitignore entries automatically on first run.
Can I use a shared access key for the whole team?
A shared read-scoped access key works for basic skill discovery. However, for audit logging and per-user usage tracking, individual keys are recommended. The MCP config supports environment variable expansion, so each developer can set their own key via SKILLREPO_ACCESS_KEY without modifying the committed config.
Next steps
With your IDE connected, explore the full MCP tool reference or learn how to publish your own skills.