Przejdź do treści
Biblioteka skilli
AI i agenci · Przegląd i audyt

codex-cli

/codex-cli

Współpracuje z OpenAI Codex CLI przy przeglądzie planu, przeglądzie kodu i dyskusji nad trudnymi problemami, z wyborem modelu i wieloma rundami rozmowy.

Licencja
MIT
Ostatnia zmiana repozytorium
20.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Współpracuje z OpenAI Codex CLI przy przeglądzie planu, przeglądzie kodu i dyskusji nad trudnymi problemami, z wyborem modelu i wieloma rundami rozmowy.

Oryginalny opis (EN)

Interact with OpenAI Codex CLI for plan review, code review, and complex problem discussion. Supports either ChatGPT-account or API-key login, model selection, and multi-round conversations. Use when the user wants a second opinion from Codex on an implementation plan, a diff, or a hard technical question, or invokes /codex-cli. Usage: /codex-cli <command> [options]

Jak działa

  1. 🚨 Model Rule — READ FIRST
  2. codex exec IS an agent loop (not single-shot)
  3. Prerequisites
  4. Sandbox — what actually runs
  5. Capabilities inside codex exec
  6. CLI Flag Reference
  7. Recommended Command Forms
  8. Reasoning Effort
  9. Long-Running Calls — Background Mode
  10. User Interface (how the skill is invoked)
Sekcje z nagłówków SKILL.md, w oryginale · 189 linii, 1 514 słów
Podgląd SKILL.md
---
name: codex-cli
description: "Interact with OpenAI Codex CLI for plan review, code review, and complex problem discussion. Supports either ChatGPT-account or API-key login, model selection, and multi-round conversations. Use when the user wants a second opinion from Codex on an implementation plan, a diff, or a hard technical question, or invokes /codex-cli. Usage: /codex-cli <command> [options]"
---

# Codex CLI Interaction Skill

Interact with OpenAI Codex CLI to leverage its reasoning for plan review, code analysis, and complex problem discussions.

> **Naming**: "codex-cli" **Skill** = this document. "Codex CLI" = the OpenAI command-line tool being invoked.

## 🚨 Model Rule — READ FIRST

- **If the user names a model, use exactly that model.** Respect the user's choice.
- **If the user does NOT name a model, do NOT pass `-m` or `-c model=` at all.** Let Codex use the default from `~/.codex/config.toml`.
- **Never hardcode a model name.** Model names change across Codex releases, and the names available under ChatGPT-account login differ from those under API-key login. Hardcoding a name is the #1 cause of "model does not exist" failures.
- To see the active default without guessing: run any `codex exec` — its header prints `model: <name>` — or read the `model = "..."` line in `~/.codex/config.toml`.

## `codex exec` IS an agent loop (not single-shot)

`codex exec` is **non-interactive**, which is NOT the same as "single-shot". Each `codex exec` call runs a **full agent loop**: Codex autonomously reads files, greps, runs shell commands, and reasons over many steps before returning. "Non-interactive" only means there is no human back-and-forth *mid-run* — it does not reduce Codex's agentic capability.

- This is why the skill uses `codex exec` (not the interactive TUI): you can't drive an interactive terminal from another agent, but `exec` gives you the same autonomous loop.
- For a **follow-up round** (e.g. round 2 of a review), continue the SAME session:
  `codex exec resume <session-id> "<follow-up>"`. Capture the `session id:` printed in round 1's header.
- **Do NOT use `resume --last` in automation.** `--last` resolves to the most recent session globally; any concurrent Codex call steals "last", so you resume the wrong thread. Always resume by explicit `<session-id>`.

## Prerequisites

1. **Codex CLI installed**
   ```bash
   which codex && codex --version
   ```
   Install path depends on your installer (e.g. `~/.local/bin/codex`, or a package manager). If missing, follow the OpenAI Codex CLI install docs.

2. **Logged in — two supported paradigms.** Check the current one first:
   ```bash
   codex login status
   ```

   **Paradigm A — ChatGPT account (OAuth).** Uses your ChatGPT subscription quota and rate limits.
   ```bash
   codex login          # opens a browser to authorize; no API key needed
   ```
   `codex login status` → `Logged in using ChatGPT`.

   **Paradigm B — API key.** Billed per API usage.
   ```bash
   codex login --with-api-key            # reads the key from stdin
   # non-interactive: codex login --with-api-key <<< "$OPENAI_API_KEY"
   ```
   `codex login status` → `Logged in using an API key - sk-***`.

   > The skill's commands are **identical** under both paradigms. What differs: billing, rate limits, and which **model names** are available — which is exactly why you must not hardcode `-m` (see Model Rule).

