Agent skill

Zcode Delegate

by amElnagdy in amElnagdy/delegate-skills

Delegate a coding task to the Z.AI ZCode CLI as a background implementer, then review its diff and land it yourself.

MITAuto-check passedDevelopment

Install Zcode Delegate

skills CLI
$ npx skills add amElnagdy/delegate-skills --skill zcode-delegate -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install amElnagdy/delegate-skills zcode-delegate --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/amElnagdy/delegate-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/zcode-delegate .claude/skills/zcode-delegate && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
zcode-delegate
GitHub stars
2.3k
Token cost
~2.4k tokens
SKILL.md length
1,111 words
Files
6 (incl. scripts, references)
Skills in repo
18
Repo updated
First seen
Licence
MIT

At a glance

Delegate a coding task to the Z.AI ZCode CLI as a background implementer, then review its diff and land it yourself.

  • Works in 5 steps: Write the brief → Dispatch → Wait for completion → …
  • Wants to hand implementation work to ZCode — phrasings like have ZCode do X
  • SKILL.md covers When NOT to use this, Prerequisites (check once), Authenticating the headless CLI and Autonomy — read this before…, plus 4 more sections
  • Runs JavaScript scripts from its folder; calls node; reaches api.z.ai; needs ZAI_API_KEY and ZCODE_API_KEY

What it does

Zcode Delegate is an agent skill from amElnagdy/delegate-skills. Delegate a coding task to the Z.AI ZCode CLI as a background implementer, then review its diff and land it yourself. Use this whenever the user wants to hand implementation work to ZCode — phrasings like "have ZCode do X", "delegate this to ZCode", "run it through ZCode", or "use ZCode to implement/fix/refactor" — or to run a queue of coding tasks through ZCode while staying the reviewer. DO NOT USE for tasks small enough to do inline, or when the user wants the code written directly without delegating.

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including scripts and reference files (for example `references/dispatch-and-poll.md`, `references/multi-task-queues.md` and `references/review-and-land.md`). Compatibility notes: Requires the zcode CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm…

It sits in Development. It works with Zhipu GLM. The repository describes itself as: Delegate a coding task to a separate coding agent CLI, review the diff, land the commit yourself — one per implementer. The licence is MIT.

When your agent uses it

  • Wants to hand implementation work to ZCode — phrasings like have ZCode do X
  • Delegate this to ZCode
  • Run it through ZCode
  • Use ZCode to implement/fix/refactor —

Example prompts

  • “have ZCode do X”
  • “delegate this to ZCode”
  • “run it through ZCode”
  • “/zcode-delegate”

Requirements

  • Node.js
  • A credential in ZAI_API_KEY
  • A credential in ZCODE_API_KEY
  • Compatibility (from SKILL.md): Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows).

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Write the brief
  2. Dispatch
  3. Wait for completion
  4. Review — do not trust the self-report
  5. Land it

What it can do on your machine

Read from SKILL.md and the folder at commit 6826b36. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (JavaScript), which the agent can run.

    Shell commands in SKILL.md call:

    • node

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • api.z.ai

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • ZAI_API_KEY
    • ZCODE_API_KEY
    • ANTHROPIC_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows).

    From compatibility in the SKILL.md frontmatter.

Context cost

Zcode Delegate loads about 2.4k tokens when it runs, and up to ~7.2k if it reads all its reference files. Until then it costs about 131 tokens; SKILL.md has 1,111 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~131
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from amElnagdy/delegate-skills at commit 6826b36, republished under its MIT licence (© amElnagdy). 1,111 words, ~2,393 tokens.

Download SKILL.mdSave it as .claude/skills/zcode-delegate/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
zcode-delegate
description
Delegate a coding task to the Z.AI ZCode CLI as a background implementer, then review its diff and land it yourself. Use this whenever the user wants to hand implementation work to ZCode — phrasings like "have ZCode do X", "delegate this to ZCode", "run it through ZCode", or "use ZCode to implement/fix/refactor" — or to run a queue of coding tasks through ZCode while staying the reviewer. DO NOT USE for tasks small enough to do inline, or when the user wants the code written directly without delegating.
compatibility
Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows).
license
MIT
metadata.version
0.5.0

ZCode Delegate

You are the orchestrator. This skill lets you hand a bounded coding task to a separate implementer — the Z.AI ZCode CLI — then review what it produced and land it yourself. You write the brief and own the judgment; ZCode does the typing; you verify and commit.

Nothing here is specific to one orchestrating agent. The loop needs only the ability to run a shell command and read a file. (It is designed for and run on Claude Code; treat other orchestrators as designed-for, not yet proven.)

