# SkillDock: a desktop skill manager for Claude Code, Cursor and Codex

> SkillDock is a Rust and Tauri desktop app that scans the real skill and MCP directories of more than thirty AI coding tools, keeps Git-backed skills and plugins as actual repositories, and previews diffs before you update or push. It solves file copying between tools, at the cost of being a GUI-only tool with a macOS and Windows build.

**wanghuan9/skilldock** — SkillDock is an AI skill manager and skill management desktop app for Claude Code, Cursor, Codex, Windsurf, Gemini CLI, and other AI coding tools. Install, organize, edit, sync, and update Skills, MCP servers, and plugins with real-directory scanning and Git-aware Diff previews. AI Skill Manager / Skill 管理软件 / MCP 管理工具.

- Repository: https://github.com/wanghuan9/skilldock
- Website: https://github.com/wanghuan9/skilldock/releases/latest
- Stars: 603 · Forks: 27
- Language: Rust
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/wanghuan9-skilldock

## The problem SkillDock targets: the same skill in six tool directories

Every AI coding tool keeps its own skills and MCP configuration in its own place. A skill that works in Claude Code does not automatically appear in Cursor, Codex or Windsurf; the usual workaround is copying a folder and pasting JSON into another config file. The README frames the goal as team collaboration without intermediate handoff directories: "Publishers can modify skills or plugins locally and push changes back with one click; users can update with one click while seeing who updated the package and what changed." The audience is therefore a developer or small team running several agents at once and maintaining shared skills, not a solo user of a single tool.

The supported tool list is unusually long for a project at version 1.0.20: Claude Code, Codex, Cursor, Windsurf, IntelliJ IDEA, OpenCode, Gemini, Antigravity, Continue, GitHub Copilot, Qwen Code, Trae, Cline, Roo Code, Kilo Code, Kiro, Goose, Junie, Augment, CodeBuddy, Droid, OpenClaw, CommandCode, Crush, Qoder, Zencoder, Hermes, iFlow, Pi, OMP, Grok Build, MiMo Code and WorkBuddy. That breadth is the product's main claim, and it is also where the maintenance burden sits: each tool can move its config directory, and the app has to keep up.

## Real-directory scanning and Git-aware diffs: how SkillDock works

SkillDock does not keep its own copy of your skills and symlink them out. According to the README it "scans each tool's real Skill directory, shows managed and unmanaged Skills, and lets users preview local changes before updating or pushing." That distinction matters. A skill installed outside the app still shows up, labelled unmanaged, and can be imported into SkillDock or removed from the current tool. Nothing is invisible just because it was not installed through the app.

Git-backed skills and plugins are kept as real repositories rather than vendored snapshots. The README states that SkillDock detects upstream updates, local edits and pending pushes, and previews changes before updating or pushing. The diff surface is built on CodeMirror: package.json lists @codemirror/merge, @codemirror/state and @codemirror/view, so the merge view is a real editor component rather than a text dump. The README also claims you can revert individual files or hunks, which is the feature that makes a diff view worth having.

The three package types sit in a hierarchy. Plugins are managed as higher-level packages and can expose skills, agents, commands, MCP integrations and host-specific capabilities; SkillDock installs the package once, tracks its source, and lets you enable or disable it per host. MCP servers are handled separately: the app scans supported app config files, shows the server command and source, and lets you toggle server sync per tool, with tool-level enablement on top. The stack underneath is Tauri 2 with a React and Vite front end and a Rust backend in src-tauri/.

## Installing SkillDock and managing your first skill

SkillDock ships as a desktop application. The README points to the releases page for downloads and to docs/install-troubleshooting.md when the install fails, and the badge in the README lists the supported platforms as macOS Apple Silicon and Windows x64. There is no documented Linux build, and no package manager instructions in the README.

If you want to build from source instead, the repository is a Tauri project with the usual two-step flow. Dependencies first, from the repository root:

```bash
npm install
```

Then run the desktop app in development mode. The package.json script desktop:dev maps to tauri dev, so this compiles the Rust backend and opens the Vite front end in a native window:

```bash
npm run desktop:dev
```

Building a distributable uses desktop:build, which maps to tauri build. The Rust side can be checked on its own with tauri:check, which runs cargo check inside src-tauri/:

```bash
npm run tauri:check
```

For a first real use, open the Skills view. The README describes filtering by management status, so the entries you did not install through SkillDock appear as unmanaged. Pick one, use import to bring it under management, then open the tool sync panel on the skill detail screen and enable it for the tools you actually use. The same pattern applies to MCP: the MCP view lists servers found in supported config files, and the per-tool toggles decide which configs get the server. If you would rather not manage an entry, the README says you can remove it from the current tool directly.

## Where SkillDock gets in the way

The platform support is the first constraint. The README badge lists macOS Apple Silicon and Windows x64 only. On Linux you can read the source and build the Tauri app yourself, but there is no documented Linux artifact and no support statement, so treating it as a cross-platform tool would be wrong.

