skill-codex: delegating Claude Code prompts to the Codex CLI

The problem skill-codex solves, and who it is for

Claude Code runs one assistant. If you want a second model to look at the same repository, the usual route is to leave the session, open a terminal, and run the codex CLI by hand. That breaks the flow and loses the context of whatever you were doing in Claude Code.

skill-codex closes that gap with a small piece of packaging. The README states the purpose plainly: enable Claude Code to invoke the Codex CLI (`codex exec` and session resumes) for automated code analysis, refactoring, and editing workflows. It is not a new agent and not a new model. It is a bridge.

The audience is narrow and specific. You need the `codex` CLI installed and available on `PATH`, and you need Codex configured with valid credentials and settings. If either half is missing, the skill has nothing to talk to. Developers who already pay for and use both tools get the benefit; everyone else gets an install that cannot run.

How the delegation actually works

The mechanism is a shell invocation, not an API integration. When Claude Code activates the skill, it constructs a `codex exec` command with a model, a reasoning effort setting, a sandbox mode, and the prompt text, then reads the result back into the conversation.

The README example shows the shape of that command, including a model flag, a reasoning effort config override, a sandbox mode, `--full-auto`, `--skip-git-repo-check`, and a trailing prompt string. Session resumes are mentioned as supported alongside `codex exec`, though the README does not show the resume syntax; it defers to `plugins/skill-codex/skills/codex/SKILL.md` for complete operational instructions and CLI options.

One design decision deserves attention. The skill suppresses thinking tokens by piping stderr to `/dev/null`, and the README gives the reason: to avoid bloating Claude Code's context window. That is a real trade-off. You get a smaller context footprint and you lose Codex's reasoning trace unless you explicitly ask Claude to show it. Whether that is the right default depends on whether you treat the reasoning as debugging output or as part of the value.

Installing skill-codex as a plugin or a standalone skill

The repository is structured as a Claude Code plugin with a marketplace, and the README recommends the plugin route because it brings automatic updates. Two commands do it, entered in Claude Code:

/plugin marketplace add skills-directory/skill-codex
/plugin install skill-codex@skill-codex

The first registers the marketplace, the second installs the plugin. The README does not describe what output confirms success; the practical check is that the skill becomes available to Claude Code afterwards.

The alternative is extracting the skill folder manually. This clones the repository shallowly, creates the skills directory, copies the `codex` folder into it, and removes the temporary clone:

git clone --depth 1 git@github.com:skills-directory/skill-codex.git /tmp/skills-temp && \
mkdir -p ~/.claude/skills && \
cp -r /tmp/skills-temp/plugins/skill-codex/skills/codex ~/.claude/skills/codex && \
rm -rf /tmp/skills-temp

Before either route, confirm the prerequisite. The README says to run `codex --version` and resolve any errors before using the skill:

codex --version

If that command fails, the skill will fail too, because it has nothing to invoke. A first real use is a prompt like the README's example: ask Claude to use codex to analyze the repository and suggest improvements. Claude then asks which model and which reasoning effort level to use, unless you already specified them, and picks a sandbox mode that defaults to `read-only` for analysis.

Model and reasoning effort choices are not automatic

The README lists a default model, `gpt-6-astra`, with alternatives `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, and legacy models such as `gpt-5.5`. Reasoning effort is a separate axis: `low`, `medium`, `high`, `xhigh`, `max`, or `ultra`, and the README notes these are subject to the model's ceiling. That qualifier matters. Selecting `ultra` on a model that does not support it is a configuration error waiting to happen, and the README does not say what the failure looks like.

The skill asks for both values interactively unless your prompt already names them. That is helpful for a one-off and tedious for a repeated workflow. If you run the same analysis regularly, naming the model and effort in the prompt itself is the way to skip the questions.

The sandbox mode is the third choice, and it defaults to `read-only` for analysis. The README example also passes `--full-auto` alongside `read-only`, which is worth reading carefully rather than skimming: the default posture is inspection, and editing workflows are a separate intent you should state deliberately.

Where skill-codex is the wrong tool

The clearest failure mode is environmental. The README puts it first: `codex` must be installed and on `PATH`, and Codex must be configured with valid credentials and settings. If you are a Claude Code user who has never installed the codex CLI, this plugin adds nothing except an error path.

The second limitation is hidden reasoning. Because stderr is discarded by default, a Codex run that produces a poor answer gives you no trace to inspect unless you ask for the thinking tokens explicitly. For a workflow where you are evaluating model quality, that default works against you.

The third is documentation depth. The README covers purpose, prerequisites, two install routes, and one worked example. It does not document rollback, does not show the session resume syntax, and does not list the full set of CLI options. It points at `plugins/skill-codex/skills/codex/SKILL.md` for those details, which is a reasonable place for them and also means the README alone is not enough to operate the skill confidently. There are no releases in the repository, so plugin updates arrive through the marketplace rather than versioned tags you can pin.

How this differs from running codex exec directly, or from a more autonomous setup

The obvious alternative is skipping the plugin and running `codex exec` in a terminal yourself. The commands are identical; the difference is context. Running it directly means you copy the prompt out of Claude Code, run it, and paste the result back. skill-codex keeps that loop inside the session and lets Claude summarize the Codex output, which the README describes as highlighting key suggestions and asking whether to continue with follow-up actions.

A second alternative is named in the README itself. It opens with a pointer: if you want a more autonomous setup for agentic workflows, check out klaudworks/ralph-meets-rex. That is a different posture, not a different wrapper. skill-codex is explicitly a delegation mechanism with a human in the loop choosing model, effort and sandbox each time. An autonomous setup removes those checkpoints. If your goal is unattended iteration, this plugin's interactive prompts are friction rather than a feature.

A third comparison point is doing nothing at all. If you only ever want Claude's answer, a second model pass costs tokens, time, and a model-selection decision every run. skill-codex earns its place when a second opinion on analysis or refactoring is worth that cost.

Licence, maintenance and upgrade cost

The repository is MIT licensed, which permits commercial and private use, modification and redistribution provided the copyright notice and permission notice are retained. That is the standard reading; it is not legal advice, and if you redistribute the skill inside a product you should have someone check the notice requirements.

On maintenance, the last push to the default branch was on 2026-09-13. The repository is not archived. There are no releases, so there is no version number to track and no changelog to read. The practical upgrade cost is low if you installed via the marketplace, since the README says that route brings automatic updates. The standalone route is the opposite: you copied a folder into `~/.claude/skills/codex`, and nothing tells you when upstream changes. Re-running the clone and copy commands is the only refresh path the README offers.

The second cost is configuration drift. The model list in the README includes a default and several alternatives, and Codex's own model availability can change independently of this repository. If a model name stops resolving, the failure surfaces at `codex exec` time, not at install time.

Editorial conclusion

Adopt skill-codex if you already run both Claude Code and the codex CLI and want a second model pass on analysis or refactoring without leaving the Claude Code session. Skip it if codex is not installed, if you need a documented rollback path, or if you want visible reasoning by default. Verify first that codex --version resolves on PATH, then read plugins/skill-codex/skills/codex/SKILL.md, which the README points to but does not reproduce, before you rely on any flag beyond the ones shown in the README example.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. skills-directory/skill-codex on GitHub