When NOT to use this

  • The task is small enough to just do inline — delegation overhead is not worth it.
  • ZCode is not installed, or its CLI has no model provider configured.
  • You want to write the code yourself, or you only need a review.

Prerequisites (check once)

  1. ZCode is installed. The CLI ships inside the desktop app — it is not on PATH and not on npm. The relay resolves it in this order: --zcode-path <file> or ZCODE_CLI first, then PATH, then the installed app bundle. On Linux the app is an AppImage with no fixed install path, so the flag or the environment variable is required there — the relay guesses nothing.
  2. A model provider is configured for the CLI, with a key it can actually reach. Being signed into the desktop app is not enough — see below.
  3. You are in (or will point --cd at) the target git repository.

The relay records the CLI version and how it was resolved into result.json, so a surprising install is visible after the fact.

Authenticating the headless CLI

Signing into the ZCode desktop app does not authenticate the CLI this relay drives. The CLI keeps its own config at ~/.zcode/cli/config.json, separate from the desktop app's, and nothing bridges the two. zcode login is the intended path, but where it fails with OAuth response is not valid JSON the way in is a Z.AI API key.

Two pieces are needed, and they are separate:

  1. The provider block must exist in ~/.zcode/cli/config.json. It defines the provider, its endpoint and its models — the environment cannot supply this:

    jsonc
    {
      "provider": {
        "zai": {
          "kind": "anthropic",
          "options": { "apiKeyRequired": true, "baseURL": "https://api.z.ai/api/anthropic" },
          "models": { "glm-5.1": { "name": "GLM-5.1" } }
        }
      },
      "model": { "main": "zai/glm-5.1" }
    }
  2. The key can live either in provider.zai.options.apiKey in that file, or in the environment as any one of ZAI_API_KEY, ZCODE_API_KEY, or ANTHROPIC_API_KEY. Prefer the environment — it keeps the secret off disk.

If a run fails with Model provider is missing an API key: <provider>, the provider block resolved but no key was found: set one of those variables and re-run.

Autonomy — read this before dispatching

ZCode's own term is mode. It has four values; only two are usable headlessly.

modeBehaviour
yoloWrites. ZCode's own default for --prompt, and this relay's write-capable default.
planRefuses edits. What --read-only selects.
buildRejected by this relay. No permission client exists headlessly, so tools are blocked and the run exits 0 having done nothing.
editRejected for the same reason.

Two limits stated plainly, because ZCode cannot enforce them:

  • plan mode refused edits in testing, but the relay does not treat that as a guarantee. It takes a Git fingerprint before the run and reports a tri-state readOnlyViolation afterwards. Confirm touchedFiles came back empty rather than assuming no edits.
  • ZCode has no --allowed-tools. Only the --disallowed-tools denylist exists, and it is genuinely enforced. An explicit allowlisted tool surface is therefore impossible here — do not assume one.

The loop

Run these five steps per task. Steps 1, 4, and 5 are your judgment; 2 and 3 are mechanical.

1. Write the brief

ZCode sees only what you send — no repo memory, no chat history. Everything the task needs goes in the brief: the goal, the current state, what to change, what to leave untouched, the project's actual gate commands (discover them from the repo's CLAUDE.md/AGENTS.md/Makefile — do not assume), and a report contract. Tell ZCode it will not commit. One task per brief. The relay delivers the brief as an attached file, so the command line no longer bounds its length — the model's context window still does. Full guidance and a template: references/writing-the-brief.md.

Show full SKILL.md (438 more words)Show less
2. Dispatch
bash
node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo
# read-only (review/diagnosis, no edits):   add --read-only
# continue a specific session:              add --session <sess_...>  (from result.json; send only the delta brief)
# continue the latest session for --cd:     add --resume-last
# withhold tools (denylist):                add --disallowed-tools "Write,Edit,Bash"
# point at the CLI explicitly:              add --zcode-path /path/to/zcode.cjs
# hard time limit (watchdog):               add --timeout 2h  (default: off)
# see all options:                          node .../relay.mjs --help

