Copilot, ChatGPT, Claude, Gemini, Cursor y Codex: quién hace qué (y cuál te conviene)

Intro con gancho

Vas en el último tramo del sprint. La laptop ya suena como microbús subiendo el puente, el build tarda una vida y en Slack ya cayó el clásico: “¿sí sale el deploy hoy o mañana?”.

Abres el editor y tienes de todo: un bug raro, un test que falla a veces, un PR con comentarios medio filosos y, obvio, el chat con tu IA favorita.

Y llega la duda que sí pega en el jale: ¿qué herramienta uso para qué? Porque Copilot, ChatGPT, Claude, Gemini, Cursor y Codex se parecen… hasta que te dejan colgado en production.

Qué te vas a llevar

• Diferencias prácticas entre Copilot, ChatGPT, Claude, Gemini, Cursor y Codex sin humo.
• Qué conviene para autocomplete, debug, refactors, tests, documentación, búsqueda en repo y tareas tipo agente.
• Un workflow aterrizado (dev, soporte y sysadmin) que suma velocidad sin apagar el cerebro.
• Errores comunes (de esos que cuestan horas) y cómo ponerles barandales.

Contexto práctico: no son “competidores”, son roles

Piensa en esto como un equipo con personalidades:

• Copilot: el compa que se sienta contigo y te va completando la frase. Brilla en edición línea por línea.
• Cursor: tu editor con esteroides: IDE + chat + acciones sobre el repo. Se siente como traer un “junior rápido” que puede tocar varios archivos (y justo por eso hay que cuidarlo).
• ChatGPT / Claude / Gemini: el consultor que razona, explica, propone alternativas y te ayuda a pensar cuando tú ya traes el cerebro frito.
• Codex (según cómo lo uses): suele ir más directo al “hazme la tarea” de programación. En setups modernos puede ser el motor para generar/cambiar código y, dependiendo del producto, correr flujos más automatizados.

La trampa es pedirle a cada uno lo que no hace bien. Ejemplo real: pedirle a Copilot que entienda un bug que vive en 7 archivos, una config heredada y un flag que nadie documentó… y luego enojarte porque se inventó medio stack.

Quién hace qué: matriz rápida (con decisiones reales)

1) Autocomplete y “flow” dentro del editor

Mejor apuesta: Copilot (y en muchos casos, también Cursor como editor)

• Dónde brilla: boilerplate, patrones repetidos, convertir intención en código rápido, sugerir el siguiente paso cuando ya vas encaminado.
• Tradeoff real: si tu codebase tiene mañas, Copilot te las replica fielito. Es como aprender viendo al más mañoso del equipo.

Ejemplo práctico:

• Estás en TypeScript y necesitas mapear un DTO a tu modelo interno.
• Copilot suele completarte campos en orden y te ahorra minutos.
• Peeero si hay campos sensibles (isAdmin, role, scopes), tú revisas con lupa. Ahí es donde nacen los bugs caros.

2) Debug serio: “¿por qué falla en production pero no local?”

Mejor apuesta: ChatGPT o Claude (y Gemini si ya vives dentro de Google/Workspace)

• Dónde brilla: hipótesis, checklist de diagnóstico, lectura de logs, proponer experimentos baratos para acotar el problema.
• Tradeoff real: si le das contexto incompleto (versiones, qué cambió, cómo reproducir), te responde de manual. Suena bonito, no arregla nada.

Mini workflow que sí jala:

1. Pasa el síntoma con evidencia: error exacto, snippet de log, versión de runtime.
2. Pide 3 hipótesis y 1 experimento barato por hipótesis.
3. Ejecuta uno, regresa con resultados. Itera.

3) Refactors y cambios en múltiples archivos

Mejor apuesta: Cursor (bien configurado) o ChatGPT/Claude con disciplina

• Dónde brilla: renombrar módulos, extraer capas, mover funciones, actualizar imports, proponer estructura.
• Tradeoff real: cambiar mucho rápido = romper cosas en silencio. Aquí mandan tests, linters y el instinto.

Decisión práctica:

• Si tienes buen suite de tests y CI decente, puedes dejar que Cursor meta mano en varios archivos.
• Si tu suite es más deseo que realidad y el CI tarda 25 min en una VM triste, ve incremental y con checkpoints. Evita el mega-diff que nadie quiere revisar.

4) Tests: unit, integration, regresión

Mejor apuesta: ChatGPT/Claude para diseño + Copilot para escribir rápido

