amElnagdy/delegate-skills / skills/zcode-delegate
zcode-delegate
VerifiedDelegate 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.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 9.4 KB |
| references/dispatch-and-poll.md | markdown | 6.4 KB |
| references/multi-task-queues.md | markdown | 3.5 KB |
| references/review-and-land.md | markdown | 4.0 KB |
| references/writing-the-brief.md | markdown | 4.9 KB |
| scripts/relay.mjs | script | 47.3 KB |
references/multi-task-queues.md
View on GitHub# Multi-task queues
A queue is a sequence of bounded tasks dispatched one at a time, each reviewed and landed before the
next begins. It is the shape that makes delegation worth the overhead: a migration, a mechanical
refactor across many files, a removal sweep.
**Run them sequentially.** Parallel dispatches against one working tree produce interleaved edits
that no reviewer can untangle, and `touchedFiles` stops meaning anything.
## The loop
For each task in the queue:
1. Write the brief for **this task only**.
2. Dispatch.
3. Wait for `result.json`.
4. Review: re-run the gates, read the diff, check scope.
5. Land it — a commit per task, not one commit at the end.
6. Note anything learned that the next brief needs.
A commit per task is what makes a queue recoverable. When task 6 of 9 goes wrong, you revert one
commit instead of unpicking a nine-task blob.
## Carrying constraints forward
Each brief is written cold, so constraints do not survive on their own. Keep a short block and paste
it into every brief in the queue:
```markdown
# Standing constraints (apply to every task in this queue)
- Do not add dependencies.
- Do not reformat files you are not otherwise changing.
- Public API in src/api/ is frozen; changing it fails review.
- Gates: node test/relay-smoke.mjs
```
Add to this block as you learn. If task 3's review caught a drive-by refactor, task 4's brief should
forbid it explicitly. The block is how a queue gets *more* reliable as it runs rather than less.
## Fresh session per task, usually
Start each task cold — a new dispatch with no `--session`. Independent tasks should not inherit an
earlier task's context, which can carry over assumptions you rejected in review.
Use `--session` **within** a task, for rework, not **between** tasks. The exception is a genuinely
continuous piece of work split across dispatches for length; there, continuing the session preserves
context that a cold brief would have to restate.
## Tracking progress
Keep a visible checklist — the queue, one line each, marked as landed. Update it after the commit,
not after the dispatch. A task is done when it is committed and the gates passed, not when ZCode
said it finished.
Record the `sessionId` of each task next to its line. If a landed task later turns out to be wrong,
that id is the cheapest way back into its context.
## The end-of-run coherence check
Individually correct changes can be collectively wrong. When the queue is done, review the whole
range as one diff:
```bash
git diff <commit-before-the-queue>..HEAD
```
Look for what per-task review structurally cannot catch:
- **Drift** — the same problem solved three different ways across tasks.
- **Duplication** — a helper invented in task 2 and reinvented in task 7.
- **Dead ends** — code added for a task that a later task made unnecessary.
- **Half-migrations** — the old and new patterns now both present, with no task left to finish it.
Then run the gates once more over the final state. A queue where every task passed its own gates can
still end with a broken tree, because task N's gates ran before task N+1 existed.
## When to stop the queue
Stop and go back to the human when:
- Two consecutive tasks need rework for the same reason — the standing constraints are wrong, not
the implementer.
- A task reveals the plan was based on a wrong assumption about the codebase.
- Correct completion needs a scope change. Ask; do not expand the mandate yourself.
Stopping a queue at task 4 with a clear explanation is a better outcome than finishing all nine and
handing over a diff you cannot defend.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |