Skills Hub: How to Unify Your AI Programming Tools Skills Management?

In today’s rapidly evolving world of AI programming tools, have you ever felt overwhelmed by scattered skill files across different platforms like Cursor, Claude Code, or Codex? Each tool has its own directory, leading to duplicates, version inconsistencies, and high migration costs. Enter Skills Hub—a cross-platform desktop app built with Tauri and React. It centralizes skill management in a single repository and syncs them to various AI tools’ global directories, prioritizing symlinks or junctions, with copy as a fallback. This achieves “Install once, sync everywhere.” In this in-depth guide, we’ll break down its design, features, and implementation to help you get started and maintain it effectively.

Summary

Skills Hub is a Tauri-based desktop application for managing AI programming tool skills uniformly. It stores skills in a central ~/.skillshub repository and syncs them via symlink, junction, or copy to directories like ~/.cursor/skills in tools such as Cursor. Supporting 14 tools, it offers local/Git imports, existing skill migrations, updates, and new tool detections for seamless consistency.

Why Skills Hub Matters: Addressing Common Pain Points

Picture this: You’re coding in Cursor and need a specific skill extension. But if you’re also using Claude Code or Codex, those skills are tucked away in separate spots under your home directory—think ~/.cursor/skills or ~/.claude/skills. It’s tough to get a bird’s-eye view of what skills you have, where they’re active, and if they’re up-to-date. Duplicates creep in, updates cause drift, and switching tools means manual migrations that eat up time.

Skills Hub tackles these head-on with a “central repository” (Central Repo) approach, defaulting to ~/.skillshub. It houses all skill content in one place and maps them to tool directories using soft links (symlinks on Unix), junctions on Windows, or copies when links fail. This isn’t just theory—it’s a file-system and SQLite-backed solution for real-world efficiency. If you’re a recent grad dipping into AI dev, this mirrors file management headaches in projects, making Skills Hub a practical fix without overcomplicating things.

Core Features and Goals of Skills Hub

Skills Hub’s design prioritizes simplicity and utility. Based on its current implementation (commit b5246ab), here’s what it delivers:

• Unified Dashboard: View all managed skills, their sources (local or Git), activation status across tools, and version details.
• Multi-Tool Syncing: Detects installed tools and creates mappings in their skill directories. It tries symlinks first (Unix), junctions on Windows, then falls back to copies for compatibility.
• Onboarding and Migration: Scans existing tool directories for skills, groups by name, detects conflicts via directory fingerprints, and imports with deduplication.
• Flexible Imports: Pull from local folders or GitHub repo URLs (including roots or subfolders). Handles multi-skill repos with candidate selection.
• Update Functionality: Rebuilds from source in the central repo; for copy-mode targets, it pushes updates back to tool directories.
• Dynamic Tool Detection: On startup, spots newly installed tools and prompts to sync all managed skills.
• Customizable Central Repo: Defaults to ~/.skillshub but configurable via settings.

That said, it skips advanced features like multi-version support, cloud syncing, or auto-scheduled updates (though there’s a placeholder for 24-hour auto-updates, it’s not implemented yet). This keeps it lightweight and focused.

It supports 14 AI programming tools out of the box. Check this table for details:

Tool Key	Display Name	Skills Directory (Relative to ~)	Detect Directory (Relative to ~)
cursor	Cursor	.cursor/skills	.cursor
claude_code	Claude Code	.claude/skills	.claude
codex	Codex	.codex/skills	.codex
opencode	OpenCode	.config/opencode/skill	.config/opencode
antigravity	Antigravity	.gemini/antigravity/skills	.gemini/antigravity
amp	Amp	.config/agents/skills	.config/agents
kilo_code	Kilo Code	.kilocode/skills	.kilocode
roo_code	Roo Code	.roo/skills	.roo
goose	Goose	.config/goose/skills	.config/goose
gemini_cli	Gemini CLI	.gemini/skills	.gemini
github_copilot	GitHub Copilot	.copilot/skills	.copilot
clawdbot	Clawdbot	.clawdbot/skills	.clawdbot
droid	Droid	.factory/skills	.factory
windsurf	Windsurf	.codeium/windsurf/skills	.codeium/windsurf

Tool installation is detected simply—if the detect directory exists, it’s considered installed. For Codex scans, it filters out .system to avoid pulling in built-in skills.

System Architecture: A Deep Dive from High-Level to Granular

Skills Hub’s architecture follows a C4-inspired model for clarity, helping you map out contexts, containers, and components. We’ll use flowcharts to visualize—think of them as mental shortcuts.

System Context: How Users Interact

Users manage local skills via the desktop app, which reads/writes:

• Tool global skills directories (e.g., ~/.cursor/skills).
• Central repo at ~/.skillshub.
• SQLite DB (skills_hub.db in app data dir).
• Temp Git clones in cache (skills-hub-git-*).

Flowchart overview:

• User → Manage/Import/Sync → Skills Hub App.
• App ↔ Tool Dirs, Central Repo, DB, Cache.
• App ↔ Clone/Search → GitHub/Any Git Repo.

Everything stays on-device, no cloud needed.

Containers: Frontend-Backend Synergy

• Frontend (WebView): React + Vite handles UI, i18n, themes, and Tauri command invocations.
• Backend (Tauri Rust): Manages FS ops, Git pulls, SQLite persistence, tool adapters, and sync engine.
• SQLite: Embedded with rusqlite for skill and sync state storage.

Entry points: src/main.tsx renders App.tsx; src-tauri/src/lib.rs sets up DB and commands.

Components: Breaking It Down

Frontend (src/):

