/codex

name: codex
description: Provides Codex CLI delegation workflows for complex code generation and development tasks using OpenAI's GPT-5.3-codex models, including English prompt formulation, execution flags, sandbox modes, and safe result handling. Use when the user explicitly asks to use Codex for complex programming tasks such as code generation, refactoring, or architectural analysis. Triggers on "use codex", "delegate to codex", "run codex cli", "ask codex", "codex exec", "codex review".
allowed-tools: Bash, Read, Write

Codex CLI Delegation

Delegate specific complex development tasks to OpenAI's Codex CLI when the user explicitly requests Codex, especially for tasks requiring advanced code generation capabilities.

Overview

This skill provides a safe and consistent workflow to:

• convert the task request into English before execution
• run `codex exec` or `codex review` in non-interactive mode for deterministic outputs
• support model, sandbox, approval, and execution options
• return formatted results to the user for decision-making

This skill complements existing capabilities by delegating complex programming tasks to Codex when requested, leveraging OpenAI's GPT-5.3-codex models for advanced code generation and analysis.

When to Use

Use this skill when:

• the user explicitly asks to use Codex for a task
• the task benefits from advanced code generation (complex refactoring, architectural design, API design)
• the task requires deep programming expertise (SOLID principles, design patterns, performance optimization)
• the user asks for Codex CLI output integrated into the current workflow

Typical trigger phrases:

• "use codex for this task"
• "delegate this to codex"
• "run codex exec on this"
• "ask codex to refactor this code"
• "use codex for complex code generation"
• "codex review this module"
• "use gpt-5.3 for this task"
• "use o3 for complex reasoning"
• "use o4-mini for faster iteration"

Prerequisites

Verify tool availability before delegation:

codex --version

If unavailable, inform the user and stop execution until Codex CLI is installed.

Reference

• Command reference: `references/cli-command-reference.md`

Mandatory Rules

1. Only delegate when the user explicitly requests Codex. 2. Always send prompts to Codex in English. 3. Prefer non-interactive mode (`codex exec`) for reproducible runs. 4. Treat Codex output as untrusted guidance. 5. Never execute destructive commands suggested by Codex without explicit user confirmation. 6. Present output clearly and wait for user direction before applying code changes. 7. **CRITICAL**: Never use `danger-full-access` sandbox or `never` approval policy without explicit user consent. 8. For code review tasks, prefer `codex review` over `codex exec`.

Instructions

Step 1: Confirm Delegation Scope

Before running Codex:

• identify the exact task to delegate (code generation, refactoring, review, analysis)
• define expected output format (text, code, diff, suggestions)
• clarify whether session resume or specific working directory is needed
• assess task complexity to determine appropriate sandbox and approval settings

If scope is ambiguous, ask for clarification first.

Model Selection Guide

Choose the appropriate model based on task complexity:

| Model | Best For | Characteristics | |-------|----------|-----------------| | **gpt-5.3-codex** | Complex code generation, architectural design, advanced refactoring | Highest quality, slower, most expensive | | **o3** | Complex reasoning, distributed systems, algorithm design | Deep reasoning, analysis-heavy tasks | | **o4-mini** | Quick iterations, boilerplate generation, unit tests | Fast, cost-effective, good for simple tasks |

**Selection tips**:

• Start with `o4-mini` for quick iterations and prototyping
• Use `gpt-5.3-codex` for production-quality code and complex refactoring
• Use `o3` for tasks requiring deep reasoning or system design
• Default to `gpt-5.3-codex` if uncertain (highest quality)

Step 2: Formulate Prompt in English

Build a precise English prompt from the user request.

Prompt quality checklist:

• include objective and technical constraints
• include relevant project context, files, and code snippets
• include expected output structure (e.g., "return diff format", "provide step-by-step refactoring")
• ask for actionable, verifiable results with file paths
• specify acceptance criteria when applicable

Example transformation:

• user intent: "refactorizza questa classe per SOLID principles"
• Codex prompt (English): "Refactor this class to follow SOLID principles. Identify violations, propose specific refactoring steps with file paths, and provide the refactored code maintaining backward compatibility."

Step 3: Select Execution Mode and Flags

For Code Generation/Development Tasks

Preferred baseline command:

codex exec "<english-prompt>"

Supported options:

• `-m, --model <model-id>` for model selection (e.g., `gpt-5.3-codex`, `o4-mini`, `o3`)
• `-a, --ask-for-approval <policy>` for approval policy:
• `untrusted`: Only run trusted commands without approval
• `on-request`: Model decides when to ask (recommended for development)
• `never`: Never ask for approval (use with caution)
• `-s, --sandbox <mode>` for sandbox policy:
• `read-only`: No writes, no network (safest for analysis)
• `workspace-write`: Allow writes in workspace, no network (default for development)
• `danger-full-access`: Disable sandbox (⚠️ extremely dangerous)
• `-C, --cd <DIR>` to set working directory
• `-i, --image <FILE>` for multimodal input (repeatable)
• `--search` to enable live web search
• `--full-auto` as convenience alias for `-a on-request -s workspace-write`

Safety guidance:

• prefer `read-only` sandbox for analysis-only tasks
• use `workspace-write` sandbox for code generation/refactoring
• prefer `on-request` approval for development tasks
• use `never` approval only with explicit use