El plugin oficial que le pone a Claude Code un segundo tope de uso

El plugin no reemplaza a Claude. Lo separa de la tarea que más consumo genera. La regla es simple: todo lo que implique decidir, organizar y revisar queda en Claude. Todo lo que implique escribir código nuevo, perseguir un error o rehacer una parte entera del proyecto se va a Codex: unas veces con un comando que tecleas tú, y otras lo pasa Claude solo, en cuanto dejas escrito el reparto.

Abre una sesión de Claude Code y escribe estos cuatro comandos dentro de la sesión, uno por uno, en orden. Los cuatro empiezan con diagonal: son de Claude Code, no de una terminal. Después de cada uno espera a que termine antes de escribir el siguiente.

Los cuatro comandos funcionan. Pero si vas a hacer esto en tres máquinas, o si te da flojera copiar y pegar uno por uno esperando a que cada uno termine, hay un camino más corto: le pegas un solo prompt a Claude y él se encarga de la parte que sí puede hacer solo. Al final quedan dos comandos tuyos, y la sección te dice cuáles.

Antes de dártelo, un detalle técnico que casi nadie te dice y que cambia todo.

Lo que Claude va a correr por ti

No copies estos: van dentro del prompt. Los ponemos a la vista para que sepas exactamente qué se está ejecutando en tu máquina y puedas frenarlo si algo no te cuadra.

claude plugin marketplace add openai/codex-plugin-cc
claude plugin install codex@openai-codex --scope user --yes
claude plugin list

El ámbito «user» deja el plugin disponible en todos tus proyectos, no solo en la carpeta donde estás parado. La bandera «--yes» acepta el comando que declara el marketplace sin detenerse a preguntar.

Quiero que instales el plugin oficial de Codex de OpenAI en mi Claude Code.
Hazlo tú, con comandos de terminal. Para instalar no uses comandos que empiecen
con diagonal: esos no los puedes ejecutar tú. Los dos que me tocan a mí me los
dices hasta el final, en el reporte.

Sigue este orden exacto y no te saltes pasos:

1. Corre "claude plugin list" y dime qué encuentras. Si el plugin codex del
   marketplace openai-codex ya aparece ahí, no instales nada: salta al paso 5 y
   avísame que ya estaba puesto.

2. Si no aparece, agrega el marketplace:
   claude plugin marketplace add openai/codex-plugin-cc

3. Instala el plugin para toda mi cuenta, sin detenerte a preguntarme:
   claude plugin install codex@openai-codex --scope user --yes

4. Vuelve a correr "claude plugin list" y pégame el resultado tal cual, sin
   resumirlo. Si el plugin no aparece en esa lista, dime el error textual y
   detente ahí: no intentes rutas alternas ni instales nada más.

5. Revisa si tengo el CLI de Codex en la máquina con "codex --version". Si el
   comando no existe, instálalo con:
   npm install -g @openai/codex
   y vuelve a comprobar con "codex --version". Si npm falla por permisos, no
   uses sudo: párate ahí y muéstrame el error.

6. No intentes iniciar sesión en Codex por tu cuenta. Ese paso abre una ventana
   de autenticación en el navegador y me toca a mí.

Cuando termines, dame un reporte de cinco líneas, sin adornos:
- si el marketplace quedó agregado
- si el plugin quedó instalado, y en qué versión
- si el CLI de Codex está, y en qué versión
- qué falló, si algo falló, con el error textual
- recuérdame que me faltan dos pasos míos, en este orden: escribir
  /reload-plugins (o cerrar y volver a abrir la sesión) y después /codex:setup

No edites ningún archivo de mi proyecto. No corras nada que no esté en esta
lista.

Cómo sabes que quedó

El paso 4 del prompt existe por una razón: un instalador que no comprueba su propio trabajo te deja creyendo que ya está. Esto es lo que tiene que devolverte la lista.

$ claude plugin list

Installed plugins:

  codex@openai-codex
    enabled    scope: user
    Use Codex from Claude Code to review code or delegate tasks.

El formato de la lista cambia entre versiones, así que no lo compares letra por letra. Lee tres cosas: que aparezca codex@openai-codex, que diga que está habilitado, y que el ámbito sea user. Si falta cualquiera de las tres, todavía no está.

Los dos pasos que sí tecleas tú

El prompt hace todo lo que se puede hacer sin ti. Quedan dos, y los dos son de diagonal, así que van dentro de una sesión de Claude Code.

