Recurso del reel de @alexsepu_ · Claude Code × Codex · 1 oct 2026

Claude + GPT en 3 líneas

Así tengo a Claude planeando y a GPT haciendo el trabajo pesado, con el plugin oficial de OpenAI para Claude Code. Primero te paso seis prompts para trabajar así y después la instalación, paso por paso.

Instalación3 líneas y después /codex:setup
De quién esDe OpenAI: repo openai/codex-plugin-cc, licencia Apache-2.0
En GitHub33.8k estrellas al 1 oct 2026
NecesitasChatGPT o una llave de la API de OpenAI, y Node.js 18.18 o más nuevo
Dibujo del reel: una tarjeta con el logo de Claude y el nombre Fable 5.1 de Anthropic, un signo de más y otra tarjeta con el logo de OpenAI y el nombre GPT-6 Astra; abajo dice los combiné
Cuadro del reel · Fable 5.1 de Anthropic y GPT-6 Astra de OpenAI

Todo lo de esta guía lo leí en la fuente el 1 de octubre de 2026, con el plugin en su versión 1.0.6. Lo que no pude comprobar te lo digo donde toca.

Los prompts

Seis prompts para que Claude mande y Codex trabaje

Se pegan en Claude Code. Claude planea, parte el trabajo y revisa. Codex hace lo pesado con tu límite de Codex. Qué gasta cada lado está en la letra chica.

1

Instala primero. Las tres líneas del video y después /codex:setup, hasta que diga que Codex está listo. Sin eso ningún prompt corre.

2

Llena lo que está [entre corchetes]. Son pocos y sólo están en CONTEXTO. El del modelo y el de la rama base son opcionales: si no los usas, bórralos completos y Codex usa su modelo. Para dejarlo como en el video, en «Modelo del trabajador» escribe gpt-6-astra, y checa esto antes.

3

Empieza por el 01. El 02 deja la regla fija, y del 03 al 06 usas el que te toque hoy. Varios te dejan una línea lista para copiar, porque hay comandos que sólo puedes escribir tú. La caja de cada prompt se desliza por dentro, y Copiar se lo lleva completo.

01

Mente maestra y trabajador EL DEL VIDEO

Claude arma el plan, parte el trabajo en secciones, le pasa a Codex las pesadas una por una y revisa cada entrega antes de seguir.

CuándoUna tarea grande, que toca varios archivos y se puede partir en piezas que se comprueban por separado. Si Claude la termina rápido solo, no lo uses. En el video la mente maestra es Fable 5.1 (/model fable).

Prompt 01 · mente maestra y trabajador
Eres la mente maestra de este proyecto: planeas, partes el trabajo, decides y revisas. El trabajador es Codex, y le encargas con el subagente codex:codex-rescue (lo mismo que hace /codex:rescue). El plugin de Codex ya está instalado.

CONTEXTO
Tarea: [qué quieres construir o cambiar, en una o dos frases]
Terminado es: [el comando que debe pasar o lo que debe funcionar al final]
No se toca: [archivos, carpetas o comportamientos que deben quedar igual]
Modelo del trabajador: [déjalo vacío y Codex usa el suyo, o escribe un id de modelo, por ejemplo gpt-6-astra]

1 · PLAN (todavía sin delegar)
Lee sólo lo necesario para planear: la estructura del proyecto y los archivos donde se toman las decisiones. No abras completo lo que le vas a encargar a Codex.
Corre git status --short y dime qué archivos ya tenían cambios antes de empezar.
Escribe los criterios de aceptación de la tarea completa: una lista numerada donde cada punto se comprueba con un comando o mirando un archivo concreto.
Parte el trabajo en secciones. Cada sección es una sola tarea que se termina y se comprueba por separado. Si dos pasos comparten casi todo el contexto, van en la misma sección.
Di quién hace cada una. CODEX: lo que obliga a leer muchos archivos, investigar una causa, implementar algo grande y bien delimitado, o correr pruebas con salida larga. TÚ: cambios chicos y puntuales, decisiones de diseño, lo que necesita preguntarme algo y lo que depende de contexto que ya tienes cargado.
Si la tarea completa es algo que terminas rápido, dímelo y hazla tú. No se delega por delegar.
Enséñame el plan en una tabla (sección, quién la hace, archivos, cómo se comprueba, depende de) y espera mi "va".

2 · EL ENCARGO QUE RECIBE CODEX
Codex no ve esta conversación. Cada sección se la escribes completa y corta, en bloques con estas etiquetas:
<task> Qué hacer, en qué archivos o carpeta y cómo se ve terminado. Si existe, el error literal o el comando exacto. Si la sección es sólo investigar, escríbelo así: sólo diagnóstico, sin editar archivos. </task>
<structured_output_contract> Que devuelva sólo esto y en corto: 1. resumen del cambio, 2. archivos tocados, 3. verificación que corrió y su resultado, 4. riesgos o pendientes. Sin logs ni código pegado: rutas y números de línea. </structured_output_contract>
<verification_loop> Que corra la comprobación de la sección antes de dar por terminado y corrija si falla. </verification_loop>
<action_safety> Que se quede dentro de los archivos de la sección, sin refactors ni limpieza fuera de la tarea, y que no toque lo de "No se toca". </action_safety>
Pásale sólo lo que esa sección necesita: rutas, el criterio y las decisiones ya tomadas que la afectan. No le pegues el plan entero.

3 · DELEGA
Con mi "va", una sección por corrida y una corrida a la vez, en el orden del plan. Pídela con --wait. Si Claude Code la manda a segundo plano de todos modos, no avances, no revises y no lances otra corrida hasta que llegue el aviso de que terminó: necesitas el resultado antes de seguir.
Sección nueva: --fresh. Corrección de la misma sección: --resume y sólo lo que cambia, sin repetir el encargo.
Si llené "Modelo del trabajador", agrega --model con ese id. Si lo dejé vacío, no pongas --model. No pongas --effort si no te lo pido.

4 · REVISA CADA ENTREGA
Pásame la respuesta de Codex tal cual. Debajo, tu revisión.
No aceptes el resumen: abre el git diff de los archivos que cambiaron y compáralo contra el criterio de la sección. Lee cambios, no archivos enteros.
Corre tú la comprobación de la sección. De la salida quédate con el resultado y, si falla, las líneas del fallo.
Si cumple, márcala y sigue con la siguiente. Si no cumple, manda una corrección con --resume diciendo qué criterio falló y con qué evidencia. Si después de esa corrección sigue sin cumplir, detente y dime qué está pasando.

