Skip to main content
skill CX Codex

mcode-delegate — Claude Code skill for MiniMax Code

The mcode-delegate Claude Code skill hands implementation work to MiniMax Code through the mcode CLI. The orchestrating agent reviews the diff and controls the commit.

MIT 138 installs ★ 2,647 updated 2026-10-14

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add amElnagdy/delegate-skills --skill mcode-delegate -a claude-code
Open on GitHub

What mcode-delegate does

The skill sends a bounded coding task to MiniMax Code, then gives the orchestrating agent a result to inspect before committing. Its relay.mjs helper runs mcode exec and writes a structured result.json. The helper does not commit changes.

It activates when a user asks MiniMax Code to implement, fix, or refactor code. The brief should spell out the goal, scope, and project checks; MiniMax Code reads that brief and repository files, including AGENTS.md, but gets no chat history.

Requirements are the MiniMax Code CLI installed and signed in, Node 22+, and git. The shell running the helper must find mcode on PATH, and the repository should have a clean working tree before dispatch. There is no sandbox: --read-only detects edits after they happen rather than preventing them.

What it helps with

  • delegate a repository implementation task to MiniMax Code
  • run a queue of coding tasks while retaining review control
  • collect the CLI run report in result.json
  • give the implementer task context without chat history

Example prompts for the agent

  • Ask MiniMax Code to fix error handling in this repository, then review the diff.
  • Delegate a refactor of this module to MiniMax Code and save its report in result.json.
  • Run these coding briefs through mcode and leave the commits to me.

How to install mcode-delegate

1Skills CLI (Vercel)

npx skills add amElnagdy/delegate-skills --skill mcode-delegate -a claude-code

2Manually: put the files in place

~/.claude/skills/mcode-delegate/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/mcode-delegate/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about mcode-delegate

How do I install mcode-delegate in Claude Code?

Run npx skills add amElnagdy/delegate-skills --skill mcode-delegate -a claude-code. The skill file is installed at ~/.claude/skills/mcode-delegate/SKILL.md.

What does mcode-delegate do?

It sends a coding task to MiniMax Code with the mcode CLI and records the run in result.json. The orchestrating agent reviews the changes and handles the commit.

What does mcode-delegate need to run?

Install and sign in to the MiniMax Code CLI (mcode), and have Node 22+ and git available. The shell running the helper must find mcode on PATH.

Source text

SKILL.md · MIT
---
name: mcode-delegate
description: >-
  Delegate a coding task to the MiniMax Code CLI (`mcode`) as a background implementer, then review
  its diff and land it yourself. Use this whenever the user wants to hand implementation work to
  MiniMax Code or a MiniMax model — phrasings like "have MiniMax do X", "delegate this to mcode", "run
  it through MiniMax Code", or "use MiniMax to implement/fix/refactor" — or to run a queue of coding
  tasks through MiniMax Code 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
compatibility: Requires the MiniMax Code CLI (`mcode`, from agent.minimax.io) installed and signed in with `mcode login`, Node 22+, and git. The orchestrating agent must be able to run shell commands and read files. Shell examples assume bash/zsh (macOS/Linux).
metadata:
  version: 0.5.0
---

# MiniMax Code Delegate