Cerrar la sesión y volver a abrirla hace lo mismo que recargar. El segundo comando es el único que no se puede automatizar de ninguna forma: revisa la instalación y abre la autenticación con tu cuenta. Tú decides con qué cuenta entras, y esa decisión no se delega.

Si prefieres hacerlo con el ratón en lugar de la terminal, esa ruta se explica en Fable orquesta a Codex. Aquí seguimos con la que se puede pegar de una sola vez.

Con esto el plugin ya vive en tu cuenta. Y ahí es donde casi todos se detienen, que es justo donde empieza el problema de verdad.

Tener el plugin puesto no cambia nada por sí solo. Claude no sabe que ahora tiene a quién delegarle, así que sigue haciendo todo él, y tú terminas acordándote a media tarea de que existía otra opción.

Cada sesión nueva empieza en blanco. Si el reparto solo vive en tu cabeza, lo vas a repetir a mano toda la semana. La solución es escribirlo una vez en el CLAUDE.md del proyecto: ese archivo lo lee Claude al arrancar, sin que se lo pidas.

Y hay una pieza que hace que el reparto se sostenga solo. El plugin no trae nada más comandos: trae también un subagente llamado codex-rescue, y su propia descripción le dice a Claude que lo use por su cuenta, sin esperar a que se lo pidas, cuando toca pasarle a Codex una tarea de construcción larga o una investigación de fondo. Los comandos con diagonal los tecleas tú; al subagente Claude sí lo puede llamar solo. Por eso la regla se escribe como un criterio de reparto y no como una lista de comandos.

Quiero dejar por escrito, en el CLAUDE.md de este proyecto, cómo repartes el
trabajo entre tú y Codex. Así no tengo que recordártelo en cada sesión nueva.

Antes de escribir una sola línea:

1. Busca si ya existe un archivo CLAUDE.md en la raíz del proyecto. Si existe,
   léelo completo.
2. Dime en una línea qué secciones tiene hoy, para que yo sepa qué había.
3. Si ya hay una sección sobre Codex o sobre repartir tareas, no la dupliques:
   muéstrame qué dice y propón cómo la reemplazas. Espera mi respuesta.

Si no hay nada de eso, agrega al final del archivo una sección nueva titulada
"Reparto con Codex". No toques, no reordenes ni resumas nada de lo que ya está
escrito arriba. La sección tiene que dejar claras estas cuatro cosas:

- Que tú te quedas con entender el problema, planear, decidir la arquitectura y
  revisar lo que vuelve.
- Que la construcción repetitiva, los refactors grandes y los errores atorados
  se le pasan a Codex, y que ese pase lo haces tú con el subagente codex-rescue,
  por tu cuenta, sin esperar a que yo te lo pida.
- Que nada de lo que vuelve de Codex se da por bueno sin que tú lo revises, y que
  me cuentas qué le pediste y qué volvió.
- Que si Codex falla dos veces en la misma tarea, esa tarea regresa a ti y no se
  insiste una tercera vez.

Escríbela en español, en frases cortas y en presente. Sin ejemplos de código,
sin listas de veinte puntos y sin explicar qué es Codex: el archivo es para ti,
no para un lector nuevo.

Cuando termines, enséñame el bloque exacto que quedó escrito y dime en qué parte
del archivo lo pusiste. Si el proyecto no tenía CLAUDE.md, créalo con esa sola
sección y avísame que lo creaste tú.

El bloque, por si lo prefieres a mano

Si no quieres que Claude te toque el archivo, ábrelo tú y pega esto al final. Dice lo mismo que produce el prompt.

## Reparto con Codex

El plugin de Codex está instalado. El trabajo se reparte así.

Te quedas tú (Claude):
- Entender el problema y preguntar lo que falte.
- Planear los pasos antes de tocar archivos.
- Decidir la arquitectura y los límites de cada cambio.
- Revisar todo lo que vuelva de Codex.

Se le pasa a Codex, con el subagente codex-rescue y sin esperar a que
te lo pida:
- Construcción repetitiva y larga.
- Refactors grandes que tocan muchos archivos.
- Errores atorados que ya se intentaron una vez.

Reglas fijas:
- Nada de lo que vuelve de Codex se da por bueno sin revisar.
- Si Codex falla dos veces en la misma tarea, la tarea regresa a ti.
- Delegar no es desentenderse: dime qué pediste y qué volvió.

Dónde aplica esta regla

El CLAUDE.md del proyecto solo manda dentro de ese proyecto. Si abres otra carpeta, ahí no existe y Claude vuelve a hacer todo él.