ENTREGA
Al cerrar cada sección, una línea: sección, quién la hizo, archivos tocados, comando corrido, resultado.
Al terminar todo: la lista de criterios con CUMPLE, NO CUMPLE o NO COMPROBADO y su evidencia, los archivos cambiados y lo que quedó pendiente.
Al final, la línea que escribo yo para la revisión de cierre: /codex:adversarial-review --background seguida del foco en una frase. Ese comando no lo puedes lanzar tú.

REGLAS
- Codex escribe archivos sin pedirme permiso: nada se delega antes de mi "va" y ningún encargo sale de sus archivos.
- Si Codex falla o deja la sección a medias, pégame el error y detente. No la termines tú por tu cuenta: yo decido. Si falta instalación o sesión, dime que corra /codex:setup.
- No subas el esfuerzo para arreglar un mal resultado: primero aprieta el encargo y el criterio.
- No hagas commit ni push. No prendas el review gate.
- Lo que no comprobaste se dice así: no comprobado.
- Un corchete que siga con su texto de instrucción cuenta como vacío.

Qué te devuelvePrimero el plan en tabla para que le des el "va". Luego, por cada sección, la respuesta de Codex tal cual y debajo la revisión de Claude con el comando que corrió. Al final, la lista de criterios con su evidencia, lo pendiente y la línea de /codex:adversarial-review para que la escribas tú.

02

La regla fija para tu CLAUDE.md

Para no pegar el 01 cada vez. Dejas escrito en el CLAUDE.md del proyecto cuándo sí va con Codex y cuándo no, y Claude lo lee al arrancar cada conversación.

CuándoUna vez por proyecto, después de probar el 01 y ver que te sirve. La regla es corta a propósito: ese archivo se carga en cada sesión.

Prompt 02 · la regla fija para tu claude.md
Vas a dejar escrita en el CLAUDE.md de este proyecto la regla de cuándo le pasas trabajo a Codex y cuándo no. Sólo escribes la regla: ahora no delegues nada ni corras /codex:setup.

CONTEXTO
Nunca se delega: [por ejemplo: migraciones, pagos, llaves y secretos]
Comando para comprobar: [el que corre tus pruebas o tu build]

1 · REVISA
Abre el CLAUDE.md de la raíz del proyecto. Si no existe, dímelo y créalo sólo con esta sección. Si ya trae algo sobre Codex, enséñamelo y pregúntame antes de reemplazarlo: no lo dupliques.

2 · AGREGA ESTA SECCIÓN AL FINAL
Cópiala tal cual. Sólo sustituye lo que está entre llaves con mis datos del CONTEXTO. No le agregues reglas ni la alargues.

INICIO DE LA SECCIÓN
## Codex, el trabajador
- Tú planeas y revisas. Codex ejecuta lo pesado. Le encargas con el subagente codex:codex-rescue.
- Delega cuando: la tarea obliga a leer muchos archivos o a buscar una causa raíz, corre pruebas o builds con salida larga, es una implementación grande y bien delimitada, o llevas varias vueltas en el mismo error.
- No delegues cuando: lo terminas tú rápido, es un cambio chico y puntual, la tarea pide ida y vuelta conmigo, depende de contexto que ya tienes cargado y habría que volver a explicarlo, o toca {nunca se delega}.
- Una tarea por corrida. Cada encargo dice qué hacer, en qué archivos, qué no se toca, cómo se ve terminado y qué devolver: resumen, archivos tocados, verificación y pendientes, en corto.
- Codex escribe archivos sin pedir permiso. Si sólo quiero diagnóstico, pídeselo con esas palabras: sólo diagnóstico, sin editar nada.
- Tarea nueva con --fresh. Corrección de la misma con --resume y sólo lo que cambia. No pongas --model ni --effort si yo no los pedí.
- Antes de dar por bueno lo que devuelva: lee el diff y corre {comando para comprobar}.
- Si Codex falla o deja algo a medias, repórtalo y detente. No lo sustituyas. Si falta instalación o sesión: /codex:setup.
- /codex:review, /codex:adversarial-review, /codex:status, /codex:result, /codex:cancel y /codex:transfer sólo los puedo escribir yo. Cuando toque uno, dame la línea exacta y espera.
- Después de una revisión de Codex no arregles nada hasta que yo elija qué hallazgos corregir.
- No prendas el review gate ni hagas commit o push por tu cuenta.
FIN DE LA SECCIÓN

ENTREGA
A. El diff del CLAUDE.md: sólo debe aparecer la sección nueva.
B. Cuántas líneas tiene ahora el archivo. Si pasa de 200, dime qué partes viejas propones sacar, sin sacarlas.
C. Cómo compruebo que la regla cargó: /context en una conversación nueva.
D. Una frase para probar la regla en esa conversación nueva.

REGLAS
- No cambies nada más del archivo.
- No traduzcas ni reescribas los comandos. Del plugin sólo existen /codex:setup, /codex:review, /codex:adversarial-review, /codex:rescue, /codex:transfer, /codex:status, /codex:result y /codex:cancel.
- Si el proyecto no tiene comando de pruebas, dímelo y deja ese hueco marcado en vez de inventar uno.

Qué te devuelveEl diff con la sección nueva ya con tus datos, el conteo de líneas del archivo, y una frase para probar en una conversación nueva que Claude ya delega solo cuando toca.

03

Antes del commit: que Codex intente tumbar tu cambio

Otro modelo cuestiona el diseño de tu cambio, no sólo el detalle del código. Después Claude comprueba cada hallazgo contra el código en vez de creérselo.

CuándoAntes de un commit delicado: permisos, datos, migraciones, reintentos. La carpeta tiene que ser un repo de Git. Va en dos tiempos porque esta revisión no la puede lanzar Claude: él te arma la línea, tú la corres y le escribes "listo".

Prompt 03 · antes del commit
Vas a preparar una revisión adversarial de Codex sobre mi cambio y después a comprobar lo que encuentre. La revisión la hace Codex con /codex:adversarial-review y la lanzo yo: tú no puedes. No arregles nada.

CONTEXTO
Qué cambié y para qué: [una o dos frases]
Lo que más me preocupa: [por ejemplo: permisos, pérdida de datos, qué pasa si falla a medias, condiciones de carrera]
Rama base: [déjalo vacío si reviso mis cambios sin commit, o escribe la rama contra la que comparo, por ejemplo main]

