Claude Code vs Codex: compáralos con el mismo bug de tu repo
En la práctica/ 19 min de lectura
Un método para comparar Claude Code y Codex en tu propio repo: misma base, misma instrucción y cuatro métricas, repetido con tres bugs antes de decidir.
- IA
- Claude Code
- Git
- QA
En este artículo (9)
Para comparar Claude Code vs Codex con datos tuyos, dales el mismo bug de tu propio repo: dos ramas creadas desde el mismo commit, la misma instrucción guardada en un archivo y cuatro métricas medidas igual para los dos: tiempo, tamaño del diff, tests sin tocar y costo. Repite con tres bugs distintos antes de decidir.
Esto es un método, no un benchmark: no publicamos resultados ni elegimos ganador. Aquí tienes los comandos de las dos herramientas, revisados contra su documentación oficial el 11 de noviembre de 2026, y dos scripts que probamos en un repo de práctica con commits hechos a mano. No ejecutamos ninguno de los dos agentes.
Por qué comparar con tu propio código
Las comparaciones que circulan usan repos, lenguajes y tareas que no son los tuyos. A ti te importa otra cosa: si el agente entiende tu estructura, respeta tus convenciones, corre tu suite y arregla los bugs que de verdad te llegan. Eso solo se mide en tu repo.
Además, lo que comparas cambia seguido. Las dos CLI sacan versiones con frecuencia y cada una puede trabajar con distintos modelos, así que en realidad comparas herramienta más modelo. Anota qué modelo usó cada una (Claude Code lo fija con --model, según su referencia de CLI; Codex con -m, según la suya) y la versión de cada CLI. Con scripts, repetir la prueba cuando algo cambie es volver a correr los mismos comandos.
Para que la comparación sea justa, fija tres cosas:
- El mismo punto de partida. El mismo commit, las mismas dependencias y el mismo test que falla.
- La misma instrucción. Un archivo de texto que reciben las dos, sin ayudas extra para ninguna.
- Las mismas mediciones. Los mismos comandos y el mismo reloj para las dos, y nada de intervenir a mitad de una corrida.
Desliza la figura para verla completa
Preparar dos ramas iguales
Empieza con un bug que puedas reproducir con un test. Escribe el test que falla, confírmalo en una rama base y crea desde ella dos worktrees, uno por agente. Un worktree de git es otra carpeta con su propia rama que comparte el historial del repo: cada agente edita su copia sin pisar la otra. En el ejemplo, una tienda cobra envío con un subtotal de exactamente $999 MXN, aunque el envío es gratis desde $999; el test nuevo afirma assert.equal(shippingCost(999), 0).
git switch -c cmp/base-1
# agrega a test/shipping.test.js el test que reproduce el bug, y luego:
git add test/shipping.test.js
git commit -m "test: free shipping from exactly 999 (fails)"
npm test # tiene que fallar, y por este motivo
mkdir -p ../cmp/runs
git worktree add ../cmp/claude -b cmp/claude-1 cmp/base-1
git worktree add ../cmp/codex -b cmp/codex-1 cmp/base-1
(cd ../cmp/claude && npm ci) && (cd ../cmp/codex && npm ci)
git switch -c cmp/base-1crea la rama base desde donde estás. Empieza con el árbol de trabajo limpio.- El commit guarda el test que falla: es la especificación del arreglo y lo que después revisa la métrica de tests.
npm testtiene que fallar en la base, y por el bug. Si falla por otra cosa, ningún agente puede pasar esa prueba.../cmp/runsguarda la salida de cada corrida fuera de los worktrees, para que no entre en el diff.- Cada
git worktree addcrea una carpeta y una rama nueva desdecmp/base-1: el mismo commit para los dos. npm ciinstala las mismas dependencias en cada carpeta, porque un worktree nuevo solo trae los archivos versionados. Usa el comando de instalación de tu proyecto.
Cada herramienta tiene su propia opción de worktree, pero no parten del mismo lugar. Según la documentación de worktrees de Claude Code, claude --worktree parte por defecto de la rama principal del remoto, no de tu HEAD local. La referencia de comandos de Codex describe codex exec --worktree como un worktree administrado, y su página de worktrees, escrita para la app de escritorio, dice que parte del HEAD de la rama elegida y le aplica los cambios sin confirmar. Para controlar el commit exacto, crea los worktrees tú con git.
Git es también el botón de deshacer común a las dos: cada corrida vive en su rama y la descartas con git worktree remove. Dentro de una sesión interactiva, Claude Code tiene además sus puntos de control con /rewind, pero en esta prueba no hacen falta. Si quieres repasar la rutina de ramas y commits, está en git para trabajar con agentes de IA.
La misma instrucción para Claude Code y Codex
Guarda la instrucción en ../cmp/prompt.md y pásasela igual a las dos. Describe el bug como se lo describirías a una persona (cómo hacerlo está en cómo reportarle un bug a la IA) y agrega las reglas que vas a medir:
Bug: con un subtotal de exactamente $999 MXN la tienda cobra envío.
El envío es gratis desde $999. Lo reproduce el test
"ships free from exactly $999" en test/shipping.test.js.
Arregla el código para que npm test pase.
No modifiques, borres ni saltes archivos de test/: son la especificación.
No hagas commit: deja los cambios en el árbol de trabajo.
Al terminar, resume en tres líneas qué cambiaste y por qué.
- Las tres primeras líneas son el bug: qué pasa, qué debería pasar y qué test lo reproduce.
- «Arregla el código para que npm test pase» da el criterio de terminado y el comando que el agente puede correr.
- La regla sobre
test/es lo que mide la tercera métrica. Sin ella escrita, editar un test no rompe ninguna regla. - «No hagas commit» deja el resultado en el mismo estado para las dos; el commit lo haces tú después de cada corrida.
- El resumen final no se mide, pero te dice si el agente entendió la causa.
Revisa también qué instrucciones de proyecto lee cada una, porque forman parte de la instrucción. Según su página de AGENTS.md, Codex lee los archivos AGENTS.md antes de trabajar. Según su documentación de memoria, Claude Code lee CLAUDE.md y, desde la versión 2.1.277, lee AGENTS.md cuando no hay un CLAUDE.md. Si tu repo solo tiene CLAUDE.md, Codex no ve esas reglas. Usa un AGENTS.md común (y que tu CLAUDE.md lo importe, si lo tienes) o ninguno. Qué conviene poner ahí lo vimos en contexto para agentes de IA.
Ahora corre cada agente en su carpeta, sin intervenir. Los dos comandos usan el modo no interactivo de cada CLI y guardan su salida en JSON:
cd ../cmp/claude
start=$(date +%s)
claude -p "$(cat ../prompt.md)" --permission-mode acceptEdits \
--allowedTools "Bash(npm test *)" --output-format json > ../runs/claude-1.json
echo "claude-1: $(( $(date +%s) - start )) s" | tee -a ../runs/times.txt
git add -A && git commit -qm "claude: bug 1" --allow-empty
cd ../codex
start=$(date +%s)
codex exec --sandbox workspace-write --json "$(cat ../prompt.md)" > ../runs/codex-1.jsonl
echo "codex-1: $(( $(date +%s) - start )) s" | tee -a ../runs/times.txt
git add -A && git commit -qm "codex: bug 1" --allow-empty
start=$(date +%s)guarda la hora de inicio en segundos y la líneaechoanota la duración entimes.txt: el mismo reloj para las dos.claude -pcorre Claude Code sin modo interactivo. Según su documentación del modo no interactivo, en-puna acción que necesita aprobación se rechaza si nada la aprueba:--permission-mode acceptEditsle deja editar archivos y--allowedTools "Bash(npm test *)"le deja corrernpm test, con o sin argumentos, según la sintaxis de permisos.--output-format jsonimprime un objeto con el resultado,duration_ms,num_turns,total_cost_usd,usageymodelUsage.codex execcorre Codex sin modo interactivo. Según su documentación del modo no interactivo, por defecto trabaja en un sandbox de solo lectura y--sandbox workspace-writele permite editar. La misma página aclara que--full-autoya no está soportado.--jsonimprime eventos en JSON Lines (thread.started,turn.started,item.*,turn.completed); cadaturn.completedtrae el uso de tokens.git add -Ay el commit congelan lo que dejó cada agente, incluidos archivos nuevos.--allow-emptyregistra también una corrida que no cambió nada.
Los permisos no quedan idénticos: Claude Code solo puede correr el comando que listaste, y Codex ejecuta sus comandos dentro de su sandbox. Anota qué podía hacer cada una. Corre una después de la otra, no a la vez, y alterna el orden: en el bug 1 empieza una y en el bug 2 la otra.
Las cuatro métricas: tiempo, diff, tests sin tocar y costo
Tres de las cuatro métricas se miden con los mismos comandos para las dos herramientas: el reloj de la shell y git. La cuarta, el costo, depende de lo que reporta cada una:
| Métrica | Cómo se mide | Claude Code | Codex |
|---|---|---|---|
| Tiempo | date +%s antes y después de la corrida | También reporta duration_ms en su JSON | La muestra de eventos de su documentación no incluye un campo de duración: usa el reloj de la shell |
| Diff | git diff --shortstat entre la base y el commit de la corrida | El mismo comando | El mismo comando |
| Tests sin tocar | git diff --name-only sobre test/ vacío, y la suite pasa con los tests originales | El mismo comando | El mismo comando |
| Costo | Tokens y lo que cuestan en tu forma de pago | total_cost_usd (estimación) y tokens por modelo en modelUsage | Tokens en cada turn.completed: input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens |
Desliza la figura para verla completa
El diff y los tests los mide este script. Guárdalo como ../cmp/agent-metrics.sh:
#!/usr/bin/env bash
# Diff size, test files touched and the original suite for one agent run.
# usage: bash agent-metrics.sh <base> <dir> "<test command>" <test path>...
set -uo pipefail
[ $# -ge 4 ] || { echo 'usage: agent-metrics.sh <base> <dir> "<test command>" <test path>...' >&2; exit 2; }
base=$1 dir=$2 cmd=$3
shift 3
git -C "$dir" rev-parse -q --verify "$base^{commit}" > /dev/null || { echo "unknown base: $base" >&2; exit 2; }
if [ -n "$(git -C "$dir" status --porcelain)" ]; then
echo "$dir has uncommitted changes: commit the agent's result first" >&2
exit 2
fi
echo "run: $(git -C "$dir" branch --show-current)"
stat=$(git -C "$dir" diff --shortstat "$base" HEAD)
echo "diff: ${stat:- no changes}"
touched=$(git -C "$dir" diff --name-only "$base" HEAD -- "$@")
if [ -n "$touched" ]; then
echo "tests: TOUCHED"
echo "$touched" | sed 's/^/ /'
else
echo "tests: untouched"
fi
# Put the original tests back, run the suite, then return to the agent's commit.
git -C "$dir" restore --source="$base" -- "$@" || exit 2
if (cd "$dir" && bash -c "$cmd") > /dev/null 2>&1; then suite=pass; else suite=FAIL; fi
git -C "$dir" reset -q --hard
git -C "$dir" clean -qfd -- "$@"
echo "suite: $suite (with the original tests)"
- Recibe la base (
cmp/base-1), la carpeta de la corrida, el comando de pruebas y las rutas de tests. Sin los cuatro argumentos, muestra el uso y sale con código 2. - Verifica que la base exista y que la carpeta no tenga cambios sin commit: el script reinicia la carpeta al final y no debe borrar nada que no esté guardado.
git diff --shortstatresume el diff: archivos cambiados, líneas agregadas y borradas, según la documentación de git diff.git diff --name-onlylimitado a las rutas de tests lista cada test que el agente cambió, borró o agregó. Si la lista no está vacía, la corrida marcaTOUCHED.git restore --sourcedevuelve las rutas de tests a como estaban en la base. Según la documentación de git restore, por defecto también quita los archivos versionados que no existen en la base, así que un test que agregó el agente no corre.- Corre la suite con los tests originales y anota
passoFAIL. Luegoreset --hardycleandejan la carpeta como la dejó el agente.
Desde ../cmp, córrelo una vez por agente: bash agent-metrics.sh cmp/base-1 claude "npm test" test, y lo mismo con codex. Esta es la salida en nuestro repo de práctica, con dos ramas de commits hechos a mano, sin ningún agente: agent-a cambió > por >= y agent-b cambió el valor esperado del test y agregó un comentario al código.
run: cmp/agent-a
diff: 1 file changed, 1 insertion(+), 1 deletion(-)
tests: untouched
suite: pass (with the original tests)
run: cmp/agent-b
diff: 2 files changed, 2 insertions(+), 1 deletion(-)
tests: TOUCHED
test/shipping.test.js
suite: FAIL (with the original tests)
agent-acambió una línea, no tocó los tests y la suite original pasa: arregló el bug.agent-btambién dejabanpm testen verde, pero editótest/shipping.test.jsy, con el test original, la suite falla: el bug sigue ahí.
Por eso la métrica de tests tiene dos partes. En otra prueba borramos el archivo de test: npm test siguió en verde, porque node --test sin archivos de test no falla (lo medimos con Node 22.22.3), y solo la corrida con los tests originales mostró el FAIL. Las demás formas de «arreglar» un test, como saltarlo o cambiar un mock, están en cómo revisar los cambios de un agente de IA en tus tests.
Para el tiempo, usa times.txt. Incluye la latencia de la red y del modelo, y varía entre corridas de la misma herramienta: trata las diferencias pequeñas como empate y, si puedes, corre cada bug dos veces por herramienta. Para el diff, más chico no siempre es mejor: mira qué archivos tocó, si hizo refactors que no pediste o si agregó dependencias, porque eso es lo que vas a revisar.
Para el costo, este script lee los tokens de cada salida guardada. Guárdalo como ../cmp/usage.mjs:
// Token usage (and Claude Code's cost estimate) from one run's saved output.
// usage: node usage.mjs <claude-run.json | codex-run.jsonl>
import { readFileSync } from "node:fs";
const text = readFileSync(process.argv[2], "utf8").trim();
let events;
try {
events = [JSON.parse(text)]; // Claude Code: one JSON document
} catch {
events = text.split("\n").filter(Boolean).map((line) => JSON.parse(line)); // Codex: JSON Lines
}
const result = events.find((e) => e.type === "result");
if (result) {
// Claude Code, --output-format json: one result object
const sum = (key) => Object.values(result.modelUsage ?? {}).reduce((n, m) => n + (m[key] ?? 0), 0);
console.log({
tool: "claude",
models: Object.keys(result.modelUsage ?? {}),
input: sum("inputTokens"),
cache_read: sum("cacheReadInputTokens"),
cache_write: sum("cacheCreationInputTokens"),
output: sum("outputTokens"),
cost_usd_estimate: result.total_cost_usd,
error: result.is_error,
});
} else {
// Codex, exec --json: usage on every turn.completed event
const turns = events.filter((e) => e.type === "turn.completed");
const sum = (key) => turns.reduce((n, e) => n + (e.usage?.[key] ?? 0), 0);
console.log({
tool: "codex",
turns: turns.length,
input: sum("input_tokens"),
cached_input: sum("cached_input_tokens"),
output: sum("output_tokens"),
reasoning_output: sum("reasoning_output_tokens"),
failed: events.some((e) => e.type === "turn.failed" || e.type === "error"),
});
}
- Lee el archivo como un solo JSON (la salida de Claude Code); si no puede, lo lee línea por línea como JSON Lines (la de Codex).
- Para Claude Code, suma los tokens de cada modelo en
modelUsage, que según la documentación de costos del SDK incluye a los subagentes, y muestratotal_cost_usd. - Para Codex, suma el
usagede cada eventoturn.completedy avisa si hubo unturn.failedo unerror. - Uso:
node usage.mjs runs/claude-1.jsonynode usage.mjs runs/codex-1.jsonl. Lo probamos con salidas de muestra que siguen el formato documentado de cada herramienta, no con corridas reales.
Antes de comparar costos, elige una unidad común. La documentación de Claude Code dice que total_cost_usd es una estimación calculada en tu computadora a precio de lista y que puede diferir de tu factura; su página de costos aclara que, para suscriptores Pro, Max y Ultra, el costo estimado de la sesión no es relevante para la facturación, porque el uso va incluido en el plan. En Codex, según su página de precios, el uso con un plan de ChatGPT consume los límites del plan (los ves con /status o en el panel de uso) y con una clave de API se cobra por token. Si pagas por API en las dos, compara dólares: la estimación de Claude Code contra los tokens de Codex por el precio de su modelo. Si usas suscripciones, anota los tokens y compara cada herramienta solo consigo misma entre bugs: los tokens de dos proveedores no son la misma unidad.
Repetir con tres bugs
Un bug es una anécdota. Elige tres con formas distintas:
- Un error de lógica de una línea, como el umbral del envío gratis.
- Un bug que cruza dos archivos, por ejemplo un redondeo distinto entre el carrito y el checkout.
- Un bug donde el atajo tentador es editar un test o un snapshot, porque el test parece «viejo».
Los mejores candidatos son bugs que ya arreglaste: sabes cuál es la respuesta correcta, tienes el test de regresión y puedes comparar cada diff con el tuyo. Pero en un worktree el arreglo sigue visible: en nuestro repo de práctica, git log --all desde el worktree mostró el commit del arreglo. Para esos bugs, en lugar de worktrees usa clones que solo traen el historial hasta la base:
fix=a1b2c3d # el commit donde arreglaste el bug 2
git switch -c cmp/base-2 "$fix^"
git checkout "$fix" -- test/shipping.test.js
git commit -m "test: bug 2 (fails)"
git switch main
git clone --no-local --single-branch --no-tags --branch cmp/base-2 . ../cmp/claude-2
git clone --no-local --single-branch --no-tags --branch cmp/base-2 . ../cmp/codex-2
git -C ../cmp/claude-2 switch -c cmp/claude-2
git -C ../cmp/codex-2 switch -c cmp/codex-2
cmp/base-2nace del commit anterior al arreglo ("$fix^").git checkout "$fix" -- test/…trae solo el test de regresión de ese commit, sin el código del arreglo. Cambia la ruta por la de tu test; el commit deja la base con el test fallando.- Según la documentación de git clone,
--no-localusa el transporte normal de git en vez de copiar la carpeta de objetos,--single-branchtrae solo el historial de esa rama y--no-tagsno trae tags. En nuestra prueba, el commit del arreglo no existía en el clon. - Cada clon recibe su propia rama, para que la salida del script diga de quién es cada corrida.
Instala dependencias en cada clon, corre los agentes igual que antes y mide con la base del remoto: bash agent-metrics.sh origin/cmp/base-2 claude-2 "npm test" test. La instrucción es la misma plantilla; solo cambia la descripción del bug.
Cómo decidir
Llena el marcador con las tres corridas de cada herramienta y decide en este orden:
- Primero la puerta. Una corrida que tocó tests o falla la suite original no cuenta como arreglo, sin importar lo rápida o barata que haya sido.
- Cuenta las puertas. Cuántos de los tres bugs pasó cada herramienta. Es la diferencia que más pesa.
- Con las puertas empatadas, mira el diff. Es lo que vas a revisar y mantener: cambios fuera del área del bug pesan más que unas líneas de más.
- Después, el costo en tu unidad, y al final el tiempo, que es la métrica más ruidosa.
- Si sigue parejo, es empate. Decide por lo que ya pagas y por cómo encaja cada herramienta en tu flujo (terminal, editor, CI).
Desliza la figura para verla completa
El resultado vale para tu repo, tus tres bugs y las versiones y modelos que probaste. Guarda el marcador y los archivos de runs/, y repite la prueba cuando cambie alguna de esas cosas. Al terminar, borra las carpetas de prueba con git worktree remove ../cmp/claude (y la de codex), y las ramas con git branch -D.
Errores comunes
- Partir de commits distintos. Si una corrida usa el worktree propio de su herramienta y la otra tu
HEAD, no comparas lo mismo. Crea los dos worktrees desde la misma rama base. - Dar contexto distinto. Un
CLAUDE.mdsinAGENTS.mdle da reglas a una herramienta y a la otra no. - Ayudar a una a mitad de corrida. Si le aclaras algo a una, ya no es la misma instrucción. Corrige el
prompt.mdy repite las dos. - Contar un verde con tests editados.
npm testen verde no basta: miratests:y la suite con los tests originales. - Comparar tokens entre proveedores. Compara dinero si pagas por API, o cada herramienta consigo misma si usas suscripción.
- Decidir con un bug y una corrida. El mismo agente puede resolver distinto el mismo bug en dos corridas. Tres bugs es el mínimo.
Preguntas frecuentes
¿Puedo correr los dos agentes al mismo tiempo?
Cada uno tiene su carpeta, así que no se pisan los archivos. Pero si sus suites compiten por la misma computadora, el tiempo deja de ser comparable. Para medir tiempo, córrelos uno después del otro y alterna quién va primero.
¿Qué hago si los dos fallan el mismo bug?
Revisa la instrucción antes que las herramientas: puede faltar información o el test puede pedir algo ambiguo. Corrige el prompt.md, vuelve a crear las dos carpetas desde la base y repite ese bug con las dos.
¿Sirve este método para otros agentes de código?
Sí. Solo necesita un modo no interactivo, git y una forma de leer el uso de tokens. Cambia el comando de la corrida y, si su salida tiene otro formato, adapta usage.mjs; agent-metrics.sh no cambia.
¿Qué modelo uso en cada herramienta?
El que usarías en tu trabajo diario, porque eso es lo que quieres saber. Fíjalo con --model en Claude Code y con -m en Codex para que no cambie entre un bug y otro, y anótalo en el marcador: si después cambias de modelo, repite la prueba.
Checklist
- El bug tiene un test que falla, confirmado en la rama base.
- Los dos worktrees (o clones, si el bug ya estaba arreglado) parten del mismo commit y tienen las mismas dependencias.
- Las dos herramientas leen las mismas instrucciones de proyecto: un
AGENTS.mdcomún o ninguno. - La instrucción está en
prompt.mde incluye la regla de no tocartest/y de no hacer commit. - Cada corrida se cronometra con
date +%s, guarda su JSON enruns/y se congela con un commit. agent-metrics.shdio diff, tests y suite original para cada corrida.- El costo está en una unidad común, y el modelo y la versión de cada CLI quedaron anotados.
- Se repitió con tres bugs, alternando el orden, y la decisión empezó por la puerta.
Con esto, la pregunta deja de ser cuál agente es mejor y pasa a ser cuál arregla mejor tus bugs. Antes de aceptar cualquier diff, revisa qué le hizo el agente a tus tests; para deshacer dentro de una sesión de Claude Code, repasa los puntos de control y /rewind, y para todo lo demás, tu rutina de git con agentes.
¿Viste esto en Instagram? Comenta VERSUS en el Reel y te mando la guía.
Escrito por

Publicado el 11 de noviembre de 2026