(<skill-dir> is this skill's installed directory — the folder containing this SKILL.md.)

The relay writes its artifacts to a temp dir, so the repo under review stays clean. It never commits — see step 5. Mechanics, flags, and the result.json shape: references/dispatch-and-poll.md.

3. Wait for completion

The relay blocks until ZCode finishes, so back it with whatever your orchestrator offers:

  • Claude Code: run the Bash call with run_in_background: true; you are notified on completion.
  • Plain shell / other agents: foreground for short tasks, or background it and poll the result file. The run is done when result.json exists with a status. A pre-run usage error exits 2 and writes no result file, so check the exit code too; a CLI that cannot be found exits 127 but does write a result.json with status zcode_unavailable.

Do not trust progress trackers over reality: read the working tree, not a status line.

4. Review — do not trust the self-report
  • Re-run the project's gates yourself. Never take "gates passed" on faith.
  • Read the diff against the brief: did ZCode do what was asked, nothing more and nothing less? touchedFiles is your starting point.
  • On a --read-only run, check readOnlyViolation and confirm touchedFiles is empty.
  • Run the relevant guard skills on the diff if you have them installed.

Full checklist: references/review-and-land.md.

5. Land it

The orchestrator commits. Only after the gates pass and the diff holds:

  • Commit the verified work yourself, with a clear message.
  • If it needs changes, send a delta brief with --session <sessionId> from the prior result.json, and review again.

Read-only second opinions

The relay doubles as a way to get an adversarial second opinion with no write risk: dispatch --read-only with a brief listing the agreed points, then each contested point with both positions, and ask ZCode to defend or concede each. Because plan mode's guarantee is measured rather than enforced here, verify touchedFiles came back empty instead of assuming no edits.

Authorization model

Delegation is something the human opts into. Once they have, committing verified, gate-passing work is the agreed contract. Two limits: surface, don't absorb (report ZCode's design decisions and defensible-but-unasked turns rather than silently keeping them) and stop for scope changes (if correct completion needs going beyond the brief, ask). The full treatment is in references/review-and-land.md.

References

© amElnagdy, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (scripts, references) in skills/zcode-delegate of amElnagdy/delegate-skills.

  • SKILL.md
  • references/dispatch-and-poll.md
  • references/multi-task-queues.md
  • references/review-and-land.md
  • references/writing-the-brief.md
  • scripts/relay.mjs

Open the folder on GitHubat commit 6826b36

Compare with similar skills

Zcode Delegate next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Zcode Delegate compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Zcode Delegate this skillamElnagdy/delegate-skills2.3k—~2.4kAutomated safety check: PassMIT
Moai Ref Cross Model Auditmodu-ai/moai-adk1.2k—~4.8kAutomated safety check: PassApache-2.0
Z.AI CLInumman-ali/zai-cli110—~528Automated safety check: PassMIT
Gh Issuestrpc-group/trpc-agent-go1.8k8 repos~8.7kAutomated safety check: PassApache-2.0
Higress Openclaw Integrationhigress-group/higress9.5k—~2.5kAutomated safety check: PassApache-2.0
Weave Router Local Testingweave-os/router5.6k—~3.1kAutomated safety check: NotesApache-2.0

Similar skills

  • Cross-model audit convergence reference for the plan-auditor and sync-auditor agents.

    1.2k GitHub stars~4.8k tokensUpdated today
    DevelopmentAuto-check passed
  • Z.AI CLI

    numman-ali/zai-cli

    Command-line access to Z.AI vision analysis, web search, page reading and GitHub repo exploration through npx zai-cli, using an API key.

    110 GitHub stars~528 tokensUpdated 9 mo ago
    Productivity & AutomationAuto-check passed
  • Gh Issues

    trpc-group/trpc-agent-go

    Fetch GitHub issues, spawn sub-agents to implement fixes and open PRs, then monitor and address PR review comments.

    1.8k GitHub starsUsed in 8 repos~8.7k tokens
    Agent WorkflowsAuto-check passed
  • Higress Openclaw Integration

    higress-group/higress

    Deploy and configure Higress AI Gateway for OpenClaw integration.

    9.5k GitHub stars~2.5k tokensUpdated 3 days ago
    AI & LLM EngineeringAuto-check passed
  • Stands up the Weave model router in Docker Compose and drives it with claude -p against a real or mocked upstream to reproduce and verify routing and streaming behavior.

    5.6k GitHub stars~3.1k tokensUpdated today
    DevOps & CloudAuto-check: notes
  • AI Model Nodejs

    TencentCloudBase/CloudBase-AI-Toolkit

    A skill your agent uses for Node.js backend AI via @cloudbase/node-sdk (=3.16.0) — cloud functions, CloudRun, Express/Koa/NestJS, serverless APIs, scheduled jobs, LLM proxies, agent orchestration.

    1.1k GitHub starsUsed in 3 repos~5k tokens
    Backend & APIsAuto-check passed

More from amElnagdy/delegate-skills