## Sandbox — what actually runs

- `codex exec`'s **nominal** default is `read-only`, **but `~/.codex/config.toml` (`sandbox_mode`) overrides it.** If your config sets `danger-full-access`, commands run with full write access unless you pass `-s read-only` explicitly.
- **This skill follows your config; it does NOT force a sandbox.** For a guaranteed no-writes review, add `-s read-only`.
- Check yours: the `codex exec` header prints `sandbox: <mode>`, or read `sandbox_mode` in `~/.codex/config.toml`.

## Capabilities inside `codex exec`

| Capability | Status | Notes |
|------------|--------|-------|
| Shell + file tools | ✅ stable | Codex autonomously reads your repo, greps, runs commands (subject to sandbox). |
| Web / internet search | ⚠️ not available by flag | `codex exec` has no `--search` flag (only the interactive `codex --search` has one), and the old `web_search_*` feature flags are deprecated. Do not assume Codex can browse the web from `exec`. |
| `browser_use` / `computer_use` | ⚠️ account-only | Depend on the ChatGPT.app ecosystem; unreliable under non-interactive `exec`. |

## CLI Flag Reference

> **⚠️ `codex review` and `codex exec review` have DIFFERENT flags.**
> - `codex review` (top-level): **NO `-m` flag.** Set a model with `-c model="..."` only.
> - `codex exec review`: supports `-m` **and** `-c model="..."`.

### Flag Compatibility Matrix

| Flag | `codex review` | `codex exec review` | `codex exec "prompt"` |
|------|:-:|:-:|:-:|
| `-m, --model` | **NO** | YES | YES |
| `-c, --config` | YES | YES | YES |
| `--uncommitted` | YES | YES | NO |
| `--base` | YES | YES | NO |
| `--commit` | YES | YES | NO |
| `-s, --sandbox` | NO | NO | YES |
| `--skip-git-repo-check` | NO | YES | YES |

## Recommended Command Forms

> These follow your `config.toml` model by default. Add `-c model_reasoning_effort="..."` to override effort; add a model flag ONLY if the user named a model.

### Code review (use top-level `codex review` — simplest)
```bash
codex review --uncommitted                       # review staged+unstaged+untracked
codex review --base main                          # review changes vs a branch
codex review --commit HEAD~1                      # review a specific commit
# A review target (--uncommitted/--base/--commit) cannot be combined with custom
# instructions. For a focused review, use exec and name the diff in the prompt:
#   codex exec -s read-only "Review git diff main...HEAD for <focus>. Report file:line findings."
# effort override:  codex review --uncommitted -c model_reasoning_effort="high"
# user named model M: codex review --uncommitted -c model="M"   # NOTE: -c, not -m
```

### Plan review / questions (use `codex exec`)
```bash
codex exec "Review this implementation plan: [...]
Evaluate: technical soundness, risks, missing considerations, approval status" \
  --skip-git-repo-check
# guaranteed no writes:  add  -s read-only
# user named model M:    add  -m M
```

### Code review via exec (only when you need `-m`)
```bash
codex exec review --base main
codex exec review --uncommitted
```

### Multi-round review (preserve context)
```bash
# Round 1 — capture the session id printed in the header
codex exec review --uncommitted            # header shows: session id: <UUID>
# Round 2+ — resume that EXACT session (never --last in automation)
codex exec resume <UUID> "Re-review after I addressed points 1 and 3."
```

## Reasoning Effort

- **Default: follow config** — do not pass an effort flag. Your config may already set a high tier (e.g. `xhigh`).
- **Override per call:** `-c model_reasoning_effort="medium|high|xhigh"`.
- Rule of thumb if you must choose: short questions → `medium`; reviews/plans → `high`; critical → `xhigh`.

## Long-Running Calls — Background Mode

