Saltar al contenido

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)
  1. Por qué comparar con tu propio código
  2. Preparar dos ramas iguales
  3. La misma instrucción para Claude Code y Codex
  4. Las cuatro métricas: tiempo, diff, tests sin tocar y costo
  5. Repetir con tres bugs
  6. Cómo decidir
  7. Errores comunes
  8. Preguntas frecuentes
  9. Checklist

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.
el mismo bug, dos agentes: un flujo, las mismas condicionescmp/base-1test que fallaClaude Code../cmp/claudeclaude -pruns/claude-1.jsonprompt.md../cmp/codexCodexcodex execruns/codex-1.jsonlagent-metrics.shusage.mjs4 métricasmisma base, misma instrucción, mismas medicionescada corrida se congela en un commit antes de medir; el tiempo, con date +%s

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)
  1. git switch -c cmp/base-1 crea la rama base desde donde estás. Empieza con el árbol de trabajo limpio.
  2. El commit guarda el test que falla: es la especificación del arreglo y lo que después revisa la métrica de tests.
  3. npm test tiene que fallar en la base, y por el bug. Si falla por otra cosa, ningún agente puede pasar esa prueba.
  4. ../cmp/runs guarda la salida de cada corrida fuera de los worktrees, para que no entre en el diff.
  5. Cada git worktree add crea una carpeta y una rama nueva desde cmp/base-1: el mismo commit para los dos.
  6. npm ci instala 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é.
  1. Las tres primeras líneas son el bug: qué pasa, qué debería pasar y qué test lo reproduce.
  2. «Arregla el código para que npm test pase» da el criterio de terminado y el comando que el agente puede correr.
  3. La regla sobre test/ es lo que mide la tercera métrica. Sin ella escrita, editar un test no rompe ninguna regla.
  4. «No hagas commit» deja el resultado en el mismo estado para las dos; el commit lo haces tú después de cada corrida.
  5. 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
  1. start=$(date +%s) guarda la hora de inicio en segundos y la línea echo anota la duración en times.txt: el mismo reloj para las dos.
  2. claude -p corre Claude Code sin modo interactivo. Según su documentación del modo no interactivo, en -p una acción que necesita aprobación se rechaza si nada la aprueba: --permission-mode acceptEdits le deja editar archivos y --allowedTools "Bash(npm test *)" le deja correr npm test, con o sin argumentos, según la sintaxis de permisos.
  3. --output-format json imprime un objeto con el resultado, duration_ms, num_turns, total_cost_usd, usage y modelUsage.
  4. codex exec corre 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-write le permite editar. La misma página aclara que --full-auto ya no está soportado.
  5. --json imprime eventos en JSON Lines (thread.started, turn.started, item.*, turn.completed); cada turn.completed trae el uso de tokens.
  6. git add -A y el commit congelan lo que dejó cada agente, incluidos archivos nuevos. --allow-empty registra 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étricaCómo se mideClaude CodeCodex
Tiempodate +%s antes y después de la corridaTambién reporta duration_ms en su JSONLa muestra de eventos de su documentación no incluye un campo de duración: usa el reloj de la shell
Diffgit diff --shortstat entre la base y el commit de la corridaEl mismo comandoEl mismo comando
Tests sin tocargit diff --name-only sobre test/ vacío, y la suite pasa con los tests originalesEl mismo comandoEl mismo comando
CostoTokens y lo que cuestan en tu forma de pagototal_cost_usd (estimación) y tokens por modelo en modelUsageTokens en cada turn.completed: input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens
cómo se mide cada métrica en cada herramientamétricacomúnClaude CodeCodextiempodate +%santes y despuésduration_msen su JSONreloj de la shelldiffgit diff --shortstatbase HEADel mismoel mismotestsgit diff --name-only+ suite originalel mismoel mismocostotokens -> tu unidadtotal_cost_usd *modelUsageturn.completedusage (tokens)tiempo, diff y tests: los mismos comandos para las dos* total_cost_usd es una estimación local a precio de lista, no tu factura

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)"
  1. 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.
  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.
  3. git diff --shortstat resume el diff: archivos cambiados, líneas agregadas y borradas, según la documentación de git diff.
  4. git diff --name-only limitado a las rutas de tests lista cada test que el agente cambió, borró o agregó. Si la lista no está vacía, la corrida marca TOUCHED.
  5. git restore --source devuelve 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.
  6. Corre la suite con los tests originales y anota pass o FAIL. Luego reset --hard y clean dejan 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)
  1. agent-a cambió una línea, no tocó los tests y la suite original pasa: arregló el bug.
  2. agent-b también dejaba npm test en verde, pero editó test/shipping.test.js y, 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"),
  });
}
  1. 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).
  2. 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 muestra total_cost_usd.
  3. Para Codex, suma el usage de cada evento turn.completed y avisa si hubo un turn.failed o un error.
  4. Uso: node usage.mjs runs/claude-1.json y node 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
  1. cmp/base-2 nace del commit anterior al arreglo ("$fix^").
  2. 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.
  3. Según la documentación de git clone, --no-local usa el transporte normal de git en vez de copiar la carpeta de objetos, --single-branch trae solo el historial de esa rama y --no-tags no trae tags. En nuestra prueba, el commit del arreglo no existía en el clon.
  4. 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:

  1. 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.
  2. Cuenta las puertas. Cuántos de los tres bugs pasó cada herramienta. Es la diferencia que más pesa.
  3. 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.
  4. Después, el costo en tu unidad, y al final el tiempo, que es la métrica más ruidosa.
  5. Si sigue parejo, es empate. Decide por lo que ya pagas y por cómo encaja cada herramienta en tu flujo (terminal, editor, CI).
plantilla del marcador: tres bugs, dos agentes, cuatro métricasbugagentetiempodifftestscosto1Claude Code__ s_ arch. +__ -__sí / no______Codex__ s_ arch. +__ -__sí / no______2Claude Code__ s_ arch. +__ -__sí / no______Codex__ s_ arch. +__ -__sí / no______3Claude Code__ s_ arch. +__ -__sí / no______Codex__ s_ arch. +__ -__sí / no______puertas pasadas (tests sin tocar y suite original):Claude Code __ / 3Codex __ / 3primero la puerta, luego diff, costo y tiempoplantilla vacía para tus corridas: aquí no hay resultados

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.md sin AGENTS.md le 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.md y repite las dos.
  • Contar un verde con tests editados. npm test en verde no basta: mira tests: 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.md común o ninguno.
  • La instrucción está en prompt.md e incluye la regla de no tocar test/ y de no hacer commit.
  • Cada corrida se cronometra con date +%s, guarda su JSON en runs/ y se congela con un commit.
  • agent-metrics.sh dio 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

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 11 de noviembre de 2026

← Blog