Second, this is a GUI application with no documented CLI. Everything the README describes happens through the window: the skills library, MCP management, plugin management, diff review, tool sync. If your skills are deployed by a CI job or a dotfiles script, SkillDock does not replace that pipeline, and its one-click sync is not scriptable. The package.json scripts are build and release tooling for the app itself, not a user-facing command line.

Third, the Git features assume the upstream repository is well behaved. The README promises detection of upstream updates, local edits and pending pushes, plus revert of individual files or hunks. It does not document what happens when a skill directory has diverged badly, when the remote is gone, or when a merge conflict appears outside the app. The README does not document rollback for an update that goes wrong, and the install-troubleshooting document covers installation, not recovery. If you need a guaranteed undo path for a shared skill, verify that behaviour yourself before depending on it.

Finally, version churn is visible in the release history: v1.0.18, v1.0.19 and v1.0.20 all landed within two days in September 2026. Rapid patch releases after a 1.0 line usually mean fixes are still arriving quickly, which is fine for early adopters and less fine if you pin versions for a team.

## SkillDock compared with hand-rolled symlinks and dotfiles

The alternative most teams already use is a dotfiles repository plus symlinks: keep skills in one Git repo, symlink each into ~/.claude/skills, ~/.cursor/... and the rest, and let Git handle history. That approach is scriptable, works on any OS, and has no GUI to learn. Its weakness is exactly what SkillDock targets. Symlinks break on Windows without developer mode, every new tool means a new link, MCP servers live in JSON files that the symlink trick does not cover, and there is no per-tool view of what is managed versus stray.

The other alternative is per-tool marketplaces and installers. The README notes that SkillDock itself installs skills from skills.sh and ClawHub and MCP servers from MCP.Directory, so those catalogues exist independently. Using them directly means less software, but you get one catalogue per tool and no shared view across Cursor, Codex and Claude Code. SkillDock's difference is that it treats the tool directories as the source of truth and adds a management layer on top, rather than asking you to move your files into its own store.

## Maintenance, licence and upgrade cost

SkillDock is MIT licensed, with the LICENSE file at the repository root and the same identifier in package.json. For most users that means you can read, modify and redistribute the source, including in commercial settings; the usual MIT obligation is keeping the copyright notice with copies. This is not legal advice, and if you redistribute a modified build, read the licence text yourself.

The last push to the repository was on 2026-09-08, and the most recent release is v1.0.20 from the same day. The repository is not archived. Upgrade cost is low by design: package.json includes @tauri-apps/plugin-updater, and the README lists update checks in the settings screen alongside the app storage directory, default editor, install behaviour, themes and card layout. So the app can check for its own updates rather than requiring a manual download each time.

The cost that does not go away is the tool matrix. More than thirty supported tools means each one's skill and MCP config locations have to be tracked, and a tool that moves its directory breaks the sync for that tool until SkillDock ships a fix. That is the trade-off you accept in exchange for not hand-editing config files.

## Conclusion

Adopt SkillDock if you run two or more of the supported agents and are tired of hand-copying skill folders and editing MCP JSON per tool. Skip it if you work only on Linux, prefer a CLI in CI, or want something other than a GUI for an unattended pipeline. Before trusting it with a shared repository, install v1.0.20, open the diff view on one Git-backed skill, and confirm that the staged, unstaged and incoming changes it shows match what git status reports in that directory.

## FAQ

### What is SkillDock used for?

SkillDock is a desktop manager for AI coding skills, MCP servers and plugins. It scans the real skill directories of tools such as Claude Code, Cursor, Codex and Windsurf, lets you install, edit, enable and sync entries per tool, and previews Git diffs before updating or pushing.

### What is skill software in the context of AI coding tools?

In SkillDock's terms, a skill is a local package that an AI coding tool loads, and skill software is the layer that manages those packages. SkillDock shows managed and unmanaged skills per tool, preserves source metadata, and keeps Git-backed skills connected to their upstream repository.

### What are the skills for AI coding agents?

SkillDock treats skills as installable units that can come from skills.sh, ClawHub, a Git repository or a local folder. A plugin is a higher-level package that can bundle skills, agents, commands and MCP integrations, and SkillDock enables or disables those per host tool.

### What is the purpose of a skill in SkillDock?

The purpose is to give a coding agent reusable instructions and capabilities that can be shared across tools. SkillDock's stated goal is team collaboration without intermediate handoff directories, so a publisher can push changes and a user can update while seeing what changed.

## Sources

- [License: MIT](https://github.com/wanghuan9/skilldock/blob/main/LICENSE)
- [Project website](https://github.com/wanghuan9/skilldock/releases/latest)
- [README](https://github.com/wanghuan9/skilldock/blob/main/README.md)
- [Releases](https://github.com/wanghuan9/skilldock/releases)
- [wanghuan9/skilldock on GitHub](https://github.com/wanghuan9/skilldock)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/wanghuan9-skilldock