Myskills

MySkills

One window for every AI agent skill. Claude Code · Codex · Shared pool · anything that reads SKILL.md

English · 中文

---

MySkills is a local desktop app that scans the skill directories you've registered, deduplicates by name + source, and gives you one coherent view of every AI agent skill you have. The default registry is ~/.claude/skills, ~/.codex/skills, and ~/.agents/skills; you can add, remove, or repath platforms in Settings.

A SKILL.md is a Markdown file with YAML frontmatter that tools like Claude Code and Codex load as reusable capabilities — prompts, tooling profiles, agent instructions. Once you use more than one of those tools, copies start to drift across folders. MySkills makes that mess legible, and any write is explicit, reviewable, backed up, and recorded.

Or skip the clicking entirely: connect your agent over MCP and let it run the whole library in conversation — inventory and read skills, organize them into scenarios, install new ones from the catalog, re-align drifted copies, clean up cruft — with every file change gated, backed up, and reversible. See [Drive it from an agent (MCP)](#drive-it-from-an-agent-mcp).

Install

Download the latest signed build for your platform:

→ Releases page

• macOS — universal .dmg (Apple Silicon and Intel). Signed with a Developer ID certificate and stapled with Apple's notary ticket, so it opens with a normal double-click — no Terminal workaround. Requires macOS 13 (Ventura) or later. ~19 MB.
• Windows — .exe installer (NSIS).
• Linux — .AppImage, .deb, or .rpm.

MySkills keeps itself current: on launch it checks the stable release channel and, when a newer version is published, offers a one-click update from the notification or Settings → Updates. Updates are signature-verified before they install.

> The original v0.1.x line was an Electron, Apple-Silicon-only build. It's superseded by the cross-platform Tauri builds (v0.2.0+) and kept on the releases page only for history.

On your desktop

What MySkills puts where:

• The app data directory contains myskills.db, backups/, and staging/. (Dev/preview builds use an isolated myskills-tauri-preview directory so they never touch your real data.)
• Automatic backups are written before every sync write; retention is configurable in Settings.
• AI provider API keys live in the system credential store when AI features are enabled.

Your SKILL.md files are never modified by MySkills. Tags and scenarios live only in the database above.

> iCloud caveat: Don't put ~/.agents/ (your main source directory) inside iCloud Drive. iCloud can "evict" files and leave .icloud placeholders that show up as broken copies — keep the main source on a local path.

What it does

See your library in one place

• List, Kanban (by scenario), and Coverage matrix views. The matrix has one row per unique skill and one column per platform; cell colour shows which copies are in sync vs. out of sync
• Per-skill detail drawer with last-modified time, content hash, and resolved path on disk
• Move to main source to promote one platform's copy as the master; other platforms get a linked copy that stays in sync

Sync writes are reviewable

• Every disk write goes through Plan → Confirm → Execute. A dialog shows you exactly what will change before anything happens
• Destructive operations write to the app data backups/ directory first
• One-click rollback from Sync History
• Writes are staged through a temporary path before replacement, with rollback records for successful writes

Discover and install from skills.sh

• Built-in search against skills.sh — a community catalog of SKILL.md skills; no account needed
• Preview the SKILL.md from GitHub raw before installing
• Install to any combination of platforms via the same plan-confirm-execute pipeline

AI assist (optional, bring your own API key)

• Supports OpenAI / Anthropic / OpenRouter / DeepSeek / Ollama / any OpenAI-compatible endpoint
• AI Lens clusters your library into themes; you can promote any cluster into a real scenario in one click
• Auto-categorize new skills into scenarios you've defined
• AI search in Discover re-ranks catalog results against a natural-language need
• Create Skill turns a rough need into an editable outline, narrows key choices, generates a locally reviewed SKILL.md, and installs only after confirmation
• Each feature has its own toggle. Keys live in the system credential store.

Drive it from an agent (MCP)

myskills-mcp is a standalone Model Context Protocol server — a plain Rust binary, no Node runtime, shipped signed inside the app — that lets an agent (Claude Code, Codex, …) run your whole skill-library lifecycle in conversation, not by clicking around:

• Understand — inventory every skill with per-platform health (synced / source / drifted / broken / disabled), read any SKILL.md, inspect the change ledger
• Organize — create scenarios and sort skills into them
• Acquire — search the skills.sh catalog and install a skill (copied to the source, symlinked across platforms)
• Fix — re-align a skill's drifted/broken copies back to the canonical source, or enable/disable it per platform
• Clean up — delete a skill to the OS trash
• Undo anything — every file change is backed up and recorded; skills_rollback reverses it

It backs onto the same database the app uses. Turn it on in Settings → "Connect your agent (MCP)" (off by default — you own access even though the agent runs the binary) and paste the one-line instruction it generates to your agent. Access is layered: reads + DB organization first; anything that touches files on disk (install / align / enable-disable / delete / rollback) needs a separate "Allow destructive actions" toggle, re-checked on every call. The app's own LLM features aren't exposed — the agent is the brain; the server is the trustworthy, reversible hands.

See [docs/mcp.md](docs/mcp.md) for the full tool reference, build, and client setup.

Privacy

• All processing happens on your machine. No telemetry, no analytics, no background phone-home
• The scanner only walks the folders you configure (default: ~/.claude/skills, ~/.codex/skills, ~/.agents/skills)
• Network calls are limited to: skills.sh catalog search, and your chosen AI provider. Both are opt-in; both ship from your machine directly to the service — never via us
• Settings has a master "Allow external network" switch — turn it off and MySkills runs fully offline

Build from source

npm install
npm run dev         # Tauri dev shell + Next.js dev (:4477)
npm run check:tauri # command bridge audit + Rust fmt/clippy/tests + frontend build
npm run validate:tauri # check:tauri + Tauri desktop bundle
npm run smoke:tauri:launch # launch bundled app and verify isolated preview DB init
npm run smoke:tauri:dmg # mount the macOS DMG and verify preview DB init
npm run smoke:tauri:fixtures # create temporary skill fixtures for desktop parity smoke
npm run build       # Next.js static export
npm run build:tauri # Tauri desktop bundle
npm run build:tauri:stable # Tauri bundle with the future stable app id
npm run smoke:tauri:launch -- --stable-migration-smoke --frontend-smoke # stable startup migration drill
npm run build:tauri:mac:signed # local Developer ID signed macOS Tauri preview
npm run notarize:tauri:mac # notarize, staple, and Gatekeeper-check the signed Tauri DMG
npm run build:tauri:updater -- --bundles app # macOS updater archive + signature
npm run updater:manifest -- --artifacts-dir dist/tauri-updater-artifacts # write latest.json for GitHub Release assets

Legacy Electron commands are kept under *:electron:legacy for the frozen v0.1.x line.

Requirements: Node 22+, npm 10+, Rust/Cargo via rustup, and platform-specific Tauri prerequisites.

Preview auto-update channel

The Tauri preview updater is intentionally release-gated:

1. Bump package.json and src-tauri/tauri.conf.json to a newer semver version, for example 0.2.0-tauri.1.
2. Configure GitHub Actions secrets TAURI_SIGNING_PRIVATE_KEY and TAURI_SIGNING_PRIVATE_KEY_PASSWORD.
3. Push tauri/refactor-v0.2 or run the Tauri Preview workflow manually.
4. After macOS, Windows, and Linux parity checks pass, CI uploads signed updater bundles plus latest.json to the tauri-preview GitHub Release.
5. Installed preview clients show the update from Settings, and a background check can raise a non-blocking toast.

The private updater signing key must never be committed. The public key is embedded in src-tauri/tauri.conf.json; CI signs artifacts with the private key from secrets.

Architecture

The v0.2 line uses a Web control surface with a Rust backend:

| Side | Path | Stack | |---|---|---| | Backend | src-tauri/ | Tauri 2, Rust, rusqlite, custom commands | | Renderer | src/ | Next.js 15 (static export), React 19, Tailwind, shadcn/Radix | | Contract | shared/ | Plain TypeScript types and command/channel constants — dependency-free |

The renderer does not receive direct filesystem, SQL, shell, or HTTP permissions. All filesystem, database, secret, and network-gated work lives behind MySkills-specific Tauri commands.

For deeper architecture see [CLAUDE.md](./CLAUDE.md) — the file is framed as an LLM coding-assistant brief, but the content is plain architecture notes worth reading. The full product spec is in [SPEC.md](./SPEC.md) (Chinese).

How it works (internals)

Skill identity is the pair (name, source_key). source_key is local for now and will be a repo/marketplace slug for future imports. Content is fingerprinted by SHA-256 of SKILL.md — updating a skill bumps its content_hash, not its identity. Scenarios, tags, and any user state survive edits in place.

Writes go through plan → confirm → execute:

1. Plan is pure read: it walks the sources, classifies each cell (in_sync / stale / only_here / missing), computes diff hashes, and pre-allocates backup paths. Output is a typed SyncPlan.
2. Confirm shows you the plan, line by line.
3. Execute backs up first, writes to a temp dir, then atomically renames into place.

Every successful write records before_hash, after_hash, backup_path, and the original dry_run_plan in sync_history — and is rollback-able.

Roadmap

| Version | Theme | Status | |---|---|---| | v0.1 | MVP-A — read-only inventory, scenarios, Discover, optional AI | superseded (frozen Electron line) | | v0.2 | Tauri rewrite — cross-platform (macOS / Windows / Linux), Rust backend, in-app auto-update, plus Create Skill | shipped | | v0.3 | MCP — agent-drivable skill library: a bundled, signed myskills-mcp server + "Connect your agent" Settings panel, with safe, reversible, audit-ledger writes | shipped | | v0.4 | MCP "manage + grow" — the agent can align/fix drift, install from the skills.sh catalog, create scenarios, and enable/disable per platform; all gated + undoable | shipped | | next | Agent skill authoring (write/improve SKILL.md content, behind a hardened security gate); project/plugin-level scanning; multi-machine awareness | planned |

Not planned:

• General-purpose in-app skill editor — Create Skill may generate and install a reviewed SKILL.md, but long-form editing stays in your usual editor
• Cloud sync — MySkills stays local-only by design
• Running skills inside MySkills — execution stays with the agent tools

Status

Solo personal project, actively developed. The shipping line is the cross-platform Tauri build (currently v0.4.0) — a Rust backend with a Next.js UI, signed and notarized on macOS, packaged for Windows and Linux, with in-app auto-update. Since v0.3 it also ships myskills-mcp, an agent-drivable MCP server (bundled + signed). The older Electron, macOS-only v0.1.x line is frozen. The Rust backend has unit coverage for the scanner and the sync/align invariants, and the release workflow signs and publishes macOS / Windows / Linux artifacts on every version tag.

Contributing

Issues and PRs welcome. Before you open one:

1. For non-trivial PRs, file an issue first. MVP scope is intentionally tight, and the architecture has invariants — skill identity, plan→confirm→execute, the IPC boundary — that are easy to violate accidentally. The short list lives in [CLAUDE.md](./CLAUDE.md).
2. Conventional commit style (feat:, fix:, ux:, docs:, chore:). Match the existing log.
3. No automated tests yet. Don't claim "tests pass" — describe what you exercised manually in the PR description.

Credits

• skills.sh — the catalog this app searches against, and the community of SKILL.md authors who made aggregation possible in the first place.
• Built with Tauri, Next.js, shadcn/ui, and Lucide. The frozen v0.1.x maintenance line was built with Electron.

License

[MIT](LICENSE) © 2026 Milk Tang.

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Milktang0128
• Source: Milktang0128/myskills
• License: MIT

Install and usage instructions live in the source repository linked above.