You are the **orchestrator**. This skill lets you hand a bounded coding task to a separate
**implementer** — the MiniMax Code CLI (`mcode`) — then review what it produced and land it yourself.
You write the brief and own the judgment; MiniMax Code does the typing in your working tree; 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, so it works the same whether you are Claude Code, OpenCode with a selected
model, or any comparable agent. (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.
- `mcode` is not installed or not signed in (run `mcode login`, or `mcode login --region global`).
- You want to write the code yourself, or you only need a review of local changes (`mcode exec review`
  does that directly).
- You need writes outside the target tree to be impossible, not just unlikely. MiniMax Code has no
  sandbox; use an OS-enforced one such as `codex-delegate`, or run this inside a container.

## Read this before the first dispatch: the autonomy model

`mcode exec` takes a permission policy — `smart`, `full`, or `off` — and has **no sandbox and no
read-only or plan setting** for a headless run (`ask` needs the TUI or ACP).

- **`smart` (the relay's default; TUI Auto):** already approves file writes and deletions headlessly.
  A live probe asked for an `rm` and got it with no prompt.
  So `smart` is not a guardrail: the brief and a clean working tree are the real scope.
- **`full` (TUI Full access):** skips normal confirmation entirely. The relay passes it only on an
  explicit `--permission full`.
- **`off`:** refused by the relay; MiniMax Code does not document what it disables.

`--read-only` is **advisory**: the relay appends a system prompt forbidding edits, keeps `smart`, and
then runs a Git-visible change tripwire (`readOnlyViolation`). A change is *detected after the fact,
not prevented*, and ignored or outside-repository paths are not covered.

## Prerequisites (check once)

1. `mcode --version` succeeds and you are signed in (`mcode` → `/status` in the TUI). If not, install
   MiniMax Code and run `mcode login`.
2. **Confirm `mcode` is on PATH in the shell the relay runs from.** The official installer puts it in
   `~/.minimax-code/bin`, which only your shell profile adds to PATH; an orchestrator's non-login shell
   may not see it. Pass `--mcode-path <file>` or set `MCODE_CLI` when `command -v mcode` comes back
   empty. The relay records the version it ran in `result.json`.
3. You are in (or will point `--cd` at) the target git repository, and its tree is clean before you
   dispatch — a run with no sandbox is much easier to review against a clean baseline.

## 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

MiniMax Code sees **only** the text you send — no repo memory, no chat history, no shared context
(beyond the repo's own `AGENTS.md`, which it reads). 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 AGENTS.md/CLAUDE.md/Makefile — do not assume), and a report
contract. Tell it that it will **not** commit (you will). Keep one task per brief. Full guidance and a
template: [references/writing-the-brief.md](references/writing-the-brief.md).

### 2. Dispatch

Send the brief to MiniMax Code with the bundled helper. It wraps `mcode exec`, captures the run, and
writes a structured `result.json` — so your only job is "run a command, read a file." (`<skill-dir>`
below is this skill's installed directory — the folder containing this `SKILL.md`, i.e. the directory
you loaded the skill from. Claude Code prints it as "Base directory for this skill" when the skill
loads; on other orchestrators use that same directory — if unsure where it landed, run
`find ~ -name relay.mjs -path '*mcode-delegate*'` and substitute the directory above it.)

```bash
node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo
# read-only (review/diagnosis; advisory):   add --read-only
# continue the exact session:               add --session <sessionId>  (from result.json; send only the delta brief)
# model / effort for this run:              add --model minimax/<model> --effort high
# hard time limit (watchdog):               add --timeout 2h  (default: off; implementation runs routinely need 1-2h)
# see all options:                          node .../relay.mjs --help
```

The helper defaults to a write-capable (`--permission smart`) run, which intentionally edits the target
repository. Its temp directory keeps only relay artifacts out of that repository. The relay **never
commits** — see step 5. Mechanics, flags, and the `result.json` shape:
[references/dispatch-and-poll.md](references/dispatch-and-poll.md).

### 3. Wait for completion

The helper blocks until MiniMax Code finishes, so back it with whatever your orchestrator offers and
resume when it returns:

- **Claude Code:** run the Bash call with `run_in_background: true`; you are notified on completion.
- **Plain shell / other agents:** run it in the foreground for short tasks, or background it and poll
  the result file — `… &` in bash/zsh, or your shell's equivalent. The run is done when `result.json`
  exists with a `status`. (A pre-run usage error — bad args or an empty brief — instead exits with code
  2 and a stderr message and writes no result file, so check the exit code too. A missing `mcode`
  binary exits 127 but *does* write a `result.json` with status `mcode_unavailable`.)

A run is finished when `result.json` is written and the process has exited — read the working tree,
not a status line. The implementer's full report is the `finalMessage` field in `result.json` (also
printed in full on stdout between the report markers).

### 4. Review — do not trust the self-report

`result.json` includes MiniMax Code's own summary and gate claims. **Re-verify, don't accept:**

- **Re-run the project's gates yourself** (the test/lint/build commands from step 1). Never take
  "gates passed" on faith.
- **Read the diff** against the brief: did it do what was asked, nothing more (scope creep) and
  nothing less? `touchedFiles` in the result is your starting point — and because there was no
  sandbox, check for edits and **deletions** *outside* the paths the brief named, not just inside them.
- **Run the relevant guard skills** on the diff if you have them installed (clean-code-guard,
  test-guard, etc. from `guard-skills`) — this skill produces the work; those skills judge it.
- For schema/migration changes, round-trip them; for removals, grep for dangling references.

Full checklist: [references/review-and-land.md](references/review-and-land.md).

### 5. Land it

The relay never commits, but nothing stops MiniMax Code from writing `.git`. The brief forbids
implementer commits, and the reviewer compares `HEAD` with the recorded pre-dispatch baseline before
landing anything. **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: dispatch `--read-only` with a brief
that lists the agreed points, then each contested point with both positions, and ask MiniMax Code to
defend or concede each — deliverable in its final message, touching no files. Because that read-only
state is only a prompt, read the verdict every time: `readOnlyViolation: false` means the Git-visible
detector saw no change (ignored or outside-repository paths are not covered); `true` means it saw
one; `null` means git could not tell. Dispatch second opinions on a clean tree you can afford to
restore.

## 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 — that is the whole point. Two limits on that
mandate: **surface, don't absorb** (report MiniMax Code's design decisions, defensible-but-unasked
turns, and non-blocking nitpicks rather than silently keeping them) and **stop for scope changes** (if
correct completion needs going beyond the brief, ask — don't expand the mandate yourself). The full
treatment is in [references/review-and-land.md](references/review-and-land.md).

## References

- [references/writing-the-brief.md](references/writing-the-brief.md) — how to write a brief MiniMax
  Code can execute blind: structure, XML blocks, the report contract, embedding the real gate commands.
- [references/dispatch-and-poll.md](references/dispatch-and-poll.md) — `relay.mjs` flags, the
  `result.json` contract, backgrounding per orchestrator, and recovery when a run misbehaves.
- [references/review-and-land.md](references/review-and-land.md) — the review checklist, the commit
  boundary, and the exact-session rework cycle.
- [references/multi-task-queues.md](references/multi-task-queues.md) — running a sequential queue:
  carrying constraints forward, progress tracking, and the end-of-run coherence check.

© amElnagdy · MIT · amElnagdy/delegate-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set21

The whole set →
cline-delegate cline-delegate — a skill for Claude Code, Codex, and Cursor offloads coding workloads to the Cline CLI agent. Runs whenever you delegate feature implementation to a background worker. CX Codex +1 3,400installs aider-delegate aider-delegate — a skill for Claude Code, Codex, and Cursor offloads bounded coding tasks to the Aider CLI as an implementer while you keep commit control. Runs headless without auto-commits polluting git history. CX Codex +1 3,300installs zcode-delegate zcode-delegate — a skill for Claude Code, Codex, and Cursor that offloads scoped coding tasks to the Z.AI ZCode CLI. Turns your primary assistant into a reviewer while ZCode writes the patch. CX Codex +1 3,200installs commandcode-delegate commandcode-delegate — a skill for Claude Code, Codex, Cursor and other agents that sends a coding task to the Command Code CLI as a background implementer while the orchestrating agent stays reviewer. CX Codex +1 3,100installs warp-delegate warp-delegate — a skill for Claude Code sends implementation work to Warp through oz, then leaves the diff review and landing to you. The agent runs in the background. CX Codex +1 3,100installs omp-delegate omp-delegate — a skill for Claude Code sends coding work to Oh My Pi (omp) and returns the diff for review. A background queue can handle several delegated tasks. CX Codex +1 2,900installs codex-background The codex-background skill keeps a Codex delegation waiting until its implementer relay finishes, without model-driven status polling. Use it when Codex needs to wait on a delegated task in the background. CX Codex +1 700installs muse-delegate muse-delegate hands coding tasks to Muse Code as a background worker, leaving diff review and git commits to the main agent. CX Codex +1 605installs

Project sponsors

Companies that keep this analytics open