For calls expected to exceed ~60s (`xhigh` effort, `--base` on large diffs, full-repo audits):
- Invoke via `Bash(run_in_background=true)` so the main session stays responsive; Claude Code writes the output to a file — read it with `Read` when the command finishes, or run the command with `Monitor` to receive output lines as they arrive.
- **Sampling tip:** launch 2–3 background runs of the same prompt in parallel — Codex output is non-deterministic, and merging runs surfaces more real issues than one run.
- Do NOT background short `ask`/single-file reviews — the realtime reasoning trace is more useful in foreground.
- ❌ Do NOT invoke Codex via a subagent (`Agent` tool). Run it from the main session with `Bash(run_in_background=true)` instead.

## User Interface (how the skill is invoked)

```bash
/codex-cli ask "question"          # quick question
/codex-cli "question"              # shorter form of ask
/codex-cli reviewplan              # review an implementation plan
/codex-cli review --uncommitted    # review uncommitted changes
/codex-cli review --base main      # review changes vs branch
```
Map each to the recommended command forms above.

## Output Format

Relay Codex feedback faithfully — do not summarize or filter. After each interaction:

```
=== CODEX FEEDBACK [Round N/MAX] ===
Model: <from header>   Reasoning: <effort>   Status: APPROVED / NEEDS REVISION
[Codex full response]
=== END CODEX FEEDBACK ===
```

## Troubleshooting

| Symptom | Fix |
|---------|-----|
| `command not found: codex` | Not installed. `which codex` should return your install path. |
| `Authentication required` | Not logged in. `codex login` (account) or `codex login --with-api-key` (API); verify with `codex login status`. |
| `model 'xxx' does not exist` | You passed `-m` with a name unavailable in your login mode. **Drop `-m`** to use the config default. |
| `-m` rejected on `codex review` | Top-level `codex review` has no `-m`. Use `-c model="..."`, or switch to `codex exec review`. |
| `Specify --uncommitted, --base, or --commit` | Review needs a target: `--uncommitted` / `--base <branch>` / `--commit <sha>`. |
| Resume ignored my prior context | You used `--last` with concurrent sessions. Resume by explicit `<session-id>`. |
| Command hangs | You invoked Codex via a subagent (`Agent` tool). Run it from the main session with `Bash(run_in_background=true)`. |

**Verify setup:**
```bash
which codex && codex --version
codex login status
codex exec "reply OK" --skip-git-repo-check   # header shows active model + sandbox
```

## Security & Privacy

- **Code transmission:** your code/prompts are sent to OpenAI for processing.
- **Credentials:** stored under `~/.codex/` (`auth.json`). Keep the directory private.
- **Sensitive code:** be mindful when reviewing code with secrets or proprietary logic.
- See [OpenAI's data usage policies](https://openai.com/policies/api-data-usage-policies).

## References

- [OpenAI Models Documentation](https://developers.openai.com/api/docs/models) — model names change; verify against your login mode.
- Local source of truth for defaults: `~/.codex/config.toml` and `codex login status`.
Pliki w paczce (2)
  • README.md 7 KB
  • SKILL.md 10 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · awakehsh/awesome-agent-tools100MIT
colinmollenhour/dotfiles100Apache-2.0
scarletkc/agents100Apache-2.0
sugarforever/01coder-agent-skills100MIT
georgekhananaev/claude-skills-vault100MIT
wentorai/research-claw95Apache-2.0

Migawka bazy z 13.11.2026 · wersja paczki a3a877545e61 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90codex
    Prosi Codex CLI o drugą opinię, przegląd kodu albo wykonanie zadania, gdy użytkownik o to poprosi.
  • 100codex-review
    Uzyskuje niezależną drugą opinię OpenAI Codex CLI o planie, diffie, specyfikacji lub ostatniej odpowiedzi Claude, także w formie przeglądu adwersaryjnego.
  • 100codex-review
    Uzyskuje drugą opinię o kodzie od Codex przez CLI codex-run, dla PR lub lokalnej zmiany, i publikuje ją tylko po zgodzie.
  • 100codex
    Wywołuje OpenAI Codex CLI do współpracy między modelami, drugiej opinii i delegowanej pracy: przegląd, debugowanie, wyjaśnianie, planowanie i implementacja.
  • 90codex
    Deleguje dobrze opisane zadania kodowe i przeglądy do Codex CLI jako drugiemu modelowi do sprawdzenia.
  • 100codex
    Uruchamia OpenAI Codex CLI przez AWS Bedrock nieinteraktywnie, by uzyskać drugą opinię, przejrzeć diff lub zlecić zadanie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.