1 · MIDE EL CAMBIO SIN LEERLO COMPLETO
Si reviso cambios sin commit, corre git status --short --untracked-files=all, git diff --shortstat y git diff --shortstat --cached.
Si llené "Rama base", corre git diff --shortstat con esa rama, tres puntos y HEAD.
Con eso basta para saber cuántos archivos son. La revisión a fondo la hace Codex.
Si no hay nada que revisar o esto no es un repo de Git, dímelo y detente.

2 · DAME LA LÍNEA PARA COPIAR
Escribe el foco en una sola frase, con "Lo que más me preocupa" y con la decisión de diseño más discutible que veas en el cambio. Que cuestione el enfoque y los supuestos, no el estilo.
Dame UNA línea, en este orden: /codex:adversarial-review, luego --wait si el cambio es de uno o dos archivos o --background en cualquier otro caso, luego --base con la rama si llené "Rama base", y al final el foco.
Si va en segundo plano, recuérdame que después escribo /codex:status para ver cómo va y /codex:result para traer el reporte.
Detente ahí. Cuando el reporte esté en la conversación te escribo "listo".

3 · CUANDO TE ESCRIBA "LISTO"
Lee el veredicto (approve o needs-attention) y cada hallazgo con su severidad, archivo y líneas.
Abre sólo el archivo y las líneas que cita cada hallazgo y clasifícalo:
- CONFIRMADO: lo ves en el código. Di qué línea lo demuestra.
- NO REPRODUCE: el código no hace lo que dice el hallazgo. Di por qué.
- FALTA CONTEXTO: no se decide leyendo. Di qué prueba o dato lo resolvería.

ENTREGA (paso 3)
A. El veredicto de Codex, tal cual.
B. Tabla en el orden de severidad en que llegó: hallazgo, severidad, archivo y líneas como las reportó Codex, tu clasificación, evidencia.
C. Tu recomendación en una línea: hacer commit, corregir primero o replantear el enfoque.
D. La pregunta: cuáles hallazgos quiero que se corrijan. Y esperas.

REGLAS
- No toques ningún archivo hasta que yo elija los hallazgos, aunque el arreglo sea obvio.
- No cambies severidades, rutas ni números de línea de lo que reportó Codex. Si no estás de acuerdo con un hallazgo, dilo y di por qué.
- Lo que Codex marcó como suposición se queda como suposición.
- Si el veredicto es approve y no hay hallazgos, dilo así y no inventes pendientes.
- No uses /codex:review para esto: ése no acepta foco.
- No hagas commit.
- Un corchete que siga con su texto de instrucción cuenta como vacío.

Qué te devuelvePrimero una sola línea de /codex:adversarial-review lista para copiar. Después de tu "listo": el veredicto de Codex, la tabla de hallazgos clasificados contra el código y la pregunta de cuáles quieres corregir. Claude no toca nada hasta que contestes.

04

El bug terco: Claude ya dio vueltas

Cortar el ciclo. Claude deja de intentar, arma el expediente del bug y se lo pasa a Codex: primero diagnóstico sin tocar nada, y el arreglo sólo con tu visto bueno.

CuándoUn arreglo ya falló y el siguiente intento sería más de lo mismo. Pégalo en esa misma conversación, para que el expediente salga de lo que ya se intentó. Si prefieres seguir el bug directo en Codex con toda la plática, escribe tú /codex:transfer y te da un codex resume con el id para continuar allá.

Prompt 04 · el bug terco
Llevas varias vueltas con este bug y no sale. Deja de intentar arreglos. Vas a pasárselo a Codex con el subagente codex:codex-rescue (lo mismo que hace /codex:rescue), en dos corridas: primero diagnóstico, después arreglo.

CONTEXTO
El bug: [qué debería pasar y qué pasa]
Cómo se reproduce: [el comando o los pasos exactos]
No se toca: [archivos, pruebas o comportamientos que deben quedar igual]
Modelo del trabajador: [déjalo vacío y Codex usa el suyo, o escribe un id de modelo, por ejemplo gpt-6-astra]

1 · EXPEDIENTE (sin tocar código)
Codex no ve esta conversación. Escríbelo corto, con lo que YA sabemos y sin teorías nuevas:
- Síntoma: el error literal, sólo el mensaje, y el comando que lo produce.
- Dónde: los archivos y funciones implicados, con su ruta.
- Lo que ya se intentó: una línea por intento, con qué cambió y por qué no funcionó.
- Lo descartado: hipótesis que ya probamos falsas y con qué evidencia.
- Lo que todavía no se ha revisado.
- Estado del repo: corre git status --short. Si quedaron cambios de los intentos fallidos, enlístalos y pregúntame si se revierten antes de delegar.
Enséñame el expediente. Si falta el comando para reproducir, pídemelo: sin eso no se delega.

2 · PRIMERA CORRIDA: SÓLO DIAGNÓSTICO
Delega en hilo nuevo (--fresh y --wait) y espera a que termine antes de hacer nada más. Escribe en el encargo, con estas palabras, que es sólo diagnóstico, sin editar ningún archivo. El encargo va así:
<task> Diagnosticar por qué falla el comando, con el expediente completo adentro. Sólo diagnóstico: sin editar ningún archivo. </task>
<compact_output_contract> Que devuelva: 1. causa raíz más probable, 2. evidencia con archivo, línea y salida, 3. el siguiente paso seguro más chico. </compact_output_contract>
<missing_context_gating> Que no adivine: lo que no pueda comprobar lo declara como desconocido. </missing_context_gating>
Si llené "Modelo del trabajador", agrega --model con ese id. Si no, no lo pongas. No pongas --effort si no te lo pido.

3 · ENSÉÑAME Y ESPERA
Pégame el diagnóstico de Codex tal cual. Abre los archivos y líneas que citó y dime en tres líneas si esa causa explica el error literal y si choca con algo de "Lo descartado".
Si Codex llegó a algo que ya habíamos descartado, avísame antes de gastar otra corrida. Espera mi "va".

4 · SEGUNDA CORRIDA: EL ARREGLO
Con mi "va", y sólo cuando la corrida anterior ya terminó, sigue en el mismo hilo (--resume y --wait) y manda sólo la instrucción nueva: aplicar el arreglo más chico y seguro para esa causa, sin refactors ni limpieza de paso, sin tocar lo de "No se toca", correr el comando de "Cómo se reproduce" y devolver resumen, archivos tocados, verificación y riesgos.
Cuando vuelva, lee el diff y corre tú el mismo comando.

ENTREGA
A. El expediente.
B. El diagnóstico de Codex, tal cual, y tu lectura en tres líneas.
C. Después del arreglo: archivos cambiados, el resultado del comando antes y después, y un veredicto en una línea: resuelto, no resuelto o no lo pude comprobar.

