New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Grok Delegate

by amElnagdy in amElnagdy/delegate-skills

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

MITAuto-check passedDevelopment

Install Grok Delegate

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

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

GitHub CLI
$ gh skill install amElnagdy/delegate-skills grok-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/grok-delegate .claude/skills/grok-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
grok-delegate
GitHub stars
2.3k
Token cost
~2.6k tokens
SKILL.md length
1,241 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 Grok Build 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 Grok — phrasings like have Grok do X
  • SKILL.md covers When NOT to use this, Prerequisites (check once), The loop and Autonomy model, plus 2 more sections
  • Runs JavaScript scripts from its folder; calls node and npm; needs XAI_API_KEY

What it does

Grok Delegate is an agent skill from amElnagdy/delegate-skills. Delegate a coding task to the Grok Build CLI as a background implementer, then review its diff and land it yourself. Use this whenever the user wants to hand implementation work to Grok — phrasings like "have Grok do X", "delegate this to Grok", "run it through Grok", "use Grok Build to implement/fix/refactor", or "have grok CLI do this" — or to run a queue of coding tasks through Grok while staying the reviewer. Prefer it when the user will review the diff and commit it themselves. DO NOT USE for tasks small…

Its SKILL.md is about 2.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`). Compatibility notes: Requires the grok CLI (Grok Build) installed and authenticated (grok login, or XAIAPIKEY; beta access needs an eligible xAI subscription), Node 18+, and git…

It sits in Development, covering Code review. It works with Git. 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 Grok — phrasings like have Grok do X
  • Delegate this to Grok
  • Run it through Grok
  • Use Grok Build to implement/fix/refactor

Example prompts

  • “have Grok do X”
  • “delegate this to Grok”
  • “run it through Grok”
  • “/grok-delegate”

Requirements

  • Node.js
  • A credential in XAI_API_KEY
  • Compatibility (from SKILL.md): Requires the `grok` CLI (Grok Build) installed and authenticated (`grok login`, or `XAI_API_KEY`; beta access needs an eligible xAI subscription), Node 18+, and git. 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 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
    • npm

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

  • Network

    No URLs in SKILL.md. Its commands use npm, which can reach the network depending on how they are called.

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

  • Credentials

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

    • XAI_API_KEY

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

  • Compatibility

    Requires the `grok` CLI (Grok Build) installed and authenticated (`grok login`, or `XAI_API_KEY`; beta access needs an eligible xAI subscription), Node 18+, and git. 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

Grok Delegate loads about 2.6k tokens when it runs, and up to ~10k if it reads all its reference files. Until then it costs about 155 tokens; SKILL.md has 1,241 words of instructions outside code blocks.

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

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). 1,241 words, ~2,599 tokens.

Download SKILL.mdSave it as .claude/skills/grok-delegate/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
grok-delegate
description
Delegate a coding task to the Grok Build CLI as a background implementer, then review its diff and land it yourself. Use this whenever the user wants to hand implementation work to Grok — phrasings like "have Grok do X", "delegate this to Grok", "run it through Grok", "use Grok Build to implement/fix/refactor", or "have grok CLI do this" — or to run a queue of coding tasks through Grok while staying the reviewer. Prefer it when the user will review the diff and commit it themselves. DO NOT USE for tasks small enough to do inline, or when the user wants the code written directly without delegating.
compatibility
Requires the `grok` CLI (Grok Build) installed and authenticated (`grok login`, or `XAI_API_KEY`; beta access needs an eligible xAI subscription), Node 18+, and git. 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

Grok Delegate

For a trusted repository rejected by Git's ownership check, the relay supports --trust-git-root <exact-worktree-root>. This opt-in affects only relay Git checks, without persistent Git config or Grok permission changes. See dispatch and poll.

You are the orchestrator. This skill lets you hand a bounded coding task to a separate implementer — the Grok Build CLI (grok) — then review what it produced and land it yourself. You write the brief and own the judgment; Grok does the typing under an explicit autonomy profile; 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, Cursor, OpenCode with a selected model, or any comparable agent. (It is designed for Claude Code and Cursor; 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.
  • The grok CLI is not installed, not authenticated, or the account lacks Grok Build beta access.
  • You want to write the code yourself, or you only need a review without an implementer run.

Prerequisites (check once)

  1. grok version succeeds. If not, install on any platform with npm i -g @xai-official/grok (or use the installer from xAI's official Grok CLI docs) and authenticate (grok login, or grok login --device-auth on headless hosts, or set XAI_API_KEY).
  2. Confirm which grok is on PATH. command -v grok shows the active binary and grok version its version — the relay records the version it ran into result.json, so a stale binary is visible after the fact.
  3. You are in (or will point --cd at) the target git repository.

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

Grok sees only the text you send — no orchestrator chat history, no shared context. 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 Grok it will not commit (you will). Keep one task per brief. Full guidance and a template: references/writing-the-brief.md.

2. Dispatch

Send the brief to Grok with the bundled helper. It wraps grok -p, 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 '*grok-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; best-effort — verify touchedFiles): add --read-only
# continue the previous Grok session:       add --resume-last  (send only the delta brief)
# 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 (workspace-write) autonomy profile — --always-approve plus --sandbox workspace — and 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 helper blocks until Grok 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 (including Git Bash/WSL), or your shell's equivalent (Start-Job in PowerShell, start /b in cmd). 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 grok binary exits 127 but does write a result.json with status grok_unavailable.)

Do not trust progress trackers over reality: 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).

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

Grok's result.json includes its 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 Grok do what was asked, nothing more (scope creep) and nothing less? touchedFiles in the result is your starting point.
  • 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.

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 --resume-last (don't restate the whole task) and review again.

Autonomy model

Grok's default permission mode is ask, which blocks on approval prompts in a headless pipe. The relay therefore always sets autonomy explicitly:

Relay flagWhat Grok getsUse when
(default)--always-approve --sandbox workspaceNormal implementation — writes scoped to the working tree
--read-only--sandbox read-only --always-approveReview / diagnosis — kernel-enforced sandbox, not total (see caveat below)
--full-access--always-approve --sandbox offExplicit opt-in when the task needs unrestricted tools

--always-approve alone would approve all tools (writes, shell, network) — closer to unrestricted than to a workspace-scoped write. Pairing it with --sandbox workspace is what keeps the default safe. Reach for --full-access only when the human asks for it.

--read-only is kernel-enforced, not total. On grok 1.0.25 the read-only sandbox (Seatbelt on macOS, Landlock on Linux) denies grok's own write/search_replace tools and shell redirects with EPERM, so --always-approve only auto-approves tools inside the sandbox. The profile is not total, though: it still permits writes to /tmp, /var/tmp and ~/.grok/, so a repo under one of those paths is not protected, and on macOS it does not restrict child-process network. Always confirm touchedFiles afterward; treat the diff, not the flag, as the guarantee. The relay automates a reporting tripwire: it compares parsed git porcelain and fingerprints the working-tree identity and index entries of Git-visible paths that were already dirty. readOnlyViolation is true when either signal proves a change, false when coverage is complete and detects none, and null when coverage is incomplete. Ignored paths, submodule internals, perfect restores, and attribution of concurrent changes remain outside it, so the diff review stays the guarantee.

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 Grok'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

© 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/grok-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

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

Grok Delegate compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Grok Delegate this skillamElnagdy/delegate-skills2.3k—~2.6kAutomated safety check: PassMIT
Code Review ChecklistshareAI-lab/learn-claude-code78k5 repos~1.1kAutomated safety check: PassMIT
Open Code Review CLIalibaba/open-code-review45k—~3.1kAutomated safety check: PassApache-2.0
Understand Diff AnalysisEgonex-AI/Understand-Anything86k—~1.4kAutomated safety check: PassMIT
Open Code Review Delegatealibaba/open-code-review45k—~2kAutomated safety check: PassApache-2.0
Code Reviewflutter/flutter179k—~1.4kAutomated safety check: PassBSD-3-Clause

Similar skills

  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 5 repos~1.1k tokens
    DevelopmentAuto-check passed

  • Open Code Review CLI

    alibaba/open-code-review

    Runs the ocr command-line tool to review Git changes, a commit or a branch comparison with an AI model, returning line-level comments and optionally applying fixes.

    45k GitHub stars~3.1k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Understand Diff Analysis

    Egonex-AI/Understand-Anything

    Reads your git changes or a pull request against a prebuilt knowledge graph of the project to explain what changed, which components are affected and what is risky.

    86k GitHub stars~1.4k tokensUpdated today
    DevelopmentAuto-check passed

  • Open Code Review Delegate

    alibaba/open-code-review

    Has the host agent do the code review itself while the ocr CLI handles file selection and rule lookup, covering workspace changes, branch ranges or single commits.

    45k GitHub stars~2k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Code Review

    flutter/flutter

    Performs a comprehensive, multi-step code review of pull requests or local code changes, using iterative refinement (generation, critique, synthesis) to ensure high-quality, actionable feedback.

    179k GitHub stars~1.4k tokensUpdated today
    DevelopmentAuto-check passed

  • PR Review State Fetch

    prisma/orm

    Official

    Fetches a pull request's canonical review state as JSON, validates it, and renders markdown, a text summary and triage target files from it using bundled scripts.

    48k GitHub stars~767 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 Grok Delegate

What does Grok Delegate do?

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

When should I use Grok Delegate?

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

How do I install Grok Delegate in Claude Code?

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

How do I install Grok Delegate in Codex?

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

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

What does Grok Delegate need to run?

Going by SKILL.md and its folder, Grok Delegate needs JavaScript for the scripts in its folder, the command-line tools its instructions call (node and npm) and credentials named XAI_API_KEY. Our summary lists: Node.js; A credential in XAI_API_KEY. Compatibility (from SKILL.md): Requires the `grok` CLI (Grok Build) installed and authenticated (`grok login`, or `XAI_API_KEY`; beta access needs an eligible xAI subscription), Node 18+, and git. 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 Grok Delegate access the network?

SKILL.md contains no URLs. Its commands use npm, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

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

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

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

What are the alternatives to Grok Delegate?

Skills that share tags, products or a category with Grok Delegate: Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars), Open Code Review CLI (alibaba/open-code-review, 45k stars), Understand Diff Analysis (Egonex-AI/Understand-Anything, 86k stars) and Open Code Review Delegate (alibaba/open-code-review, 45k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Grok 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.