amElnagdy/delegate-skills installation guide

Installing `amElnagdy/delegate-skills` on macOS Tahoe (Apple silicon)

What this repository is

`delegate-skills` is a **Claude Code extension package built from Agent Skills**, not a standalone coding application. Its skills teach an orchestrating agent such as Claude Code how to delegate a bounded coding task to a separate installed coding-agent CLI, wait for that CLI, inspect its result, review the Git diff, rerun the project’s gates, and leave the final commit to the reviewer.

**Classification:**

• **Install mode:** Claude extension
• **Mechanisms:** context injection, orchestration, and external CLI launching
• **Setup effort:** low for the skill package itself; higher when you add and authenticate one or more implementer CLIs
• **Confidence:** high

The evidence is direct: the repository contains `SKILL.md` instruction packages, installs through the Skills CLI, explicitly supports `--agent claude-code`, and bundles Node-based relays that launch separate CLIs and Git. It is not an MCP server, Claude Code hook, or independent desktop app.

macOS Tahoe and Apple-silicon support

The supplied documentation supports bash/zsh on macOS and reports macOS runs for multiple skills, including `claude-delegate`, `codex-delegate`, `grok-delegate`, `kimi-delegate`, and others. The package’s own scripts use Node built-ins and have no package dependencies.

However, the supplied files do **not** provide a formal macOS Tahoe compatibility statement or an Apple-silicon compatibility matrix. Installation on Tahoe is therefore reasonable based on the documented general macOS support, but it is not specifically certified by the evidence. Compatibility of each optional implementer CLI is separate and must be checked in that skill’s `SKILL.md`.

Before you begin

You need:

1. **Claude Code**, already installed and usable as your orchestrating agent. The supplied repository files do not document how to install Claude Code, so this guide does not invent a command for it.
2. **Node.js 18 or newer**, including `npx`.
3. **Git**.
4. A Terminal session using macOS’s normal zsh shell.
5. For actual delegation, at least one supported implementer CLI installed and authenticated. This is not required merely to install or use `delegate-setup` for discovery.

Open **Terminal** from Applications → Utilities. Confirm that Node, `npx`, Git, and Claude Code are available using the installation or version-checking method provided by their respective first-party documentation. No general-purpose Node or Git installation command is supplied by this repository.

Do **not** run `.cursor/install.sh` as a normal Mac installation method. That file identifies itself as provisioning for a Cloud Agent VM, assumes `nvm`, and writes shims into `/usr/local/cargo/bin`. It is not the documented end-user installation path for this package.

Step 1: Inspect the available skills

Before installing anything, ask the documented Skills CLI to list what the repository provides:

npx skills add amElnagdy/delegate-skills --list

This package currently describes one setup utility, `delegate-setup`, plus implementer-specific skills such as `claude-delegate`, `codex-delegate`, `aider-delegate`, `kimi-delegate`, and others. Each implementer skill drives a separate CLI; installing the skill does not itself install or authenticate that separate product.

Because `npx` and the Skills CLI obtain package content externally, review the displayed source and skill selection before approving installation.

Step 2: Choose an installation scope

For the simplest complete installation, install the package with the repository’s documented command:

npx skills add amElnagdy/delegate-skills

Follow any agent-selection prompts shown by the Skills CLI and select Claude Code when offered.

If you want only the fleet-configuration utility, install just that skill instead:

npx skills add amElnagdy/delegate-skills --skill delegate-setup

If you want one implementer integration without the rest, the repository gives Codex as this example:

npx skills add amElnagdy/delegate-skills --skill codex-delegate

It also documents an explicit Claude Code target for that skill:

npx skills add amElnagdy/delegate-skills --skill codex-delegate --agent claude-code

Use the explicit Claude Code form when you want to avoid ambiguity about the destination agent. Do not assume that `codex-delegate` installs Codex: it installs only the delegation skill. The `codex` CLI must separately be installed and authenticated according to its own first-party instructions.

For a global Skills CLI installation rather than a project-local one, the repository documents:

npx skills add amElnagdy/delegate-skills --global