REGLAS
- En este prompt tú no arreglas el bug. Si Codex falla o no llega a una causa, pégame el error y detente. Si falta instalación o sesión, dime que corra /codex:setup.
- Una tarea por corrida: primero diagnóstico, luego arreglo. No las juntes.
- Si el arreglo no resuelve, no lances otra corrida sin preguntarme.
- Lo que sea hipótesis sin evidencia se marca como hipótesis.
- No hagas commit.
- Un corchete que siga con su texto de instrucción cuenta como vacío.

Qué te devuelveEl expediente del bug para que lo apruebes, el diagnóstico de Codex tal cual con la lectura de Claude, y después de tu "va" el arreglo con el comando corrido antes y después. Si no quedó, Claude se detiene y te pregunta.

05

Trabajo largo en segundo plano

Dejas a Codex con un trabajo largo sin que Claude se quede esperando ni llenando la conversación de avances, y te quedan las líneas para ver cómo va, traer el resultado o pararlo.

CuándoMigraciones, refactors grandes, investigaciones que van para rato. No cierres la sesión de Claude Code hasta traer el resultado: al cerrarla el plugin corta el trabajo y borra lo guardado de esa sesión. Si el trabajo es enorme, pídele a Claude que lo parta en tramos y lanza uno a la vez.

Prompt 05 · trabajo largo en segundo plano
Vas a dejar a Codex trabajando en segundo plano con el subagente codex:codex-rescue y no te vas a quedar mirando. Mientras Codex trabaja, aquí se habla lo mínimo.

CONTEXTO
El trabajo: [qué tiene que quedar hecho]
Terminado es: [el comando que debe pasar o la comprobación final]
No se toca: [carpetas, archivos o comportamientos fuera de alcance]
Modelo del trabajador: [déjalo vacío y Codex usa el suyo, o escribe un id de modelo, por ejemplo gpt-6-astra]

1 · ANTES DE LANZAR
Corre git status --short y dime qué cambios hay sin commit. Si hay, pregúntame si los guardo antes: después no vamos a poder separar lo que hizo Codex de lo que ya estaba.
Confirma que es UN solo trabajo. Si son varios que no tienen que ver, o es tan grande que conviene partirlo en tramos que se comprueban por separado, dímelo y lanzamos sólo el primero.

2 · EL ENCARGO
Escríbelo corto y completo: Codex no ve esta conversación y nadie le va a contestar dudas a medio camino.
<task> Qué hacer, en qué archivos o carpetas y cómo se ve terminado. </task>
<structured_output_contract> Que devuelva en corto: 1. resumen, 2. archivos tocados, 3. verificación corrida y su resultado, 4. riesgos o pendientes. Sin logs ni código pegado. </structured_output_contract>
<default_follow_through_policy> Que tome la interpretación razonable de menor riesgo y siga sin preguntar. </default_follow_through_policy>
<verification_loop> Que corra el comando de "Terminado es" antes de terminar. </verification_loop>
<action_safety> Que no salga del alcance ni toque lo de "No se toca". Si una acción es riesgosa o irreversible, que no la haga y la deje anotada en pendientes. </action_safety>
Enséñame el encargo y espera mi "va".

3 · LÁNZALO
Con mi "va", delega en segundo plano y en hilo nuevo (--background y --fresh). Si llené "Modelo del trabajador", agrega --model con ese id. Si no, no lo pongas.

4 · HOJA DE SEGUIMIENTO
En cuanto arranque, dame esto y nada más:
- Las líneas que escribo yo, porque tú no puedes lanzarlas: /codex:status para ver la tabla de trabajos y sacar el id. /codex:status con el id y --wait al final para esperar a que termine ése (la espera tiene tope, así que puede volver con el trabajo todavía corriendo). /codex:result con el id para traer el reporte final. /codex:cancel con el id para detenerlo.
- Dos avisos: que no cierre esta sesión hasta traer el resultado, porque al cerrarla se corta el trabajo y se borra lo guardado. Y que cancelar no deshace lo que Codex ya haya editado.

5 · MIENTRAS CORRE
No me mandes avances ni revises el repo por tu cuenta. No edites los archivos que Codex está trabajando ni lances otra corrida de Codex. Si te pido otra cosa mientras tanto, que sea en archivos distintos.

6 · CUANDO EL RESULTADO ESTÉ EN LA CONVERSACIÓN
No lo repitas ni lo resumas encima. Dime sólo que ya está y que toca verificarlo con el prompt 06 antes de aceptarlo.

REGLAS
- No prendas el review gate para vigilar el trabajo.
- Si Codex no está listo, alto: dime que corra /codex:setup.
- Si el trabajo falla o lo cancelo, no lo termines tú: dime en qué quedó y qué archivos alcanzó a tocar con git status --short.
- No hagas commit.
- Un corchete que siga con su texto de instrucción cuenta como vacío.

Qué te devuelveEl encargo para que le des el "va", la confirmación de que arrancó y una hoja con las cuatro líneas de seguimiento y los dos avisos. El id del trabajo lo sacas tú de /codex:status. Cuando el resultado llega, Claude no lo repite: te manda al 06.

06

El cierre: nada se acepta sin comprobarlo

Claude comprueba el trabajo de Codex contra el código y los comandos, no contra lo que Codex dice que hizo. Sales con un veredicto: aceptar, corregir o descartar.

CuándoCada vez que Codex termina algo que escribió archivos, y siempre antes de un commit. Va justo después del 01, el 04 o el 05, en la misma sesión.

Prompt 06 · el cierre
Codex ya entregó trabajo en este proyecto. No lo des por bueno: compruébalo contra el código y los comandos, no contra su resumen. Lee cambios, no archivos enteros.

CONTEXTO
Lo que se le pidió: [la tarea, o "la última que delegaste"]
Terminado era: [el comando que debía pasar o lo que debía funcionar]
No se debía tocar: [carpetas, archivos o comportamientos]

1 · JUNTA LA EVIDENCIA
Si el resultado de Codex no está en esta conversación, pídeme que escriba /codex:result (ese comando lo lanzo yo) y espera.
Corre git status --short y git diff de los archivos que cambiaron. Enlista cada archivo tocado, creado o borrado.
Si no hay repo de Git, dímelo: sin diff no puedes comprobar qué cambió y la revisión queda parcial.