All 18 skills in this repo
  • Aider Delegate

    amElnagdy/delegate-skills

    Delegate a coding task to Aider (aider) as a background implementer, then review its diff and land it yourself.

    2.3k GitHub starsUsed in 2 repos~3k tokens
    Auto-check passed
  • Qoder Delegate

    amElnagdy/delegate-skills

    Delegate a coding task to the Qoder CLI (qodercli) as a background implementer, then review its diff and land it yourself.

    2.3k GitHub starsUsed in 2 repos~1.6k tokens
    Auto-check passed
  • Warp Delegate

    amElnagdy/delegate-skills

    Delegate a coding task to the Warp Agent CLI (oz) as a background implementer, then review its diff and land it yourself.

    2.3k GitHub starsUsed in 2 repos~2.6k tokens
    Auto-check passed
  • Agy Delegate

    amElnagdy/delegate-skills

    Delegate a coding task to the Google Antigravity CLI (agy) as a background implementer, then review its diff and land it yourself.

    2.3k GitHub stars~2.5k tokensUpdated 17 days ago
    Auto-check passed
  • Claude Delegate

    amElnagdy/delegate-skills

    Delegate a coding task to a separate Claude Code CLI process or another Claude session as an implementer, then review its diff and land it yourself.

    2.3k GitHub stars~2.4k tokensUpdated 17 days ago
    Auto-check passed
  • Cline Delegate

    amElnagdy/delegate-skills

    Delegate a coding task to the Cline coding agent CLI (cline) as a background implementer, then review its diff and land it yourself.

    2.3k GitHub stars~1.6k tokensUpdated 17 days ago
    Auto-check passed

Works with

Categories

Questions about Zcode Delegate

What does Zcode Delegate do?

Delegate a coding task to the Z.AI ZCode CLI as a background implementer, then review its diff and land it yourself. Zcode Delegate is an agent skill from amElnagdy/delegate-skills.AI ZCode CLI as a background implementer, then review its diff and land it yourself.

When should I use Zcode Delegate?

Zcode Delegate fits situations like: wants to hand implementation work to ZCode — phrasings like have ZCode do X; delegate this to ZCode; run it through ZCode; use ZCode to implement/fix/refactor —.

How do I install Zcode Delegate in Claude Code?

Run `npx skills add amElnagdy/delegate-skills --skill zcode-delegate -a claude-code`. Or copy the skill folder (skills/zcode-delegate in amElnagdy/delegate-skills) into .claude/skills/zcode-delegate in your project. Claude Code loads it when a task matches its description.

How do I install Zcode Delegate in Codex?

Run `npx skills add amElnagdy/delegate-skills --skill zcode-delegate -a codex`. Or copy the skill folder (skills/zcode-delegate in amElnagdy/delegate-skills) into .agents/skills/zcode-delegate in your project. Codex loads it when a task matches its description.

Can I use Zcode Delegate in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add amElnagdy/delegate-skills --skill zcode-delegate -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/zcode-delegate, .gemini/skills/zcode-delegate, .github/skills/zcode-delegate and .opencode/skills/zcode-delegate in your project.

What does Zcode Delegate need to run?

Going by SKILL.md and its folder, Zcode Delegate needs JavaScript for the scripts in its folder, the command-line tools its instructions call (node) and credentials named ZAI_API_KEY, ZCODE_API_KEY and ANTHROPIC_API_KEY. Our summary lists: Node.js; A credential in ZAI_API_KEY; A credential in ZCODE_API_KEY. Compatibility (from SKILL.md): Requires the `zcode` CLI (Z.AI ZCode) with a configured model provider, Node 18+, and git. ZCode ships its CLI inside the desktop app rather than on PATH or npm — see Prerequisites. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows)..

Does Zcode Delegate access the network?

SKILL.md names 1 domain. In commands or code: api.z.ai; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Zcode Delegate safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Zcode Delegate use?

Zcode Delegate is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Zcode Delegate use?

About 2.4k tokens (SKILL.md is roughly 9.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.8k tokens, read only when the agent opens those files.

What are the alternatives to Zcode Delegate?

Skills that share tags, products or a category with Zcode Delegate: Moai Ref Cross Model Audit (modu-ai/moai-adk, 1.2k stars), Z.AI CLI (numman-ali/zai-cli, 110 stars), Gh Issues (trpc-group/trpc-agent-go, 1.8k stars) and Higress Openclaw Integration (higress-group/higress, 9.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Zcode Delegate?

amElnagdy (a GitHub user) maintains it in amElnagdy/delegate-skills, which has 2,317 GitHub stars. The repository holds 18 skills in this directory. The repository was last updated on September 20, 2026.

Source: amElnagdy/delegate-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.