¿Cuándo deberías pedirle a una IA que escriba código desde cero versus solo revisar o refactorizar código existente?

Question

Accepted Answer

La regla general: deja que la IA **escriba** donde los errores son baratos y obvios, y úsala para **revisar/refactorizar** donde los errores son costosos o sutiles. El factor decisivo es cuánto te cuesta verificar el resultado.

## Por qué es importante

- **Greenfield y boilerplate** — una nueva utilidad, un archivo de configuración, un endpoint CRUD, una regex. No hay contexto oculto que romper.
- **APIs/librerías desconocidas** — la IA conoce la superficie de una librería que no conoces, y verificas contra la documentación.
- **Código descartable/prototipo** — la velocidad importa más que la perfección.

En estos casos el costo de un error es bajo y puedes leer el resultado de arriba a abajo.

## Cuándo usarla solo para revisar/refactorizar

- **Lógica crítica de negocio** — facturación, autenticación, matemáticas de dinero. Una respuesta incorrecta que parece plausible es peligrosa.
- **Código sutil** — concurrencia, seguridad, algoritmos pesados en casos edge donde "parece correcto" no es "es correcto".
- **Sistemas existentes grandes** — la IA no puede ver todos los invariantes en los que depende tu base de código, así que generar en ella riesga rotura silenciosa.

Aquí mantienes la IA como un **segundo par de ojos**: sugiere, tú decides.

```text
                 Cost of a bug LOW          Cost of a bug HIGH
New code          ✅ let AI write           ⚠️ AI drafts, you verify hard
Existing code     ✅ AI refactors           ✅ AI reviews, you write the change
```

## Tradeoffs y riesgos

Escribir desde cero es rápido pero la IA puede inventar APIs (**alucinación**) o perder contexto que no puede ver. Revisar es más seguro pero más lento y solo tan bueno como el contexto que le das. De cualquier forma eres el **autor responsable** — la IA es una herramienta, no quien firma el commit.

## Por qué es importante

Misjuzgar esto es donde la dev asistida por IA sale mal: la gente deja que la IA genere lógica crítica que luego no puede verificar completamente, o escriben manualmente boilerplate trivial que la IA podría haber producido en segundos. Alinear el modo (**escribir** vs **revisar/refactorizar**) con el **costo de estar equivocado** te mantiene rápido en las cosas baratas y cuidadoso en las peligrosas. La habilidad que se prueba es el juicio sobre dónde gastar tu esfuerzo de verificación — no si puedes hacer prompt a una IA.