2 · COMPARA
a. Los archivos que Codex dijo que tocó contra los que aparecen en el diff. Marca lo que sobra y lo que falta.
b. Los criterios de lo que se pidió, uno por línea. Si ya existían en el plan, usa ésos y no unos nuevos. Sin evidencia en el diff o en la salida de un comando no hay CUMPLE.
c. Lo de "No se debía tocar": confirma que quedó igual.
d. Cambios que nadie pidió: refactors, renombres, archivos nuevos o dependencias nuevas.
e. Trampas: código a medias, pruebas borradas o saltadas para que pase, y valores fijos que simulan el resultado.
f. Lo que Codex marcó como suposición, duda o pendiente se queda con esa etiqueta. No lo conviertas en hecho.

3 · VERIFICACIÓN PROPIA
Corre tú el comando de "Terminado era". Pega sólo el resultado y, si falla, las líneas del fallo. Que Codex diga que lo corrió no cuenta.

4 · VEREDICTO
ACEPTAR: todos los criterios cumplen, la verificación pasa y no hay cambios fuera del alcance.
CORREGIR: falta algo concreto. Di si es un ajuste chico que harías tú o algo que conviene devolverle a Codex. Para lo segundo, redacta la corrección para mandarla con --resume: sólo qué criterio falló y la evidencia, sin repetir la tarea. No la mandes ni ajustes nada hasta que te diga "va". Ojo: --resume retoma la última corrida de Codex terminada en esta sesión. Si después de este trabajo hubo otra corrida, dímelo y manda la corrección como tarea nueva con --fresh y el contexto completo.
DESCARTAR: el enfoque no sirve. Dime qué archivos habría que revertir. No reviertas nada tú.

ENTREGA
A. Tabla de criterios: criterio, CUMPLE / NO CUMPLE / NO COMPROBADO, evidencia (archivo y línea, o resultado del comando).
B. Archivos cambiados: dentro o fuera del alcance.
C. Resultado del comando de verificación.
D. Veredicto en una línea y el siguiente paso.
E. Por si quiero una segunda opinión de Codex sobre estos cambios, la línea que escribo yo: /codex:review o /codex:adversarial-review, con --wait si son uno o dos archivos y --background en lo demás.

REGLAS
- No arregles ni reviertas nada sin que yo lo diga.
- Si Codex dejó el trabajo incompleto o falló, no lo termines por tu cuenta: repórtalo.
- No resumas ni suavices los errores: pégalos como salieron.
- Lo que no pudiste comprobar va como NO COMPROBADO, nunca como CUMPLE.
- No hagas commit, aunque el veredicto sea ACEPTAR.

Qué te devuelveUna tabla de criterios con su evidencia, la lista de archivos dentro y fuera del alcance, el resultado del comando que corrió Claude y un veredicto en una línea. Si toca corregir, la corrección ya redactada y esperando tu "va".

Dibujo del reel: unas hojas que dicen prompt junto a una gráfica que sube, con el rótulo mejores resultados
Cuadro del reel · a mí me dio mejores resultados. Es mi experiencia, no una prueba medida

Lo que viste en el video

Claude es la mente maestra. GPT es el trabajador

El plugin se llama Codex plugin for Claude Code y es de OpenAI. Su README lo dice en una línea: «Use Codex from inside Claude Code for code reviews or to delegate tasks to Codex.» Tú sigues hablando con Claude. Cuando toca algo pesado, Claude se lo pasa a Codex, que es el agente de programación de OpenAI, y te regresa su respuesta.

Claude1 · La mente maestraClaude Code

Tu sesión de siempre, con el modelo que tengas puesto. Yo uso Fable 5.1. Planea, decide y revisa.

→
Claude2 · El mensajerocodex:codex-rescue

El subagente que instala el plugin. Corre en Sonnet y sólo reenvía la tarea: una llamada y ya.

→
3 · El trabajadorCodex

El Codex CLI de tu propia máquina, con tu cuenta de OpenAI. Lee, investiga, edita y contesta.

No corre nada en la nube aparte. El README lo aclara: el plugin usa el mismo Codex que tendrías instalado, la misma sesión y la misma carpeta de tu proyecto.

Dibujo del reel: el logo de Claude con una corona y el rótulo mente maestra le pasa el plan con una flecha al logo de OpenAI con casco de obra y el rótulo trabajador; abajo, un muro de ladrillos a medio levantar
Cuadro del reel · corona para el que planea, casco para el que construye

Por qué se te acaban los tokens

Claude Code manda la conversación completa en cada mensaje. Entre más archivos lee y más pruebas corre, más pesa todo lo que sigue. Lo dice su documentación de costos: «Token costs scale with context size: the more context Claude processes, the more tokens you use.» Y cuando se acaba, sale este mensaje:

Mensaje real de Claude Code · code.claude.com/docs/en/errors
You've hit your session limit · resets 3:45pm
You've hit your weekly limit · resets Mon 12:00am

La misma página avisa que el límite de sesión y el semanal se comparten entre todos los modelos: cambiar de modelo dentro de Claude no te regresa el acceso. Por eso tiene sentido sacar el trabajo pesado a otra cuenta.

Dibujo del reel: una terminal con el logo de Claude, una batería de tokens vacía con un signo de admiración y debajo el mensaje You've hit your session limit, resets 3:45pm
Cuadro del reel · la batería de tokens vacía y el mensaje del límite

Seccionar el trabajo no lo inventé yo

Anthropic describe este patrón en su artículo Building effective agents, del 19 de diciembre de 2024. Lo llama «orchestrator-workers»:

«In the orchestrator-workers workflow, a central LLM dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes their results.»

Anthropic · Building effective agents · 19 dic 2024

O sea: un modelo central parte la tarea, se la reparte a modelos trabajadores y junta los resultados. En el mismo artículo aparece la palabra que uso en el video: «Sectioning: Breaking a task into independent subtasks run in parallel.»

Dibujo del reel: una batería de tokens llena, el trabajo cortado en tres bloques numerados y un recorte del artículo de Anthropic con el título Workflow: Orchestrator-workers
Cuadro del reel · el trabajo en 1, 2 y 3, con el recorte del artículo de Anthropic

El matiz, porque también está en la fuente. El artículo habla de modelos trabajadores en general: no menciona a Codex ni mezclar modelos de dos empresas. Eso es idea mía. Y el mismo texto pide empezar por «the simplest solution possible» y subir la complejidad sólo cuando haga falta. Dividir sirve cuando la tarea es grande y las piezas se pueden comprobar por separado. No es regla para todo. Y ojo: en el artículo «sectioning» es parte de otro patrón, el de paralelización, y habla de subtareas independientes que corren al mismo tiempo. Aquí las secciones van una por una. Lo que más se parece a lo que hago es orchestrator-workers.

