yibie/skills-manager: Native macOS App for Multi-Agent Skill Management

yibie/skills-manager: Native macOS App for Multi-Agent Skill Management

Introduction

If you work with multiple AI coding agents, you've likely hit the same friction: each tool maintains its own skill format, install path, and update mechanism. Claude Code keeps skills in one directory. Cursor uses another. Codex, Gemini CLI, Qwen Code, Roo Code, Continue, OpenHands, OpenClaw — the list keeps growing, and your skills are scattered across incompatible silos. Discovering new capabilities means checking skills.sh, GitHub repos, and agent-specific marketplaces separately. Installing means copying files to the right hidden folder and hoping the agent picks them up. Updating means doing it all again, manually, per agent.

yibie/skills-manager addresses this directly. It's a native macOS application — built in SwiftUI with Swift 6 and SwiftData — that brings discovery, installation, testing, and management of coding agent skills into a single interface. With support for over 40 agents and direct integration with skills.sh, it eliminates the repetitive directory-hopping that slows down developers who rely on AI-assisted workflows. This skills manager macOS coding agents tool is designed for developers who treat AI assistants as core infrastructure, not occasional helpers.

What is yibie/skills-manager?

yibie/skills-manager is an open-source native macOS application maintained by yibie and distributed under the MIT License. As of its last commit on April 27, 2026, the repository has accumulated 350 stars and 30 forks, with Swift as its primary language. The project sits at the intersection of developer tooling and AI workflow infrastructure — it's not a coding agent itself, but rather the management layer that makes multiple agents usable at scale.

The application is architected as a pure local tool: no backend service, no required cloud connection. It reads and writes agent configuration files directly, uses local Git history for version management, and functions entirely offline except for network-dependent features like Discover refresh, search, detail loading, translation fallback, and sandbox LLM calls. This local-first design matters for developers working with proprietary codebases or in air-gapped environments.

Built specifically for macOS 14 (Sonoma) and later, the app leverages modern Apple frameworks — SwiftUI for the interface, SwiftData for persistence, and Swift 6's concurrency model. The repository also includes a terminal UI implementation using Blessed, providing a keyboard-first three-panel interface for developers who prefer staying in the terminal. A historical Ink-based TUI remains in the repository but is no longer the target runtime.

The timing is relevant: the coding agent ecosystem has exploded, with the README listing 42 distinct agents from major players (Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI) to emerging tools (Kiro CLI, Mux, Neovate, Pi). Each represents a potential skill format and install location. yibie/skills-manager's value proposition scales directly with this fragmentation — the more agents you use, the more painful manual management becomes.

Key Features

Unified Discovery via skills.sh Integration

The Discover feature starts fast from a local cache at ~/.skills-manager/cache/discover-directory.json, then refreshes from skills.sh in the background. Search goes beyond the initially loaded list, using the skills.sh full-site API when online and falling back to cached query snapshots when offline. This hybrid approach means you can browse and search skills even without connectivity.

Multi-Agent Installation

Skills Manager detects and scans 42 agents through its AgentRegistry. For agents marked as "Install target," you can install skills to one or multiple agents simultaneously from a multi-install picker. Currently 15 agents support direct installation: Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Augment, Command Code, Continue, iFlow CLI, Kilo Code, Kiro CLI, MCPJam, Mux, Neovate, OpenHands, Pi, Qwen Code, Roo Code. The remaining 27 agents are still detected and scanned from their registered skill directories when installed locally, with scanning support ready for future installation capability.

Built-in Testing Sandbox

Before committing skills to your agents, you can test them in a built-in LLM sandbox. This reduces the risk of installing skills that behave unexpectedly in production contexts.

Real-Time Monitoring

The app monitors all configured agents and their skill directories in real time, giving you visibility into what's installed where without manually inspecting filesystem paths.

Translation Support

Discovered skill summaries include bundled Chinese descriptions, with an on-demand LLM translation button as fallback for newly loaded or uncached entries. The app normalizes local Ollama and LM Studio endpoints to IPv4 loopback (127.0.0.1) at runtime to avoid macOS localhost resolving to IPv6 ::1 — a pragmatic fix for a common local-LLM networking issue.

Library Management

Star favorites, filter by agent or source, update installed skills, and remove unused ones. The starred skills view gives you a personal curated collection across all your agents.

Terminal UI Option

