Search skills/

delegate-skills Claude skills

Twenty skills that hand a coding task to another agent CLI (Codex, Cursor, Aider, Claude and many more) in the background, then leave the diff review and commit to you.

amElnagdy/delegate-skills 20 skills Planning, TDD & debuggingSkill & agent tooling
Our verdict Recommended

A careful, dependency-free delegation layer with explicit approval and review steps; know which implementers run without a sandbox.

4/5 Depth expertise shipped ! Security Broad access 15d Maintenance Updated 15 days ago 2.5K Adoption stars OK License MIT, commercial OK

What delegate-skills does

delegate-skills lets one orchestrating agent send implementation work to a different coding agent CLI installed on your machine, while you keep the review and the commit. There is one delegate skill per implementer, including codex, claude, cursor, aider, cline, opencode, copilot, grok, kimi, agy (Antigravity), pi, qoder, warp and zcode. A delegate-setup skill discovers which CLIs you have, proposes named lanes such as feature, tests and ui, shows the full config, and writes it only after approval. You can then delegate by lane or pick an implementer directly.

Each skill runs a small Node relay script that launches the implementer and git. The relays start the CLI as a background job, support read-only modes, resume of earlier sessions and queued tasks, and fail loudly if you use the wrong skill for a lane. Project-level lane config is bound to your setup approval, so a cloned or edited project config fails closed until you re-approve it. The README says the relay scripts use Node built-ins only, with no dependencies, no network calls of their own, no credentials and no telemetry. There are about 20 skills averaging 9 KB with references, scripts and CI-tested relays.

Good for

  • Developers who want a second agent to do implementation while the first one reviews
  • Routing feature, test and UI work to different CLIs
  • Comparing implementers on the same task

Not for

  • Tasks small enough to do inline
  • Environments without sandboxing for CLIs that write with no approval prompts

What's inside depth 4/5

20 skills averaging 9.5 KB, each with references and a relay script, plus CI-run relay tests and a shared smoke matrix.

Skills
20
Reference docs
75
Scripts
28
Tests / evals
2
Templates
0
Avg SKILL.md
9.3 KB

Counted from the repository file tree. How we score depth.

Dependencies and costs

  • Node.js and git
  • At least one implementer CLI installed and logged in (Codex, Cursor, Aider, Cline and others)
  • Bash or zsh; Git Bash or WSL on Windows
  • Telemetry: none found; the README states the relay scripts send no telemetry and make no network calls of their own.

How a delegation run works, step by step

  1. Install the pack with npx skills add amElnagdy/delegate-skills.
  2. Ask your orchestrating agent to build a fleet. The README gives this prompt:
Use $delegate-setup to discover my installed implementer CLIs and create a fleet for feature, tests, and UI work.

Setup lists the CLIs it finds, proposes lanes, shows the complete configuration, and writes nothing until you approve. It never dispatches work itself. You can make the config global or limit it to one repository. 3. Dispatch through the matching *-delegate skill with --lane <name>. Explicit flags override the lane's dials (model, effort, variant). 4. If you only need one implementer, or want one-off settings, skip setup and name the skill directly:

Use $codex-delegate to have Codex implement the refactor in services/billing/, then review and commit it.
  1. The orchestrator reviews the diff and runs your gates. You land the commit.

Every skill uses the same split of roles. The orchestrator writes the brief and makes the judgment calls, the implementer edits the working tree in its own session, and the orchestrator verifies the result. The loop only needs an agent that can run shell commands and read files. The skills are designed for and run on Claude Code, and the agy skill describes other orchestrators as "designed-for, not yet proven."

Implementer-specific gotchas

Each SKILL.md lists its own prerequisites. A few of them affect whether the diff you get is reviewable at all.

  • Aider commits by default. --auto-commits and --dirty-commits both default to on, and the second one commits your own uncommitted work before Aider starts editing. The relay always passes --no-auto-commits, --no-dirty-commits and --no-gitignore. If you run aider by hand outside the relay, pass the first two yourself.
  • Antigravity in headless mode. In --print mode, agy cannot ask for write permission and may deny it automatically. The relay detects that denial and does not report the run as complete. Check agy help and agy models before the first dispatch.
  • Claude Code on macOS. Login credentials live in the Keychain. If the orchestrator's sandbox blocks Keychain access (the skill says Codex's sandbox does), claude auth status can report loggedIn: false even though the login is valid. Re-run the check, and the dispatch, outside that sandbox.
  • No read-only or resume on some CLIs. Kimi always runs in auto permission mode and has no read-only option. Cline has no headless resume. Command Code's only headless write state is --yolo, with no sandbox.
  • codex-background edits your Codex config. Its first-run bootstrap updates $CODEX_HOME/config.toml (default ~/.codex/config.toml). The skill says it makes a backup first.

Files in the repository

The repo has 178 files across 20 skill folders. Most *-delegate folders contain one SKILL.md, four reference files and one relay script. delegate-setup has two references, including the delegate-fleet.v1 schema that documents config paths, supported dials and overlay behavior, plus four scripts. codex-background is built differently from the rest: six scripts, two test files and one reference. Relay smoke tests run in CI against a shared smoke matrix, and the README documents native Windows checks for several implementers.

Security review