Paso a paso

Instálalo: tres líneas y un cuarto paso

Las tres líneas salen de la sección «Install» del README oficial, tal cual. Se escriben en Claude Code, en la terminal, una por una. Son comandos de la app, no un prompt.

Dibujo del reel: la página del repo de GitHub en la sección Install con los tres comandos encerrados en azul, y debajo las tres líneas numeradas: /plugin marketplace add openai/codex-plugin-cc, /plugin install codex@openai-codex y /reload-plugins
Cuadro del reel · las tres líneas sobre la página real del repo

Antes de empezar

Sección Requirements del README: ChatGPT subscription (incl. Free) or OpenAI API key; Usage will contribute to your Codex usage limits; Node.js 18.18 or later
Captura real · README de openai/codex-plugin-cc · sección Requirements · 1 oct 2026
Encabezado del repo en GitHub: openai / codex-plugin-cc, público Botones del repo en GitHub: Notifications, Fork 2.4k y Star 33.8k
Captura real · github.com/openai/codex-plugin-cc · 1 oct 2026

El repo vive en la cuenta openai de GitHub y el archivo del plugin trae como autor a OpenAI. Por eso en el video digo «tranquilo».

  • Claude Code, en una sesión normal de terminal. Ahí es donde corren los comandos /plugin.
  • Una cuenta de OpenAI. El README pide «ChatGPT subscription (incl. Free) or OpenAI API key». Sobre el plan gratis hay letra chica.
  • Node.js 18.18 o más nuevo.
  • Codex CLI. Si no lo tienes, el cuarto paso te ofrece instalarlo.
  • Git, si vas a usar las revisiones: esos dos comandos sólo corren dentro de un repositorio.

Los pasos

Sección Install del README: Add the marketplace in Claude Code, /plugin marketplace add openai/codex-plugin-cc; Install the plugin, /plugin install codex@openai-codex; Reload plugins, /reload-plugins; Then run, /codex:setup
Captura real · README · sección Install · 1 oct 2026
  1. Registra el marketplace de OpenAI

    LÍNEA 1/plugin marketplace add openai/codex-plugin-cc

    Claude Code necesita conocer el catálogo antes de instalar algo de él. Según su documentación, cuando sale bien imprime Successfully added marketplace: y el nombre. Este catálogo se llama openai-codex: por eso la siguiente línea termina así.

  2. Instala el plugin

    LÍNEA 2/plugin install codex@openai-codex

    Ojo, esto el README no lo cuenta: dentro de una sesión, esta línea no instala de inmediato. La documentación de Claude Code dice que abre el panel del plugin para que lo revises y elijas dónde queda. Las tres opciones, tal cual:

    1. Install for you (user scope): lo tienes en todos tus proyectos de esta máquina. Es la que yo elegiría para uso personal.
    2. Install for all collaborators on this repository (project scope): queda prendido para todos los que trabajan en ese repo.
    3. Install for you, in this repo only (local scope): sólo tú y sólo en ese repo.

    El panel puede enseñarte qué va a instalar. Como este catálogo no es el de Anthropic, la doc avisa que en su lugar puede salir Components will be discovered at installation. Por eso te lo digo yo: trae 8 comandos, 1 subagente, 3 skills internas (no las invocas tú) y 3 hooks.

  3. Recarga los plugins

    LÍNEA 3/reload-plugins

    Aplica lo que instalaste sin reiniciar la sesión. Según la documentación imprime un conteo que empieza con Reloaded:. En un Claude Code reciente el panel a veces ya te dice Plugin is now active. y esta línea queda de más. Córrela igual: es la que pide el README y no estorba.

  4. El cuarto paso: revisa que Codex esté listo

    DESPUÉS/codex:setup

    En el video no cabía, pero el README lo pide justo después de las tres líneas. Te dice si Codex está instalado y con sesión iniciada.

    1. Si falta Codex y tienes npm, Claude te pregunta si lo instala. Las opciones son «Install Codex (Recommended)» y «Skip for now». Si prefieres hacerlo tú: npm install -g @openai/codex.
    2. Si falta iniciar sesión, corre !codex login. El signo ! es el modo shell de Claude Code: corre el comando directo, sin pasar por Claude.
    3. Si ya usabas Codex en esta máquina, el README dice que esa misma cuenta debería funcionar de inmediato.
    README después de /codex:setup: will tell you whether Codex is ready; npm install -g @openai/codex; !codex login; After install, you should see the slash commands listed below and the codex:codex-rescue subagent in /agents; One simple first run is /codex:review --background, /codex:status, /codex:result
    Captura real · README · lo que sigue de /codex:setup · 1 oct 2026
  5. Comprueba que quedó

    El README dice qué deberías ver después de instalar: los comandos /codex: y el subagente codex:codex-rescue dentro de /agents. Y propone esta primera corrida, dentro de un repo de Git:

    Primera corrida · del README
    /codex:review --background
    /codex:status
    /codex:result

¿Usas la app de escritorio o VS Code? Ahí las líneas /plugin no aplican y se hace por menús. Según la documentación de Claude Code: en VS Code, escribe /plugins para abrir Manage plugins y agrega el catálogo en la pestaña Marketplaces. En la app de escritorio, el botón + junto a la caja de texto, luego Plugins y Add plugin, pero ese menú sólo enseña los catálogos que ya agregaste, y no comprobé cómo se agrega uno desde ahí. Lo seguro es correr las tres líneas una vez en la terminal: lo que instalas para tu usuario aparece también en la app y en VS Code de esa misma computadora.

Lo que instala

Los ocho comandos, uno por uno

Son exactamente ocho comandos y un subagente, más tres skills internas que usa el propio plugin. Si ves por ahí un /codex:ask o un /codex:run, no existen. Dos cosas que conviene saber antes: sólo rescue y setup los puede lanzar Claude por su cuenta, los otros seis los escribes tú. Y sólo rescue toca tus archivos.

/codex:rescue

Escribe archivosTambién lo lanza Claude

El trabajador. Le pasa una tarea a Codex: investigar un bug, intentar un arreglo o seguir algo que Codex ya empezó. Por defecto Codex edita dentro de tu proyecto sin pedirte permiso. Si sólo quieres diagnóstico, díselo con palabras.

Acepta --background, --wait, --resume, --fresh, --model y --effort. Si no pones --resume ni --fresh, puede preguntarte si continúa el hilo anterior.

/codex:rescue investigate why the tests started failing

/codex:review

Sólo leeLo escribes tú