For terminal-native workflows, the Blessed TUI provides three-panel keyboard-first navigation with discover, install/uninstall/star operations, source-file opening, search, detail overlays, and full refresh. Version history is temporarily disabled in the TUI.

Use Cases

Polyglot Agent Workflows

You switch between Claude Code for architecture discussions, Cursor for inline editing, and Codex for shell automation. Each has accumulated skills from different sources. Skills Manager lets you discover a new skill once and install it to all three agents that support direct installation, rather than manually copying files to ~/.claude/skills, ~/.cursor/skills, and ~/.codex/skills (or whatever each agent's actual path is).

Team Onboarding Standardization

Your team uses a mix of agent tools based on personal preference. You maintain an internal skills repository and want new team members to get productive quickly. Skills Manager's monitoring and multi-install capabilities let you verify that required skills are present across all agents in use, rather than documenting separate install procedures for each tool.

Offline-First Development

You frequently work without reliable internet — on planes, in secure facilities, or with intermittent connectivity. The local cache for Discover, cached query snapshots for search, and pure-local architecture mean you can still browse, search, and manage skills that were previously loaded. The only features that require connectivity are refresh, detail loading for uncached items, translation fallback, and sandbox LLM calls.

Skill Evaluation Before Production

You found a promising skill on skills.sh but want to verify its behavior before installing it across all your agents. The built-in sandbox lets you test interactions without modifying your agent configurations. If it performs well, install selectively; if not, you've avoided polluting your skill directories.

Chinese-Language Development Teams

The bundled Chinese description translations and on-demand LLM fallback reduce friction for teams where English isn't the primary working language. The runtime normalization of local LLM endpoints also helps teams using Ollama or LM Studio for internal translation or skill testing.

Installation & Setup

Binary Installation

Download the latest release from the Releases page and drag to Applications.

Build from Source

git clone https://github.com/yibie/skills-manager.git
cd skills-manager
open SkillsManager.xcodeproj

The git clone command creates a local copy of the repository. cd skills-manager enters the project directory. open SkillsManager.xcodeproj launches Xcode with the project file, where you can build and run using standard macOS development workflows. Building from source requires Xcode with Swift 6 support and macOS 14 SDK.

Terminal UI Setup

cd tui
npm exec skills-manager

This runs the Blessed TUI directly without global installation. The cd tui command enters the terminal UI subdirectory. npm exec skills-manager executes the locally defined command.

For a persistent global command:

npm link

Run once inside tui/. This creates a symlink in your npm global bin directory, making skills-manager available from any terminal location.

Then launch from anywhere with:

skills-manager

Requirements

• macOS 14 (Sonoma) or later
• One or more coding agents installed (the app detects available agents automatically)

No additional dependencies are required for the native app. The TUI requires Node.js and npm.

Real Code Examples

The README provides two primary code blocks for installation and TUI usage. Here they are with context:

Building from source:

git clone https://github.com/yibie/skills-manager.git
cd skills-manager
open SkillsManager.xcodeproj

This is the complete build-from-source workflow. Unlike many open-source projects that require dependency managers like CocoaPods or Swift Package Manager resolution steps, this appears to be a self-contained Xcode project. The open command leverages macOS's open utility to launch the .xcodeproj bundle in the default application (Xcode). Once opened, you build with ⌘-B and run with ⌘-R, or archive for distribution. The simplicity suggests the project manages dependencies through Xcode's built-in Swift Package Manager integration rather than external tooling.

Running the TUI locally:

cd tui
npm exec skills-manager

This demonstrates the zero-installation TUI execution pattern. npm exec runs a package's binary without permanently installing it — useful for evaluation. The command looks for skills-manager in the local tui/package.json bin entries. The TUI implementation uses Blessed, a curses-like library for Node.js, which explains the three-panel keyboard-driven interface.

Global TUI installation:

npm link
skills-manager

The npm link command creates a symbolic link from the global npm prefix to the current package. This is a standard Node.js pattern for CLI tool development and local installation. After linking, the skills-manager command resolves globally to your linked development copy. Note that this persists until you run npm unlink or remove the package — it's not a system-wide installation in the traditional sense, but a npm-managed symlink.

These three examples represent the full set of documented commands in the README. The project appears intentionally focused on simplicity — there are no complex configuration files, environment variables, or initialization scripts shown in the documentation.

Advanced Usage & Best Practices

Cache Management

The Discover cache at ~/.skills-manager/cache/discover-directory.json enables fast startup. If you encounter stale data or want to force a refresh, you can remove this file — the app will rebuild it on next launch. For teams, consider versioning this cache in a shared repository if you want consistent discover results across machines.

Agent Registry Extension

The README lists 42 agents with registry IDs. If you use an agent not yet in the supported list, examine the AgentRegistry implementation to understand how detection works. The scan-only agents suggest the registry pattern is extensible — detection requires knowing the skill directory path, while installation requires additional metadata about file format and placement.

Local LLM Endpoint Configuration

The runtime normalization of localhost to 127.0.0.1 for Ollama and LM Studio suggests these are the primary local LLM integrations for translation fallback and sandbox. If you use other local LLM servers, verify whether they exhibit the same IPv6 resolution issue on macOS. The fix is applied at runtime, so no configuration is needed — but understanding this behavior helps diagnose connectivity issues.

TUI vs GUI Selection

The Blessed TUI supports core workflows (discover, install, star, search) but lacks version history. For operations requiring historical comparison or complex filtering, use the native GUI. For quick installs and terminal-centric workflows, the TUI avoids context switching. The historical Ink TUI should not be used — it's retained only as reference.

Skill Conflict Awareness

While not yet implemented, the roadmap includes "Skill conflict detection across agents." Until then, manually verify that skills with the same name but different implementations don't create unexpected behavior when installed to multiple agents. The multi-install picker makes this easy to do accidentally — test in the sandbox first.

Comparison with Alternatives

Skills Manager occupies a specific niche: it's the only tool currently offering unified discovery-to-installation across this breadth of agents on macOS. The trade-off is platform specificity — there's no Windows or Linux version. For developers committed to macOS who use multiple agents, this is a clear win; for cross-platform teams, it's a gap that may require complementary tooling.

The direct skills.sh comparison is worth noting: Skills Manager doesn't replace the directory, it operationalizes it. You still browse skills.sh for discovery (or through Skills Manager's interface), but you gain installation, testing, and management capabilities that the web directory doesn't provide.

