Codex Delegate

Decide when to delegate code-heavy, multi-file, or repo-intensive tasks to Codex while keeping final judgment and context in the main agent.

Security Scan

The skill's instructions, requirements, and scope are consistent with its stated purpose of deciding when to delegate tasks to Codex; it is instruction-only and requests no credentials or installs.

Purpose & Capability

Name and description align with the SKILL.md: the skill's goal is to decide delegation to Codex, and it does not request unrelated binaries, env vars, or configs.

Instruction Scope

The runtime instructions are limited to decision-making heuristics and output structure; they do not instruct the agent to read arbitrary files, exfiltrate data, call external endpoints, or access secrets.

Install Mechanism

No install spec or code files are provided; this is instruction-only, so nothing will be written to disk or fetched at install time.

Credentials

No environment variables, credentials, or config paths are required — the declared requirements are minimal and proportional to the skill's purpose.

Persistence & Privilege

The skill does not request always:true or other elevated persistence. It is user-invocable and allows autonomous invocation (the platform default), which is appropriate for a routing/decision skill.

Assessment

This skill is coherent and low-risk: it only provides guidance about when to delegate work to Codex and asks for no installs or secrets. Before using, remember the main-agent must still validate and accept any code changes Codex proposes — never let delegated execution bypass your final review. If you plan to have the agent actually run repository edits or tools, ensure the agent's runtime environment and any required credentials are configured separately and reviewed.

Use this skill to decide whether Codex should be used, what part should be delegated, and what must remain with the main agent.

Core rule

Codex is a specialist executor, not the long-term owner of the human relationship. Use Codex for heavy technical work, isolated analysis, and context offloading. Keep final judgment, risk trade-offs, environment acceptance, and user-facing conclusion in the main agent.

When to delegate to Codex

Delegate when the task is:

• code-heavy
• repo-heavy
• multi-file
• CLI-heavy
• deep review / audit work
• likely to consume too much token/context in the main thread
• better handled in an isolated, clean context

Typical examples:

• repository analysis
• skill/package review
• deep code review
• bug investigation
• patch drafting
• dependency and config analysis
• log/error analysis

When NOT to delegate fully

Do not fully hand off tasks that depend on:

• long-term memory
• user preference and tone alignment
• final risk judgment
• environment acceptance across shell / gateway / cron / LaunchAgent
• upgrade timing and change management
• whether a temporary workaround becomes the official solution

Codex may assist, but the main agent must still decide.

Delegation split

Codex should do

• static inspection
• file and repo structure analysis
• code/package consistency checks
• focused error analysis
• technical option comparison
• isolated patch or remediation proposals
• heavy token-consuming analysis that would otherwise bloat the main session

Main agent should do

• define the real goal
• set scope and constraints
• choose whether Codex is the right tool
• evaluate user risk tolerance and workflow fit
• validate dynamic/runtime reality
• decide whether something is truly "done"
• deliver the final recommendation in the human's context

Validation rule

Never confuse these layers:

• reviewed by Codex
• technically plausible
• works in current shell
• works in gateway
• works in cron
• accepted as the official solution

The first three can often be delegated. The last three require main-agent ownership.

Token discipline

Delegation is not just about capability. It is also about saving token and protecting the main thread. Delegate when:

• the task would create a large technical detour
• the analysis is mostly local and mechanical
• the result can be brought back as a short conclusion

Do not delegate when the cost of coordination exceeds the saved context.

Lightweight workflow

1. Define the task in one sentence.
2. Ask: is this mainly technical execution or human-facing judgment?
3. If mainly technical execution, delegate the heavy part to Codex.
4. Require Codex output to stay structured and narrow.
5. Bring back only the useful result.
6. Do final validation and decision in the main agent.

Output structure

When using this skill, report with:

• conclusion
• should delegate or not
• what Codex should handle
• what the main agent must keep
• validation level required before calling it done

Keep it short. Prefer good routing over long explanation.

Attribution

• Author: 石屹
• For: 加十
• Affiliation: 为加十工作流设计
• Note: built for 加十