Una revisión normal de tu trabajo actual: tus cambios sin commit o tu rama contra otra con --base. No acepta instrucciones de en qué fijarse. El README recomienda correrla en segundo plano.

/codex:review --base main

/codex:adversarial-review

Sólo leeLo escribes tú

La revisión que cuestiona el diseño, no sólo el detalle. A ésta sí le dices en qué fijarse, después de los flags. Regresa un veredicto, approve o needs-attention, y los hallazgos por severidad.

/codex:adversarial-review --background look for race conditions and question the chosen approach

/codex:status

Sólo leeLo escribes tú

La lista de trabajos de Codex en curso y recientes de este repo. Con el id de uno te da su detalle. Úsalo para ver cómo va algo que dejaste en segundo plano. Con el id y --wait espera a que termine (eso viene en el archivo del comando, no en el README).

/codex:status task-abc123

/codex:result

Sólo leeLo escribes tú

Trae la respuesta final de un trabajo que ya terminó. Cuando hay, incluye el id de la sesión de Codex para reabrirla allá con codex resume.

/codex:result task-abc123

/codex:cancel

No toca el repoLo escribes tú

Detiene un trabajo que sigue corriendo en segundo plano. Ojo: lo detiene, pero en el código del plugin no hay nada que deshaga lo que Codex ya editó.

/codex:cancel task-abc123

/codex:transfer

No toca el repoLo escribes tú

Convierte tu conversación actual de Claude Code en un hilo de Codex y te imprime un codex resume con su id, para seguirla directo allá con todo el contexto. Si no encuentra la conversación, acepta --source con la ruta del .jsonl. El README avisa que un Codex viejo hay que actualizarlo.

/codex:transfer

/codex:setup

No toca el repoTambién lo lanza Claude

Revisa que Codex esté instalado y con sesión. También prende y apaga el «review gate», que viene apagado y tiene su advertencia.

/codex:setup

También se lo puedes pedir hablando

El README da un ejemplo: «Ask Codex to redesign the database connection to be more resilient.» Y el subagente tiene instrucción de ofrecerse solo cuando Claude está atorado o la tarea es grande.

Lo que regresa es de Codex, tal cual

Con /codex:rescue, Claude te entrega la respuesta de Codex sin resumirla. Y si Codex falla, Claude tiene instrucción de reportarlo y detenerse, no de terminar el trabajo él.

Después de una revisión, Claude no arregla solo

El plugin se lo prohíbe: primero te pregunta cuáles hallazgos quieres corregir. Ningún comando de revisión cambia código.

Sigue el trabajo en Codex cuando quieras

Lo delegado se puede retomar dentro de Codex con codex resume y el id que te dan /codex:result o /codex:status.

Sección /codex:rescue del README: Hands a task to Codex through the codex:codex-rescue subagent, los flags que soporta, los ejemplos y las notas
Captura real · README · /codex:rescue · 1 oct 2026. Dos de sus ejemplos usan modelos ya retirados: no los copies
Sección /codex:review del README: Runs a normal Codex review on your current work, con la nota de correrla en segundo plano, los ejemplos y la frase This command is read-only
Captura real · README · /codex:review · 1 oct 2026

El modelo del trabajador

Pon a GPT-6 Astra de trabajador

Esto es lo que no cabía en 30 segundos: el plugin no fija el modelo. En sus archivos no aparece Astra ni una vez. El README lo dice así: «if you do not pass --model or --effort, Codex chooses its own defaults.» Si quieres Astra, hay que pedirlo.

Icono oficial de GPT-6 Astra

El identificador que da OpenAI es gpt-6-astra. El flag --model es del plugin y sólo está documentado en /codex:rescue.

Por tarea · en Claude Code
/codex:rescue --model gpt-6-astra [lo que quieres que haga]
Fijo para todo (sólo si lo quieres siempre) · en ~/.codex/config.toml
model = "gpt-6-astra"
model_reasoning_effort = "low"

También se lo puedes pedir a Claude con palabras, por ejemplo «pásale esto a Codex con el modelo gpt-6-astra». El subagente tiene instrucción de pasar el nombre con --model. En los prompts 01, 04 y 05 es el campo «Modelo del trabajador».

Ojo con estas dos líneas. El flag --model y las claves model y model_reasoning_effort están literales en el README. El identificador gpt-6-astra está literal en la documentación de OpenAI. La combinación exacta no viene escrita en ninguna de las dos, así que no te la doy por comprobada. Tampoco está comprobado que tu cuenta tenga Astra en el Codex CLI: la doc dice que depende del despliegue, de cómo inicias sesión y de la app que uses. Lo ves con /model dentro de Codex, que sólo enseña lo que tu cuenta tiene. Si Codex no acepta el modelo, quita --model o borra la línea model de tu config.toml y Codex vuelve a elegir el suyo.

SI NO DICES NADA

Codex elige

Usa el model de tu config.toml y, si no hay, «a recommended model». Hoy la documentación de Codex recomienda GPT-6.1 Sol para trabajo complejo.

EL CONFIG

Dos lugares

~/.codex/config.toml es el tuyo. .codex/config.toml en la raíz del proyecto le gana, pero sólo se carga si marcaste el proyecto como confiable.

EL ESFUERZO

Empieza bajo

OpenAI sugiere arrancar Astra en Light, que en el config es low. El flag --effort del plugin sólo acepta none, minimal, low, medium, high y xhigh.

Astra se gasta rápido: guárdalo para lo difícil

Ésta es la tabla de la página de precios de Codex: mensajes locales estimados por cada ventana de cinco horas en el plan Plus. OpenAI aclara que son estimados, no topes fijos, y que también puede haber límites semanales.

ModeloMensajes por 5 horas (Plus)Para qué lo propone OpenAI
GPT-6 Astra5-45«Keep Astra for your most demanding work.»
GPT-6.1 Sol15-160El recomendado para trabajo complejo y repetido.
GPT-6 Sol15-150La página no dice para qué.
GPT-6 Luna350-3,000Tareas claras y repetibles.

Fuente: learn.chatgpt.com/docs/pricing y learn.chatgpt.com/docs/models, consultadas el 1 de octubre de 2026. La página de precios no trae fecha de actualización. Mi lectura: Astra para la sección difícil y Sol o Luna para lo demás. Por eso en los prompts el modelo es opcional. Ojo: la misma página se contradice. La tabla trae fila de Astra para Plus, pero la tarjeta del plan Plus sólo lista GPT-6 Sol y GPT-6 Luna. Leí las dos y no comprobé cuál manda. Antes de fijarlo, abre Codex y checa /model.

