Skip to content
Skills Library
AI & agents · Planning

codex-delegate

/codex-delegate

Delegation policy for handing work to Codex — implementation of modules whose interface contract is fixed, independent verification, and pre-commit review. Use when deciding whether and how to hand a piece of work to Codex.

Author
kcng0 ↗
Licence
MIT
Last repository change
05.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 05.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Delegation policy for handing work to Codex — implementation of modules whose interface contract is fixed, independent verification, and pre-commit review. Use when deciding whether and how to hand a piece of work to Codex.

Original author description

Delegation policy for handing work to Codex — implementation of modules whose interface contract is fixed, independent verification, and pre-commit review. Use when deciding whether and how to hand a piece of work to Codex.

How it works

  1. Scope
  2. Implementation
  3. Independent verification
  4. Pre-commit review
Original SKILL.md headings · 48 lines, 518 words
SKILL.md preview
---
name: codex-delegate
description: Delegation policy for handing work to Codex — implementation of modules whose interface contract is fixed, independent verification, and pre-commit review. Use when deciding whether and how to hand a piece of work to Codex.
---

# Handing work to Codex

All three cases dispatch through the `codex` skill.

## Scope

By default Codex takes:

- **Implementation of self-contained modules whose interface contract is already fixed**, typically backend modules (routes, services, data access, CLIs). Work whose correctness depends on look and feel, such as UI, stays with you.
- **Independent verification** and **pre-commit review**.

The user's or project's instructions override this scope. When they widen it (for example, "Codex may do frontend work") or narrow it, follow them.

## Implementation

1. Before dispatching, write these into the task file:
   - the interface contract (routes, signatures, data shapes, error semantics)
   - file ownership
   - the real entry point that exercises the module
   - shared resources: ports, databases, whether dependencies may be installed

   If you cannot fill these in, do the work yourself or ask the user.
2. Use the `implement` role. Dispatch independent modules in parallel in one message, and keep working on other independent things.
3. When results come back, read the diff, trigger the real entry point once yourself, then integrate.

## Independent verification

Use it when the user asks, or when the change is high-risk: schema or data migrations, authentication or permission checks, money or billing calculations, concurrency/locking/idempotency, or incompatible changes to an external API. Ordinary changes do not need it.

1. Write into the task file:
   - the working directory
   - the scope of the change (files or diff)
   - the expected behavior
   - the real entry point

   Fill in anything missing before dispatching.
2. Use the `check` role with `--schema <codex skill dir>/schemas/check.json` (the schema the `codex` skill ships), so the result comes back as structured counterexamples. If Codex wrote the change, verify with a different model than the author's (`-m`).
3. Weigh each counterexample before acting on it. A concrete input, an `expected_source` outside the code under test and an obvious fix are enough: just fix it. Check it yourself first when something looks off: the expected value is inferred rather than sourced, the input is not reachable from the real entry point, it contradicts what you know about the code, or the fix would change a contract or design. If it does not hold, resume the thread with your evidence (the `codex` skill's "Treating results").
4. A clean result is only as strong as its `coverage`. If `not_covered` includes the risky part of the change, extend the verification or tell the user.
5. After fixing, resume the same thread by id to re-verify. If counterexamples are still open after two rounds, hand them to the user.

## Pre-commit review

1. Run it when the user asks, or before committing or merging a batch of non-trivial changes. Use the `codex` skill's Review section: the default for uncommitted changes, `--base <branch>` for a branch. Put known risk areas in the focus file.
2. Review is read-only and runs no code. To find counterexamples by actually exercising the change, use independent verification instead.
3. Go through each finding: fix the ones that clearly hold, check doubtful ones against the code before deciding, and tell the user which you dismissed and why.

Versions

RepositoryScoreLicence
This page · kcng0/cc-codex-run100MIT
FrancoStino/opencode-skills-collection100MIT
kachofugetsu09/akashic-agent100MIT
wenyuchiou/codex-delegate100MIT
sickn33/agentic-awesome-skills100MIT
joezhuo2/delegate-skills100MIT
amelnagdy/delegate-skills100MIT
smk-labs/claude-plugins100MIT
Song-Sungyoub/claude-codex-delegate95MIT

Database snapshot: 13.11.2026 · package version 9c38c66cf469 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100codex-rescue
    Delegate an implementation task to Codex, then Claude reviews the result. Use when asked \"codex rescue\", \"delegate to codex\", \"have codex do it\", or wants Codex to implement or fix something.
  • 100codex-review
    Use when you want an independent Codex review of a plan, spec or code change at a major checkpoint or before merging, when asked for a "codex review" or "second opinion", or before writing `codex exec` by hand.
  • 100codex
    Claude-to-Codex bridge to delegate bulk mechanical work, get an independent cross-model diff review, or ask a read-only question. Triggers only when the user names Codex, as in "use codex", "have codex review", "cross-check with codex", "ask codex".
  • 90dispatching-to-codex
    Use when the user explicitly asks to hand a task to Codex — "use codex", "delegate this", "send it to codex", "交给codex", "派给codex", or the /delegate command. Runs the full dispatch lifecycle with frozen acceptance criteria and a binding independent judge. NEVER auto-dispatch —…
  • 90delegate
    Delegate a bounded task with /delegate and a self-contained brief. Use when work is independent, parallel, or needs a fresh context, and the parent must keep the scope, the diff review, and the checks.
  • 100implement
    Delegate a coding task to a Codex subagent (GPT 6.1 Sol by default) that writes files directly in the working directory. Use when the user wants Codex — or "GPT-5.5" — to build, implement, write, add, refactor, fix, or otherwise change code, whether they say "have Codex do X",…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.