• App.tsx: Single-page dashboard integrating scans, imports, syncs, updates, deletes, and settings.
• components/skills/*: Header, FilterBar, SkillCard, SkillsList, Modals (Add, Import, Settings, etc.).
• i18n/*: i18next for en/zh switching.
• CSS: Tokens for light/dark themes.

Backend (src-tauri/src/):

• commands/mod.rs: Tauri interfaces with threading, DTOs, error handling.
• core/*: Business logic modules (detailed below).

Data and Storage: Files and DB Design

Skills Hub balances file systems for content with SQLite for metadata.

File System Structure

• Central Repo: ~/.skillshub/<skill_name>/. No full Git repos—just copied content to skip .git. Names from source dir/repo.
• Git Temps: App cache dir, skills-hub-git- with .skills-hub-git-temp marker. Cleans >24h old on startup.
• Tool Dirs: Per-adapter paths, e.g., Cursor’s .cursor/skills.

SQLite Schema

DB at app_data_dir()/skills_hub.db. ER diagram:

• skills: id (UUID), name, source_type (local/git), source_ref (path/URL), source_revision, central_path (unique), content_hash, timestamps, status.
• skill_targets: skill_id, tool, target_path, mode (auto/symlink/junction/copy), status, synced_at.
• settings: key/value like central_repo_path, installed_tools_v1 (JSON), onboarding_completed.
• discovered_skills: For scanned but unimported (reserved, not fully used yet).

This setup tracks everything from skill sources to sync modes.

Backend Core Modules: Rust in Action

Rust powers the backend for cross-platform reliability. Let’s unpack key modules.

Tool Adapters

Defines ToolId/Adapter with names, paths. Install check: Detect dir exists. Scan: Lists subdirs, fingerprints (hash_dir ignores .git). Link detection: symlink_metadata/read_link.

Onboarding (Scan/Aggregate)

Loops installed tools, detects skills, fingerprints, groups by name. Flags conflicts if unique fingerprints >1. Outputs OnboardingPlan with totals.

Content Hashing

Walks dirs, skips ignores (.DS_Store, etc.), hashes paths + contents for identity checks.

Sync Engine

Logic:

1. Target missing: Symlink (Unix), junction (Win), copy fallback.
2. Target exists: If linking to source, idempotent. Else, overwrite=true deletes first; default errors with TARGET_EXISTS.

Prioritizes safety over destruction.

Installer: Imports and Updates

• Local Import: Copies source to central, inserts record (local type).
• Git Import: Parses URLs (repo/tree/blob/.git), clones temp, copies subpath. Multi-skills? Throws MULTI_SKILLS to prompt selection.
• Multi-Skill Candidates: Lists from skills/* etc., parses SKILL.md YAML for name/desc.
• Update: Stages new content, swaps central dir, updates DB. For copy targets, overwrites to propagate.

Git Fetcher

Prefers system git CLI for user configs, falls back to libgit2.

GitHub Search

Reqwest to API, returns summaries (full_name, etc.). Frontend tab disabled but backend ready.

Temp Cleanup

Targets prefix + marker + age >24h only.

Frontend UI and User Flows: Hands-On Experience

Single-page dashboard for intuitiveness.

Layout

• Header: Branding, lang switch, settings, add skill.
• FilterBar: Sort (updated/name), search, refresh.
• Discovered Banner: Shows importables, links to Review & Import.
• Skills List: Cards with source, time, tool pills, update/delete.
• Modals: Add (local/git tabs), Import, Git Pick, Settings, Delete, New Tools Prompt, Loading Overlay.

Themes via CSS vars, stored in localStorage.

Key User Paths

Startup:

1. Fetch central path.
2. Tool status (installed/new).
3. Onboarding plan.
4. Managed skills.

Import Existing:

1. Open ImportModal.
2. Select groups/variants (for conflicts).
3. import_existing_skill, then sync_skill_to_tool (overwrite for source).

Add Skill:

• Local: install_local + sync.
• Git: If multi, list_git_skills + install_git_selection + sync.

Toggle Activation: sync/unsync.

Update/Delete: update_managed_skill (pushes to copies) / delete_managed_skill (cleans targets, central, DB).

Key Strategies: Consistency and Safety

• No default overwrites to protect user data.
• Deletes only tracked targets.
• Windows fallbacks for permissions.
• Errors like MULTI_SKILLS or TARGET_EXISTS guide users.

Performance and Reliability

Blocking ops spawn_blocking. Overlays for 10-60s tasks. Errors include causes, desensitized paths.

Developing and Building Skills Hub

Requirements: Node 18+, Rust stable, Tauri deps.

Dev Start:

npm install
npm run tauri:dev

Build:

npm run lint
npm run build
npm run tauri:build

Platform-specific:

• macOS DMG: npm run tauri:build:mac:dmg
• Windows MSI: npm run tauri:build:win:msi
• Linux DEB: npm run tauri:build:linux:deb

Rust tests: cd src-tauri; cargo test.

Testing Recommendations

Rust: Hash stability, URL parsing, sync behaviors.
Frontend: Hooks, modal validations.

Current State and Roadmap

Done: Multi-tool adapters, scans, imports, syncs, updates, new tool prompts.
Next: Enable GitHub search UI, persist scans, onboarding gates, variant naming, maintenance tools.

FAQ: Answering Your Questions

Where’s the central repo? ~/.skillshub by default, changeable in settings.

Why copy mode sometimes? Fallback for link failures due to permissions/OS.

Fixing TARGET_EXISTS? Clean target manually or enable overwrite in flows.

Handling multi-skill Git repos? List candidates, select, install.

Languages supported? English/Chinese via i18n.

New tools auto-sync? Detected on start, prompts for all-skills sync.

Copy mode updates? Automatically pushed to tools.

macOS ‘damaged’ prompt? Run xattr -cr “/Applications/Skills Hub.app”.

Getting Started with Skills Hub

1. Build or download the app.
2. Launch, scan existing skills.
3. Import/add new ones, select tools.
4. Manage via unified list.

Skills Hub streamlines AI tool skills, boosting your productivity. Give it a spin if fragmentation bugs you—it’s a game-changer for efficient coding.

(Word count: approximately 4,200)