Choose project-local installation when you want the skills associated with one project. Choose global installation when you deliberately want them available across projects. The supplied files do not document the Skills CLI’s exact destination directories, so this guide does not guess them.

Step 3: Start with safe discovery

After installation, open Claude Code and ask it to load the setup skill using the repository’s documented wording:

Use $delegate-setup to discover my installed implementer CLIs and create a fleet for feature, tests, and UI work.

`delegate-setup` is the safest first test because it does not dispatch coding work. It discovers available CLIs, proposes named fleet lanes, shows the complete configuration, and writes it only after explicit approval.

Discovery may invoke installed CLIs for version or model-list probes. The repository’s own discovery scripts claim no network calls of their own, but an implementer CLI being probed may contact its service.

Read Claude Code’s proposed fleet carefully. Approve configuration only if the named implementers and optional model or effort settings match what you intended.

Step 4: Install and authenticate an implementer

To perform work, choose one implementer from the repository’s table and read that skill’s prerequisites. Do not install every CLI unless you actually intend to use it.

For example, `codex-delegate` requires the separate `codex` CLI. `claude-delegate` starts another Claude Code session. Other skills require their corresponding binaries, such as `aider`, `agy`, `grok`, `kimi`, `opencode`, `pi`, `omp`, `vibe`, or `oz`.

Each CLI has different security properties. Some have workspace or read-only modes; others have no sandbox or no enforceable read-only mode. Authentication may involve a browser login, subscription, API key, or provider-specific configuration. Follow only the commands in the selected skill’s own `SKILL.md` and the implementer’s first-party documentation.

Step 5: Try a bounded delegation

Once the matching CLI is installed and authenticated, open the Git repository where you want work performed. Start with a small, clearly bounded task. The repository provides this direct example for Codex:

Use $codex-delegate to have Codex implement the refactor in services/billing/, then review and commit it.

The named directory in that example is illustrative; describe your real task and real paths in Claude Code. The orchestrator should create a self-contained brief because the implementer does not receive your existing Claude Code conversation.

The normal loop is:

1. Claude Code writes a brief.
2. The skill’s `relay.mjs` launches the selected implementer.
3. The relay waits and creates a structured `result.json`.
4. Claude Code and you inspect `touchedFiles` and the working-tree diff.
5. The project’s actual test, lint, and build gates are rerun independently.
6. Only the reviewer lands the commit.

The relays are designed not to commit. Aider is especially notable because Aider normally commits by default; its relay explicitly disables Aider’s automatic and dirty-worktree commits.

Step 6: Review before committing

Never accept the implementer’s success report as proof. Inspect the Git-visible changes:

git diff

Also rerun the project’s documented gates yourself. Their commands differ by repository and are not supplied here, so this guide cannot provide generic replacements.

Check that the diff matches the brief, contains no unrelated edits, and does not include secrets or generated files you did not expect. `touchedFiles` and Git status are review aids, not complete security records: ignored files, reverted writes, and writes outside the repository may not appear.

Some implementers—including Pi, Oh My Pi, Kimi, and Warp’s `oz agent run`—lack a sandbox or a fully enforced read-only mode. Use only implementers whose permission model you understand, preferably from a clean worktree, and grant full-access or bypass options only when you deliberately accept the risk.

Updating, pinning, and removal

The README says installations can be pinned by appending an **existing** release tag in the form `@vMAJOR.MINOR.PATCH`, and that the Skills CLI pins by Git ref rather than `metadata.version`. The supplied metadata does not establish which release tags currently exist, so verify a real tag on the repository before constructing a pinned command.

No end-user update or uninstall command is documented in the supplied first-party files. Use the Skills CLI’s own first-party documentation for those operations rather than guessing a command.

Installation is complete when

• Claude Code recognizes the installed `$delegate-setup` or chosen `*-delegate` skill.
• `delegate-setup` can list available implementer CLIs and present a fleet proposal.
• Your selected implementer CLI is separately installed and authenticated.
• A bounded trial dispatch finishes with a reviewable result and leaves the commit under your control.

Repository: <https://github.com/amElnagdy/delegate-skills> License: MIT