Broad access

This skill asks for more access than most, or sends data to another service. That is usually a design choice rather than bad intent, but you should know before you install it.

  • Turns off permission prompts or safety checksThe relay defaults to a write-capable --yolo run of Command Code, which edits the target repository without per-action approval and can write .git.skills/commandcode-delegate/SKILL.md:104
  • Turns off permission prompts or safety checksA fresh Cursor run defaults to write-capable with --force (commands run without approval) and the relay always passes --trust; plan mode is opt-in.skills/cursor-delegate/SKILL.md:129
  • Turns off permission prompts or safety checksOh My Pi has no sandbox and a write-capable relay run always passes --yolo; other relays pre-approve tools by default too (cline --auto-approve, opencode --auto, grok --always-approve inside a sandbox, qoder auto).skills/omp-delegate/SKILL.md:152

A set of skills that let one coding agent hand work to another agent CLI (Codex, Cursor, Aider, Cline, Grok and about a dozen more) through local Node relay scripts. Several relays default to write-capable runs with the delegated agent's approval prompts switched off (--yolo, --force, --auto-approve), so the delegated agent can edit and run commands in the target repo unprompted. The scripts have no network code of their own, but the CLIs they launch contact their own services.

Worth knowing

  • Relies on a CLI or package we could not reviewEach *-delegate skill launches a separate coding-agent CLI (codex, claude, cursor-agent, aider, cline, opencode, grok, kimi, copilot and others) plus git; those programs and the model services they call are not in the repo.README.md:67
  • Changes files outside your projectThe optional codex-background bootstrap, run only after the user is told, edits $CODEX_HOME/config.toml (backed up first) to add an MCP server block and writes a registry; delegate-setup/scripts/config.mjs also writes lane config to ~/.config or the project after explicit approval.skills/codex-background/scripts/bootstrap.mjs:2
  • Installs packages or toolsA Cursor Cloud Agent setup script runs nvm install 22 and symlinks node/npm/npx/corepack into /usr/local/cargo/bin on that VM..cursor/install.sh:33

What we checked

The repository (178 files) on Oct 29, 2026. Not a full review: we read 2 of 69 code files; it relies on code outside the repository: the implementer CLIs and their model services (codex, claude, cursor-agent, aider, cline, opencode, grok, kimi, copilot, agy, qoder, warp, zcode and others); npm package `skills` used in docs/CI (`npx skills`); about 65 of the 69 code files (relay.mjs, bootstrap/server/supervisor, setup scripts and tests) were pattern-scanned for network, shell, file-write and config use rather than read line by line.

NVIDIA SkillSpector static scan: 205 pattern hits (Excessive Agency 145, Agent Snooping 24, MCP Rug Pull 19, Privilege Escalation 7, Tool Misuse 5, Rogue Agent 3). The 205 hits are mostly 'auto-approve'/'--yolo' flag documentation (recorded as disables_safety), skill-enumeration matches on README links, unpinned npx mentions in CI and install scripts, and delegate command lines like claude -p ... and codex exec ..., which are the skill's purpose. Searches for fetch/http/net/WebSocket in all scripts found none; no allowed-tools frontmatter was found.

A review, not a certification. Skills change after we check them — read the files before installing.

License

MIT — commercial use allowed.

Can it run unattended?

Yes. Tasks run as background jobs with queueing, resume of sessions and review gates, though you still land each commit yourself.

Alternatives to delegate-skills

Claude Octopus

nyldn/claude-octopus

An escalation layer that runs tasks past up to twelve external AI providers (Codex, Copilot, Ollama, Grok, more) with a consensus gate, plus 63 skills.

With caveats Check first Depth 4/5

Paperclip

paperclipai/paperclip

A self-hosted app for orchestrating teams of AI agents with org charts, budgets and approvals; its skills are mostly maintainer workflows.

With caveats Broad access Depth 4/5

Orca

stablyai/orca

An open-source desktop and mobile app for running several coding agents in parallel git worktrees, plus 11 thin skills that hand agents the app's CLI.

With caveats Check first Depth 2/5

FAQ

What is delegate-skills?

It is a set of agent skills, one per coding CLI, that lets an orchestrating agent delegate an implementation task to another CLI in the background and then review the resulting diff.

How do I install delegate-skills?

Run npx skills add amElnagdy/delegate-skills, then ask your agent to use delegate-setup to discover installed CLIs and create lanes. You need at least one implementer CLI installed and logged in.

Is delegate-skills safe to run?

The relays are dependency-free Node scripts without network calls of their own. The risk comes from the implementers, some of which run with approvals disabled and no sandbox, so use read-only mode or an isolated environment when in doubt.

Can I delegate a coding task to a local model?

Yes, through aider-delegate. Aider can reach any OpenAI-compatible endpoint, including llama.cpp, Ollama, vLLM or LM Studio, via --api-base. A local endpoint still needs a non-empty OPENAI_API_KEY.

Do I need an implementer CLI installed before running delegate-setup?

No. delegate-setup requires no implementer CLI. It detects whichever ones are present. You do need at least one installed and logged in before you can dispatch work.

Sources: GitHub repository (stars, license, file tree, last push Oct 14, 2026). Review based on the README and SKILL.md files as published.