FAQ

Does Skills Manager work on Windows or Linux?

No — macOS 14 (Sonoma) or later is required. The SwiftUI and SwiftData dependencies are Apple-platform specific.

Is there a cost to use the app?

No. The project is MIT Licensed and free to use, modify, and distribute.

Do I need all 42 agents installed?

No. The app detects whichever agents you have installed and scans their skill directories. You only need one agent for basic functionality.

Can I use Skills Manager without internet?

Partially. Discovery search, skill installation, library management, and monitoring work from cache offline. Refresh, detail loading for new items, translation fallback, and sandbox LLM calls require connectivity.

How does the sandbox LLM work?

The README doesn't specify the sandbox implementation details. It uses LLM calls for testing skills before installation, with local endpoints (Ollama, LM Studio) supported via runtime normalization.

What's the difference between "Install target" and "Scan" agents?

Install target agents support direct installation from Skills Manager's multi-install picker. Scan agents are detected and monitored but require manual installation — their registry entries prepare for future installation support.

Can I contribute new agent support?

Yes. The project welcomes issues and PRs. See CONTRIBUTING.md for guidelines.

Conclusion

yibie/skills-manager solves a genuinely painful problem for developers deep in the AI coding agent ecosystem: the fragmentation of skill management across dozens of tools. Its native macOS implementation, local-first architecture, and direct skills.sh integration make it a practical choice for developers who use multiple agents daily and want to reduce the operational overhead of keeping skills synchronized.

The 350-star, actively maintained project (last commit April 2026) is best suited for macOS-using developers already committed to AI-assisted workflows with two or more supported agents. It's less relevant if you use a single agent with its own skill marketplace, or if you primarily work on Windows or Linux. The TUI option extends its appeal to terminal-centric users, though the full feature set remains in the GUI.

If you're managing skills across Claude Code, Cursor, Codex, and others — or planning to — download yibie/skills-manager from GitHub and evaluate whether it reduces your context-switching overhead. The MIT license and open-source nature mean you can inspect, modify, and contribute back if your use case extends beyond the current 42-agent registry.

For related reading on structuring developer tooling workflows, see [INTERNAL_LINK: macOS developer productivity tools].