Agent skill

Kimi Delegate

by amElnagdy in amElnagdy/delegate-skills

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

MITAuto-check passedDevelopment

Install Kimi Delegate

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

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

GitHub CLI
$ gh skill install amElnagdy/delegate-skills kimi-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/kimi-delegate .claude/skills/kimi-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
kimi-delegate
GitHub stars
2.3k
Token cost
~1.6k tokens
SKILL.md length
678 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 Kimi Code CLI (kimi) 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 Kimi - phrasings like have Kimi implement X
  • SKILL.md covers When NOT to use this, Prerequisites (check once), Choose the model alias and The loop, plus 3 more sections
  • Runs JavaScript scripts from its folder; calls node and brew

What it does

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

Its SKILL.md is about 1.6k 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`).

It sits in Development. It works with Kimi. 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 Kimi - phrasings like have Kimi implement X
  • Delegate this to Kimi
  • Run it through Kimi Code
  • Use Kimi to implement/fix/refactor -

Example prompts

  • “have Kimi implement X”
  • “delegate this to Kimi”
  • “run it through Kimi Code”
  • “/kimi-delegate”

Requirements

  • Node.js

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 8ef0210. 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
    • brew

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

  • Network

    Links to these hosts (documentation or services it may open):

    • moonshotai.github.io

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

  • Credentials

    Names no API keys, tokens, secrets or passwords.

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

Context cost

Kimi Delegate loads about 1.6k tokens when it runs, and up to ~6.5k if it reads all its reference files. Until then it costs about 136 tokens; SKILL.md has 678 words of instructions outside code blocks.

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

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 8ef0210, republished under its MIT licence (© amElnagdy). 678 words, ~1,550 tokens.

Download SKILL.mdSave it as .claude/skills/kimi-delegate/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
kimi-delegate
description
Delegate a coding task to the Kimi Code CLI (`kimi`) as a background implementer, then review its diff and land it yourself. Use this whenever the user wants to hand implementation work to Kimi - phrasings like "have Kimi implement X", "delegate this to Kimi", "run it through Kimi Code", or "use Kimi to implement/fix/refactor" - or wants to run a queue of coding tasks through Kimi 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.
license
MIT
metadata.version
0.5.0

Kimi Delegate

You are the orchestrator. Hand a bounded coding task to a separate implementer - the Kimi Code CLI - then review what it produced and land it yourself. You write the brief and own the judgment; Kimi does the typing in its own session; you verify and commit.

The loop needs only a shell command and file access, so any comparable orchestrator can drive it.

When NOT to use this

  • The task is small enough to do inline; delegation overhead is not worth it.
  • The kimi CLI is not installed or authenticated.
  • You need a CLI-enforced read-only implementer. Headless Kimi has no read-only mode.

Prerequisites (check once)

  1. Install Kimi Code with brew install kimi-code on macOS/Linux, or use the native installer from the official Kimi Code documentation.
  2. Authenticate with kimi login (device-code flow, no TUI), or use /login in the TUI.
  3. Confirm kimi --version succeeds.
  4. Work in, or point --cd at, the target git repository.

Choose the model alias

Kimi uses default_model from its config.toml when --model is omitted. To choose another model alias, pass --model <alias from your kimi config>. Model aliases are user-defined config keys; use one the human has configured rather than inventing one.

The loop

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

1. Write the brief

Kimi sees only the text you send plus what it can inspect in the workspace - no chat history or shared context. Include the goal, current state, what to change, what to leave untouched, the project's actual gates, and a report contract. Tell Kimi not to commit. Keep one task per brief. See references/writing-the-brief.md.

2. Dispatch

Use the bundled helper. It wraps Kimi's headless prompt mode, captures the structured event stream, and writes result.json. (<skill-dir> is the installed folder containing this SKILL.md.)

bash
node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo
# choose a configured model alias:       add --model <alias from your kimi config>
# resume the most recent session:        add --resume-last  (delta brief only)
# resume a specific session:             add --session <id> (delta brief only)
# hard time limit (watchdog):            add --timeout 2h  (the 30m default suits short runs; implementation briefs routinely need 1-2h)
# see all options:                       node .../relay.mjs --help

The child process's cwd pins the workspace. Use repeatable --add-dir flags only for extra workspace directories. The relay writes artifacts under the system temp dir by default and never commits. See references/dispatch-and-poll.md.

3. Wait for completion

The helper blocks until Kimi finishes. Run it with the orchestrator's background-command facility, or background it in the shell and poll for result.json. A pre-run usage error exits 2 and writes no result; a missing kimi exits 127 and writes status: "kimi_unavailable".

Trust process state and the working tree over a progress display. Completion means the process exited and result.json exists. Kimi's full report is the finalMessage field in result.json (also printed in full on stdout between the report markers).

Show full SKILL.md (256 more words)Show less
4. Review - do not trust the self-report

Treat Kimi's final message and gate claims as claims:

  • Re-run the project's gates yourself.
  • Read the diff against the brief, starting with touchedFiles.
  • Run relevant guard skills if installed.
  • Round-trip migrations and grep for dangling references after removals or renames.

See references/review-and-land.md.

5. Land it

The implementer edits the working tree; the orchestrator commits. Commit only after the gates pass and the diff holds. If rework is needed, send a delta brief with --resume-last or --session <id>, then review again.

Autonomy and permissions

In headless -p mode, Kimi always runs in auto permission mode and never asks for approval. Kimi rejects --prompt combined with --yolo, --auto, or --plan, so the relay passes none of them and offers no --read-only or --full-access option. There is no CLI-enforced read-only mode: inspect touchedFiles and the diff after every run. That diff, not a flag, is the guarantee of what changed.

Authorization model

Delegation is something the human opts into. Once they have ("run this queue", "proceed"), committing verified, gate-passing work is the agreed contract. Two limits remain: surface, don't absorb (report Kimi's design decisions, defensible-but-unasked turns, and non-blocking nitpicks) and stop for scope changes (if correct completion needs going beyond the brief, ask instead of expanding the mandate). See 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/kimi-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 8ef0210

Compare with similar skills

Kimi 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.

Kimi Delegate compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Kimi Delegate this skillamElnagdy/delegate-skills2.3k—~1.6kAutomated safety check: PassMIT
Ccmanager Configkbwo/ccmanager1.3k—~1.5kAutomated safety check: PassMIT
Kimi WebbridgeMoonshotAI/kimi-code7.8k—~3.6kAutomated safety check: PassMIT
Gen ChangesetsMoonshotAI/kimi-code7.8k—~1.1kAutomated safety check: PassMIT
Pulse Releasequnqin24/Pulse517—~1.3kAutomated safety check: PassApache-2.0
Luvus ModuleRizRiyz/luvus958—~2.5kAutomated safety check: PassApache-2.0

Similar skills

  • Ccmanager Config

    kbwo/ccmanager

    Set up, review, or repair a CCManager config — .ccmanager.json at a git repository root, or the global ~/.config/ccmanager/config.json.

    1.3k GitHub stars~1.5k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Kimi Webbridge

    MoonshotAI/kimi-code

    Kimi Browser Extension(Kimi 浏览器扩展,原 Kimi WebBridge)lets AI control the user's real browser — navigate, click, type, read, screenshot, and interact with any website using the user's actual login…

    7.8k GitHub stars~3.6k tokensUpdated today
    DevelopmentAuto-check passed
  • Gen Changesets

    MoonshotAI/kimi-code

    A skill your agent uses when generating changesets in the kimi-code repository — deciding whether to write one, which package to list, the bump level, the wording, and the confirmation workflow.

    7.8k GitHub stars~1.1k tokensUpdated today
    DevelopmentAuto-check passed
  • Pulse Release

    qunqin24/Pulse

    Release a new Pulse version end to end — checks, bilingual CHANGELOG entry, VERSION, tag, the release workflow, syncing main, and the issue replies that go with it.

    517 GitHub stars~1.3k tokensUpdated today
    DevelopmentAuto-check passed
  • Luvus Module

    RizRiyz/luvus

    Write a luvus module (an extension for luvus, mission control for your AI coding agents).

    958 GitHub stars~2.5k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Gen Docs

    MoonshotAI/kimi-code

    Update Kimi Code CLI user documentation after meaningful code changes that affect product behavior or user experience.

    7.8k GitHub stars~1.2k tokensUpdated today
    DevelopmentAuto-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 2 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 2 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 2 days ago
    Auto-check passed

Works with

Categories

Questions about Kimi Delegate

What does Kimi Delegate do?

Delegate a coding task to the Kimi Code CLI (kimi) as a background implementer, then review its diff and land it yourself. Kimi Delegate is an agent skill from amElnagdy/delegate-skills. Delegate a coding task to the Kimi Code CLI (kimi) as a background implementer, then review its diff and land it yourself.

When should I use Kimi Delegate?

Kimi Delegate fits situations like: wants to hand implementation work to Kimi - phrasings like have Kimi implement X; delegate this to Kimi; run it through Kimi Code; use Kimi to implement/fix/refactor -.

How do I install Kimi Delegate in Claude Code?

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

How do I install Kimi Delegate in Codex?

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

Can I use Kimi 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 kimi-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/kimi-delegate, .gemini/skills/kimi-delegate, .github/skills/kimi-delegate and .opencode/skills/kimi-delegate in your project.

What does Kimi Delegate need to run?

Going by SKILL.md and its folder, Kimi Delegate needs JavaScript for the scripts in its folder and the command-line tools its instructions call (node and brew). Our summary lists: Node.js.

Does Kimi Delegate access the network?

SKILL.md names 1 domain. As links in the text: moonshotai.github.io. This is read from the text; nothing was executed.

Is Kimi 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 Kimi Delegate use?

Kimi 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 Kimi Delegate use?

About 1.6k tokens (SKILL.md is roughly 6.2k 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 5k tokens, read only when the agent opens those files.

What are the alternatives to Kimi Delegate?

Skills that share tags, products or a category with Kimi Delegate: Ccmanager Config (kbwo/ccmanager, 1.3k stars), Kimi Webbridge (MoonshotAI/kimi-code, 7.8k stars), Gen Changesets (MoonshotAI/kimi-code, 7.8k stars) and Pulse Release (qunqin24/Pulse, 517 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Kimi Delegate?

amElnagdy (a GitHub user) maintains it in amElnagdy/delegate-skills, which has 2,336 GitHub stars. The repository holds 18 skills in this directory. The repository was last updated on October 7, 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.