• Dónde brilla:
  • Claude/ChatGPT: casos borde, fixtures, mocks vs fakes, qué vale la pena probar.
  • Copilot: mecanografiar el test cuando ya definiste la forma.
• Tradeoff real: la IA tiende a inventar APIs o asumir frameworks. Tú pones el marco: Jest/Vitest, pytest, JUnit, etc.

Prompt útil (corto y efectivo):

“Tengo esta función y estos invariantes. Quiero 8 tests: 4 felices y 4 borde. Usa Vitest. No inventes dependencias. Si falta info, pregúntame.”

5) Documentación, onboarding y “explica este código que nadie toca”

Mejor apuesta: Claude o ChatGPT

• Dónde brilla: convertir código en explicación clara, generar README, diagramas en texto (tipo Mermaid), guías de uso.
• Tradeoff real: puede sonar súper convincente aunque esté mal. Úsalo como borrador; valida con el código y con alguien del equipo si aplica.

6) Búsqueda y contexto “pegado” al repo

Mejor apuesta: Cursor (por integración con el proyecto) + tus herramientas (ripgrep, búsqueda del IDE)

• Dónde brilla: relaciones entre archivos, “dónde se usa esto”, cambios más coherentes con tu codebase.
• Tradeoff real: en repos enormes y máquinas modestas (hola, Windows con 8GB o la Mac viejita de batalla), el índice se vuelve fricción. Ajusta el setup: excluye dist/, build/, node_modules/, limita carpetas y listo.

7) Tareas tipo agente: “haz esto y vuelve con un PR”

Mejor apuesta: depende del producto y tus guardrails; aquí entra Codex/agents según tu stack

• Dónde brilla: tareas definidas y repetibles, con criterios claros: “agrega endpoint + tests + docs”, “migra config”, “crea script”, “haz rollback plan”.
• Tradeoff real: un agente puede hacer mucho… incluyendo romper tu repo con toda la seguridad del mundo.

Regla de oro: si va a escribir código con poca supervisión, exige:

• plan,
• diffs chicos,
• verificación (tests + build) antes de declarar “terminado”.

Guía principal: un workflow real para usar todas sin volverte loco

Paso 1: define la intención en una oración (sí, una)

Antes de abrir el chat, escribe algo así:

• “Quiero arreglar el bug X sin cambiar el comportamiento Y.”
• “Quiero refactorizar esto para soportar Z sin romper A.”

Si no lo puedes decir tú, la IA menos.

Paso 2: elige herramienta por fricción, no por hype

• Si estás tecleando y quieres velocidad: Copilot.
• Si vas a tocar 6 archivos: Cursor (o chat + disciplina).
• Si estás atorado entendiendo: ChatGPT/Claude/Gemini.
• Si es tarea repetible con criterios: Codex/agent (con guardrails).

Paso 3: dale contexto mínimo viable (y quítale lo sensible)

Un patrón que uso mucho:

• Stack: Node 20, Postgres, Prisma, Next.js.
• Síntoma: error exacto.
• Repro: pasos.
• Esperado vs actual.
• Constraints: “no puedo cambiar schema”, “no puedo agregar dependencias”, “tengo 30 min”.

Y si hay datos sensibles (tokens, PII, secretos de AWS): redacta. Neta. Ese descuido no se arregla con un “perdón”.

Paso 4: exige plan + verificación

Pídeles que trabajen con este formato:

1. Plan en bullets (máx 7)
2. Cambios propuestos
3. Cómo verificar (comandos)

Ejemplo de verificación típica (Node):

npm test
npm run lint
npm run build

Paso 5: intégralo a tu rutina de pull request

• Pide un resumen para el PR (qué cambió y por qué).
• Pide una lista de riesgos: “¿qué podría romper esto?”
• Pide pruebas manuales en checklist.

Eso reduce un buen el “¿y esto por qué está así?” del reviewer, y te evita vueltas por deadline.

Dos escenarios reales (con sabor a vida tech mexa)

Escenario A: “Se cayó el servicio y el internet anda payaso”

Estás tethering con el cel (Telcel salvándote el día) y tienes que resolver en corto.

• Primero: ChatGPT/Claude para diagnóstico con logs pegados (ya redactados).
• Luego: Copilot para hacer el fix sin perder tiempo tecleando.
• Al final: la IA te ayuda a escribir el post-mortem sin drama: causa raíz, impacto y acción preventiva.

Tradeoff: cuando la conexión está inestable, los chats se cortan y pierdes contexto. Copilot en el editor se siente más “continuo”. Plan B: notas locales + comandos claros + no confiarte.

Escenario B: “Cliente pide cambio ‘rápido’ antes de facturar”