Si quieres el mismo reparto en todo lo que tocas, el bloque va en el CLAUDE.md de tu carpeta de usuario. Ese lo lee Claude en cualquier proyecto, y el del proyecto se le suma encima cuando existe.

A partir de aquí el reparto ya no depende de que te acuerdes. Lo que sigue es saber qué pedir a mano: los ocho comandos que trae el plugin y que tecleas tú, y qué hace cada uno.

Con el plugin puesto, Claude Code gana ocho comandos nuevos. Se escriben dentro de la sesión, empezando con una diagonal, igual que los que ya usas. Ninguno de los ocho se corre en una terminal normal.

No hace falta aprendértelos de memoria. Con revisar, cuestionar y delegar cubres casi todo el día; los demás existen para ver cómo va un trabajo, recogerlo o cortarlo.

Qué es Codex por dentro —sus modelos, su archivo de instrucciones y su caja de arena— no se explica aquí: eso vive en la guía de Codex de OpenAI. Esta página lo da por sabido y va directo al reparto del trabajo.

Cada prompt activa un flujo distinto entre Claude y Codex. Copia, pega, llena los huecos entre corchetes con lo tuyo y deja el resto como está. Están redactados para que el traspaso quede claro en los dos sentidos: cuándo Claude prepara, cuándo Codex ejecuta, cuándo vuelve a Claude a documentar.

Voy a implementar [DESCRIBE LA FEATURE O EL CAMBIO] en este proyecto.

Antes de escribir una sola línea, hazme un plan y espera mi aprobación:
1. Lee los archivos que se van a tocar y dímelos por ruta completa.
2. Parte el trabajo en pasos chicos. Un objetivo y un archivo principal por paso.
3. Marca cada paso como [PLAN] si es decidir o diseñar, o [EJECUCIÓN] si es escribir o modificar código.
4. Para cada paso [EJECUCIÓN] escribe el encargo que le vas a pasar a Codex: qué archivo toca, qué comportamiento nuevo tiene que quedar, qué NO debe cambiar, y cómo se comprueba que salió bien.
5. Cierra el plan diciéndome en una línea cuál es el riesgo más grande.

Al terminar el plan te detienes y esperas mi respuesta. No toques nada todavía.

Si te digo que sí, sigue así:
- Los pasos [PLAN] los haces tú.
- Los pasos [EJECUCIÓN] los delegas a Codex uno por uno con el subagente codex-rescue, pasándole el encargo que ya escribiste.
- No mandes dos pasos a la vez. Espera el resultado de cada uno, léelo y dime en dos líneas qué cambió antes de seguir con el siguiente.
- Si un paso vuelve incompleto o con errores, no lo repares por tu cuenta: dímelo y espera.

/codex:rescue

Contexto: estoy trabajando en [BREVE DESCRIPCIÓN DEL PROYECTO].

El error que aparece es:
[PEGA AQUÍ EL ERROR COMPLETO, TAL CUAL SALE EN PANTALLA]

Lo que ya se intentó:
1. [INTENTO 1 Y POR QUÉ NO FUNCIONÓ]
2. [INTENTO 2 Y POR QUÉ NO FUNCIONÓ]

Lo que necesito de ti:
- Diagnostica la causa raíz, no el síntoma. Si los dos intentos anteriores iban por mal camino, dilo con esas palabras.
- Revisa primero si el error viene de configuración o de datos, antes de asumir que es del código.
- Aplica el arreglo directamente en los archivos afectados.
- No agregues librerías nuevas sin avisarme antes.
- Al terminar, déjame un resumen de tres líneas: qué era, qué tocaste y qué debería comprobar yo.

/codex:adversarial-review

Revisa los cambios sin guardar de esta rama con criterio crítico, en este orden:
1. Decisiones de diseño discutibles: ¿había una opción más simple que se descartó sin razón?
2. Casos borde que el código no maneja: entradas vacías, valores nulos, errores de red.
3. Dependencias nuevas que quizá no hacían falta.
4. Nombres y abstracciones que van a envejecer mal.
5. Código repetido que se podría extraer.

Reglas de la revisión:
- No toques ningún archivo. Es solo lectura.
- Devuélveme una lista ordenada por prioridad, con archivo y línea en cada punto.
- En cada punto dime qué pasa si NO se arregla. Si no pasa nada, márcalo como opcional.
- Si algo está bien resuelto, dilo también, en una línea al final.

/codex:rescue

Limpia [NOMBRE DEL MÓDULO O DE LA CARPETA] con estos objetivos, en este orden:
1. [OBJETIVO 1 — por ejemplo: sacar la lógica repetida a un ayudante común]
2. [OBJETIVO 2 — por ejemplo: renombrar lo que se llama confuso]
3. [OBJETIVO 3 — por ejemplo: partir el archivo que se volvió demasiado grande]

