Desarrollo Web 17/11/2026 Codit Digital

IA para programar: cuando el código rápido se vuelve deuda

La velocidad ya no es el problema

Programar con asistencia de IA dejó de ser una novedad. Lo que antes llevaba una tarde hoy se resuelve en una sesión, y esa ganancia es real. El informe Navigating Open Source Software Development in the Generative AI Era, publicado por LF Research con Red Hat, Futurewei, OpenSSF y LF AI & Data, relevó ahorros de tiempo de entre 19% y 52% según la tarea (https://linuxfoundation.org/research/oss-development-gen-ai-era-2026).

El mismo informe trae la contracara: 1 de cada 4 pull requests entrantes se considera de baja calidad, un fenómeno que los mantenedores llaman AI slop. En proyectos grandes el porcentaje sube, y el agotamiento de quienes revisan contribuciones aparece como la principal preocupación. Solo 1 de cada 3 proyectos tiene una política formal de contribución con IA.

Traducido a una empresa argentina: el problema ya no es si el equipo usa IA, sino si hay reglas para aceptar lo que produce. Sin esas reglas, la herramienta aumenta el volumen de código entrante y traslada el cuello de botella a la revisión.

De dónde viene la deuda cuando se genera código con IA

El código generado suele ser plausible. Compila, pasa el test feliz y se ve razonable en un diff de trescientas líneas. Lo que no siempre aparece es el contexto: por qué se eligió ese patrón, qué contrato respeta, qué pasa con los errores, cómo se comporta con datos raros.

Hay cuatro fuentes recurrentes de deuda:

1. Coherencia arquitectónica. El asistente propone una solución localmente correcta que contradice la decisión global. Agrega una dependencia nueva donde el proyecto ya tiene otra, o mete lógica de negocio en un controlador cuando la arquitectura la tiene en un servicio.

2. Superficie de ataque. Un handler generado sin validación de entrada, un token que se registra en logs, una consulta que se arma por concatenación. Ninguno de esos errores se ve en el demo.

3. Tests que confirman el sesgo. Si pedís un test después del código, el modelo tiende a escribir un test que valide exactamente lo que hizo, no lo que debería hacer. El resultado es una suite verde que no protege nada.

4. Documentación inexistente. El código llega, pero nadie puede explicar después por qué está ahí. Cuando el autor original se va o el contexto se pierde, ese bloque se convierte en intocable.

Si querés profundizar en cómo se mide y se decide este tipo de deuda, te puede servir deuda técnica, refactor y reescritura del motor propio.

No todo es velocidad: lo que sí funciona

Los datos del informe no invitan a prohibir la herramienta. Al contrario: muestran que el ahorro de tiempo es consistente y que el problema está en la gobernanza, no en el uso. La recomendación de LF Research es pasar de una gestión reactiva a sistemas claros de verificación.

En la práctica, eso se traduce en hábitos concretos. El primero es usar IA para tareas con límites bien definidos: boilerplate, transformaciones de datos, pruebas de casos límite, migraciones repetitivas. El segundo es pedir explicaciones, no solo código. Si quien revisa no puede explicar el resultado, no debería aprobarlo.

El tercero es mantener al humano responsable del contrato. Definir entradas, salidas y errores esperados antes de generar código reduce muchísimo el margen de invención. Es el mismo principio que aplicamos cuando delegamos tareas operativas: conviene revisar IA para pymes: qué delegar hoy antes de soltar procesos completos.

Una política de IA en siete reglas

No hace falta un documento de cincuenta páginas. Alcanza con siete reglas que el equipo pueda recordar y aplicar en cada pull request:

  1. Todo código generado se revisa como si viniera de un desconocido. No hay excepción por rapidez.
  2. Las dependencias nuevas requieren justificación. Si la solución agrega un paquete, hay que explicar por qué no alcanzaba con lo que ya estaba.
  3. Los tests se escriben contra el comportamiento esperado, no contra la implementación propuesta.
  4. Las zonas críticas tienen revisión humana obligatoria: autenticación, pagos, facturación, permisos y consultas a datos sensibles.
  5. Se registra el origen cuando aplica. En proyectos con licencias o requisitos de trazabilidad, saber si un bloque fue generado ayuda a auditar.
  6. Nada se mergea sin ejecutar el pipeline completo. Lint, análisis estático, tests y build.
  7. Cada mejora del proceso se escribe. Si el equipo descubre un prompt que funciona o un paso de revisión que evitó un bug, pasa al playbook del proyecto.

Estas reglas no frenan la adopción. La ordenan. Y tienen un efecto colateral positivo: hacen que la revisión sea más rápida, porque quien revisa sabe qué buscar.

Cómo medir si la adopción está saliendo bien

Mirá cuatro números. El primero es el tiempo de revisión por pull request: si sube mucho, el volumen generado está superando la capacidad de validación. El segundo es la tasa de revert y de correcciones posteriores al merge. El tercero es la cantidad de dependencias nuevas por mes. El cuarto es la cobertura de tests en las zonas críticas, no el promedio global.

Si esos indicadores empeoran, no hace falta culpar a la IA. Casi siempre falta una política explícita o una etapa de verificación automatizada. La misma lógica que aplicamos en QA visual para entregas white label: la revisión no es un trámite final, es parte del proceso de producción.

El criterio que usamos en Codit Digital

Usamos IA para acelerar, nunca para decidir. La arquitectura, los contratos entre módulos y las decisiones de seguridad las toma el equipo humano, con criterio y con contexto del negocio. Después sí: automatizamos lo repetitivo y verificamos con pipelines que no dependen de la buena voluntad de nadie.

Ese equilibrio es el que permite entregar más rápido sin pagar la factura dos meses después. Si tu equipo ya genera código con IA y querés ordenar la revisión sin perder velocidad, hablemos: en Codit Digital acompañamos equipos a adoptar IA con criterio técnico y control de calidad. Escribinos desde contacto.