El clásico freelance mal cotizado: “es un ajuste chiquito” que termina tocando permisos, UI y un endpoint.

• Cursor para navegar el repo y proponer cambios multi-archivo.
• Claude/ChatGPT para revisar lógica de permisos y edge cases (“¿qué pasa si el usuario no tiene rol?”, “¿qué pasa con cuentas desactivadas?”).
• Copilot para rematar: componentes, validaciones, tests.

Consecuencia real: si te vas solo con autocomplete, acabas con un patchwork que compila pero no cumple reglas de negocio. El chat te ayuda a pensar; Copilot te ayuda a ejecutar.

Screenshots sugeridos

• Comparación de una misma tarea: “generar tests” en Copilot vs Chat (dos ventanas).
• Cursor mostrando cambios en múltiples archivos con un prompt y el diff.
• Un ejemplo de prompt con “Plan + Verificación” y la respuesta.
• Un PR description generado por IA + checklist de riesgos.

Errores comunes + solución

Error 1: pedir “arregla esto” sin reproducibilidad

Síntoma: te regresa 5 soluciones genéricas.

Solución: dale repro y pide experimentos.

• “Aquí está el error, aquí el comando, aquí el output. Dame 3 hipótesis y cómo falsarlas.”

Error 2: confiar en código que “se ve bien”

Síntoma: compila local, truena en CI o en prod.

Solución: obliga verificación.

• “No lo des por terminado hasta darme comandos para validar y qué output esperas.”

Error 3: refactor masivo sin red de seguridad

Síntoma: 40 archivos cambiados, nadie quiere revisar eso.

Solución: refactor por etapas.

• Etapa 1: rename + tests verdes
• Etapa 2: extraer módulo
• Etapa 3: limpiar

Error 4: prompts enormes con contexto inútil

Síntoma: se confunde, mezcla cosas, inventa.

Solución: contexto mínimo viable + preguntas.

• “Si te falta info, pregúntame antes de asumir.”

Error 5: filtrar secretos sin querer

Síntoma: pegaste .env, headers, tokens, datos de clientes.

Solución:

• Redacta (***) y comparte solo lo necesario.
• Usa ejemplos sintéticos cuando se pueda.
• Si tu empresa tiene políticas, se siguen aunque dé flojera. Más vale fricción que incidente.

Checklist final (para elegir y no arrepentirte)

• ¿Necesito escribir rápido dentro del archivo? → Copilot.
• ¿Necesito entender/razonar/diagnosticar? → ChatGPT o Claude (Gemini si estás en ecosistema Google).
• ¿Necesito cambiar varias partes del repo con coherencia? → Cursor + tests.
• ¿La tarea es repetible y bien especificada? → Codex/agent con plan + verificación.
• ¿Tengo tests/CI listos para cachar errores? Si no, reduce el alcance.
• ¿Ya redacté secretos/PII? Siempre.
• ¿Tengo un PR claro con riesgos y pasos de prueba? Eso te salva revisiones.

FAQ

1) ¿Copilot reemplaza a ChatGPT/Claude?

No. Copilot es más “manos en el teclado”. ChatGPT/Claude son mejores para pensar, explicar y diseñar. Juntos rinden más.

2) ¿Cursor es solo un editor con chat?

Es un editor que puede operar sobre tu repo (buscar, proponer diffs, tocar varios archivos). Ese poder está buenísimo… y también es riesgo. Úsalo con tests y cambios pequeños.

3) ¿Cuál da mejores respuestas para backend vs frontend?

No es tan binario. En general:

• Autocomplete de UI repetitiva: Copilot suele ser muy fuerte.
• Lógica de negocio y diseño de pruebas: ChatGPT/Claude suelen ayudar más.
  El ganador cambia según tu stack y el contexto real que puedas compartir.

4) ¿Qué hago si la IA inventa funciones o librerías?

Córtalo directo: “No inventes APIs. Usa solo lo que te pasé. Si falta algo, pregunta.” Y cuando hable del repo, pídele que cite archivos o ubicaciones concretas.

5) ¿Cómo mido productividad sin autoengañarme?

Mide outcomes: tiempo a PR mergeado, bugs post-release, tamaño de diff, y si el equipo entiende el cambio. Si escribes más rápido pero rompes más, saliste tablas (o perdiste).

Siguiente episodio: teaser

Vas a dejar de pelearte con prompts kilométricos: armaremos plantillas cortas que sí generan cambios correctos.
Y lo más útil: cómo pedirle a tu IA que te contradiga antes de que production lo haga.