La letra chica

Lo que en el video no cabía

Los tokens

Lo delegado gasta de tu límite de Codex

No desaparece, se cobra en otra cuenta. El README: «Usage will contribute to your Codex usage limits.» Ese límite se comparte con ChatGPT Work. Y si entras con una llave de la API, se cobra a tarifa de API.

Del lado de Claude

Claude sigue gastando en tres puntos

Tu sesión principal, que decide y arma el encargo. El subagente mensajero, que corre en Sonnet. Y la respuesta de Codex, que regresa completa a la conversación. Cuánto es cada parte no está medido: /usage te lo desglosa por plugin y subagente.

Sin cifras

Nadie promete un porcentaje de ahorro

El README no habla de ahorro y no trae cifras ni pruebas medidas. Lo de «salvar tokens» y «mejores resultados» es lo que me ha pasado a mí. Te ahorras que Claude lea medio proyecto y corra las pruebas. En una tarea chica, delegar sale más caro que hacerla.

Tu plan de ChatGPT

El gratis no está claro

El README dice «ChatGPT subscription (incl. Free)». Pero la página de precios de Codex, consultada el 1 de octubre de 2026, pone el Codex CLI de Plus para arriba, y a Free y Go sólo les da GPT-6 Luna en la app de escritorio. Leí las dos. No comprobé cuál manda hoy.

Ejemplos viejos

No copies los modelos del README

Trae ejemplos con --model gpt-5.4-mini y --model spark. Según la documentación de Codex, el primero se retiró el 31 de agosto de 2026 para cuentas de ChatGPT y el segundo el 14 de septiembre de 2026. El config.toml de ejemplo trae el mismo modelo retirado.

Review gate

Déjalo apagado si no vas a estar viendo

Es opcional y viene apagado. Se prende con /codex:setup --enable-review-gate, se apaga con /codex:setup --disable-review-gate y hace que Codex revise lo que Claude acaba de hacer antes de dejarlo terminar. La advertencia del README: «may drain usage limits quickly. Only enable it when you plan to actively monitor the session.»

Sobre Fable 5.1: se elige con /model fable, no es el modelo por defecto en ningún plan, pide Claude Code v2.1.257 o posterior y, según tu plan, puede cobrarse con créditos de uso. El plugin no lo exige: funciona con el modelo que tengas en la sesión.

El criterio

Cuándo delegar y cuándo no

Instalar es lo fácil. Lo difícil es saber qué mandar. Es la misma regla que el prompt 02 deja escrita en tu CLAUDE.md, y sale de las instrucciones del propio subagente y de la documentación de Claude Code sobre subagentes.

Mándaselo a Codex

Sí conviene

  • Claude ya dio varias vueltas con el mismo error, o hay que buscar una causa raíz leyendo muchos archivos.
  • Es una implementación grande y bien delimitada, que se puede comprobar con un comando.
  • Quieres una segunda opinión de otro modelo antes de un commit delicado.
Que lo haga Claude

Mejor no

  • Claude lo termina rápido solo. El plugin lo dice: «Do not grab simple asks that the main Claude thread can finish quickly on its own.»
  • La tarea pide mucha ida y vuelta contigo, o depende de contexto que Claude ya tiene cargado: Codex no ve tu conversación.
  • Son varias cosas que no tienen que ver. La guía interna del plugin pide una tarea por corrida.

Si algo falla

Los atorones, con su salida

Estos errores no salieron de mi pantalla, así que no te voy a inventar ninguno. Son los que el README, el código del plugin o la documentación traen escritos.

Lo que pasaQué hacer
Instalaste y no aparecen los comandos /codex:Corre /reload-plugins. Después revisa en /agents que esté codex:codex-rescue.
Claude Code dice que /plugin no está disponibleEsos comandos sólo corren en una sesión interactiva de terminal. En la app de escritorio y en VS Code se instala por menús.
/codex:setup dice que falta CodexAcepta «Install Codex (Recommended)» o instálalo tú con npm install -g @openai/codex, y corre /codex:setup otra vez.
/codex:setup dice que falta iniciar sesiónCorre !codex login. Si el navegador no abre, el plugin sugiere !codex login --device-auth o !codex login --with-api-key.
Tu Node es viejoEl plugin pide Node.js 18.18 o más nuevo. Actualízalo y repite el /codex:setup.
«This command must run inside a Git repository.»Las dos revisiones sólo corren dentro de un repo de Git. /codex:rescue no lo exige.
«Unsupported reasoning effort»Le pusiste a --effort un valor que el plugin no acepta. La lista termina en xhigh.
Se te acabó el límite de CodexDentro del Codex CLI, /status te dice cuánto te queda, y el tablero está en chatgpt.com/codex/settings/usage. La página de precios dice que en Plus y Pro puedes comprar créditos, o seguir con una llave de la API a tarifa de API.
Cerraste Claude Code y el trabajo de Codex ya no estáAsí funciona el plugin, aunque el README no lo diga: al cerrar la sesión corta los trabajos en segundo plano de esa sesión y los quita de la lista. Trae el resultado con /codex:result antes de cerrar.

Fuentes y método

De dónde sale cada dato

Todo lo consulté el 1 de octubre de 2026. Los modelos, planes y límites cambian seguido: si algo no coincide, manda lo que diga la página oficial. Los enlaces del README apuntan a developers.openai.com, que hoy redirige a learn.chatgpt.com.

Cómo se hizo esta guía. Las capturas del README y del encabezado del repo son de la página oficial de GitHub, tomadas sin sesión el 1 de octubre de 2026 y recortadas a la sección, sin retoque. Los dibujos son cuadros del reel: el marco, la cinta y los trazos son diseño mío. Los logos y el icono de Astra son los oficiales de cada marca. Los mensajes de cada paso no son de una corrida mía: salen de leer el README, los archivos del plugin y la documentación. Lo que viene del código y no del README va dicho así, y lo que es deducción mía también. Sotai no está afiliada a OpenAI ni a Anthropic.

Claude piensa, GPT trabaja y tú revisas

Instálalo hoy, corre el prompt 01 con una tarea grande de verdad y cierra con el 06 antes del commit. Si te sirve, deja la regla fija con el 02 y ya no lo vuelves a pegar.

Dibujo del reel: el logo de Claude y el de OpenAI conectados por un cable, el rótulo al máximo, una batería de tokens llena y una gráfica que sube con el rótulo mejores resultados
Cuadro del reel · conectados, y a sacarle el máximo
SOTAI
Alex Sepúlveda · 1 de octubre de 2026