Reglas:
- Mantén intacto lo que otros archivos ya usan. No cambies firmas exportadas.
- Si una prueba existente se rompe, detente ahí y repórtalo. No la borres ni la ajustes para que pase.
- No agregues funciones nuevas ni abstracciones por si acaso.
- Deja un resumen de cambios archivo por archivo.

Trabaja en segundo plano. Yo consulto el avance con /codex:status y recojo la salida con /codex:result.

Codex acaba de cerrar un trabajo. Este es el identificador de sesión que me devolvió /codex:result: [PEGA AQUÍ EL IDENTIFICADOR].

Tu turno, en este orden:
1. Lee los archivos que Codex modificó. No los cambies todavía.
2. Escribe pruebas que cubran exactamente los casos que el arreglo acaba de resolver, incluido el que fallaba antes.
3. Actualiza comentarios o documentación solo donde el comportamiento cambió y no se entiende leyendo el código.
4. Si el arreglo deja algo a medias, no lo termines: escríbelo al final en una sección llamada «Pendientes», con una línea por punto.

No repitas trabajo que Codex ya hizo ni rehagas su solución porque tú la habrías escrito distinto. Si de verdad crees que está mal, dilo en «Pendientes» y ahí párate.

Continúa donde nos quedamos. Lo que quedó pendiente:
1. [PUNTO PENDIENTE 1]
2. [PUNTO PENDIENTE 2]

Antes de ejecutar nada:
- Dime en una línea qué vas a tocar primero y por qué.
- Si algo de lo que ya habíamos decidido dejó de aplicar, avísame antes de cambiarlo.
- Si algún punto de la lista ya quedó hecho, dilo y sáltatelo en vez de repetirlo.

Cuando termines, déjame un resumen de tres líneas: qué cerraste, qué quedó abierto y qué debería comprobar yo.

Aquí no hay tabla de ahorro. Hay una sola idea, y es la que sostiene toda la página: cuando delegas a Codex, ese trabajo consume los límites de tu cuenta de ChatGPT, no los de tu cuenta de Claude. Son dos proveedores distintos con dos contadores distintos.

Eso cambia la pregunta. Ya no es cuánto plan te queda, sino cuál de los dos contadores estás gastando en este momento. Decidir y revisar se paga en Claude. Escribir código pesado y correr revisiones se paga en ChatGPT.

Dónde viene Codex incluido

Codex viene con el plan de ChatGPT, no se compra aparte. La columna del medio no cambia en ninguna fila: en todos viene incluido. Lo que cambia es cuánto rinde.

Se escribe en una terminal normal, no dentro de Claude Code. Es lo primero que corres cuando una delegación no responde y quieres saber si el problema está en el plugin o en tu sesión de Codex.

Los precios del producto y todo lo que Codex hace fuera de Claude Code se explican en Master Codex. Aquí lo único que importa es de qué contador sale cada cosa.

No es que cambie tu rutina. Es que cada vez que ibas a quemar tokens de Claude, ahora tienes un lugar donde mandar esa tarea. Este es un día tipo: plan por la mañana, rescates durante el día, revisión que cuestiona antes de guardar los cambios.

1. 1

   Mañana

   Claude arma el plan.

   Le dictas lo que quieres construir y le pides el plan paso a paso con decisiones explicadas. Claude divide el trabajo, marca qué es pensar y qué es ejecutar, y te devuelve los pasos listos para delegar.

2. 2

   Mediodía

   Sale un error, /codex:rescue se encarga.

   El primer error aparece. En vez de pedirle a Claude que lo arregle, pegas el error en /codex:rescue con el contexto mínimo. Codex investiga, aplica el arreglo y te devuelve el resumen. El trabajo pesado no sale de tu plan de Claude.

3. 3

   Tarde

   Trabajo largo en segundo plano.

   Delegas una limpieza grande con /codex:rescue y, dentro del mismo encargo, le pides con palabras que trabaje en segundo plano. Sigues con Claude en otra cosa, consultas el avance con /codex:status y recoges lo que devuelve con /codex:result cuando termine.

4. 4

   Antes de guardar

   /codex:adversarial-review como segundo ojo.

   Antes de cerrar el día, corres /codex:adversarial-review sobre los cambios sin guardar. Codex cuestiona decisiones que Claude defendería. Tú decides qué aceptar y guardas los cambios limpios.