AI Slop (Desperdicio de IA y Contaminación de la Base de Código)

1. Visión general del concepto y problema sistémico

Con la disminución del costo de generación de tokens, la industria del desarrollo se enfrenta a una nueva forma de inflación: el costo de crear una línea de código ha caído casi a cero, mientras que el costo de entender, revisar, mantener y depurar ese código se ha mantenido constante o incluso ha aumentado.

AI Slop (Desperdicio de IA) es código que es sintácticamente correcto e incluso pasa pruebas primitivas, pero es conceptualmente dañino para la salud del proyecto. Se caracteriza por:

• Inflación injustificada del tamaño de los archivos (Code Bloat).
• Duplicación oculta de funcionalidad existente.
• Casos extremos enmascarados (Edge Cases) que el modelo "suavizó" con valores de fallback peligrosos en lugar de lanzar excepciones correctas.
• Pérdida de un estilo de ingeniería unificado en el proyecto.

Si un 30% de AI Slop entra en el repositorio, la base de código se vuelve insostenible en 6-12 meses: nuevas características rompen las antiguas de manera impredecible, el tiempo de incorporación de nuevos desarrolladores se triplica y la velocidad de desarrollo cae a cero.

Ciclo de acumulación de desperdicio (The Slop Accumulation Cycle):
[Tarea] ---> [Prompt sin contexto] ---> [LLM genera 200 líneas de boilerplate]
                                                       |
                                                       v
[Se generó un duplicado de la función formatCurrency] <--- [Clic ciego "Accept"]
                                                       |
                                                       v
[Aumento del tamaño del bundle + Nuevos bugs ocultos] <--- [Merge en main sin revisión profunda]

2. Taxonomía arquitectónica y modelo mental

Tipos de desperdicio que surgen en el proceso de generación de código sin reflexión:

1. Desperdicio de reinvención (Reinvention Slop):
   • El modelo no ve el helper existente cn() (clsx/tailwind-merge) o formatDate() y genera su propio análogo local directamente dentro del componente.
   • Resultado: 20 implementaciones diferentes de una misma operación con comportamientos variados ante null o undefined.
2. Desperdicio de programación defensiva (Defensive Bloat):
   • Comprobaciones infinitas if (user && user.profile && user.profile.settings) en entornos con encadenamiento opcional moderno (Optional Chaining user?.profile?.settings) o tipado estricto de TypeScript, que ya garantiza la existencia del campo.
3. Desperdicio de ocultación de errores (Silent Failure Slop):
   • Envolver cualquier problema potencial en try { ... } catch (e) { return null; }.
   • Resultado: el sistema no falla, pero pierde datos silenciosamente o genera informes distorsionados, convirtiendo la depuración en producción en una pesadilla.
4. Desperdicio de comentarios (Comment Hallucination):
   • Docenas de líneas de comentarios obvios que el modelo añade para volumen, creando ruido visual y dificultando la comprensión del algoritmo.

3. Pipeline técnico y mecánica interna

Comparación: Código saludable vs AI Slop

Ejemplo de AI Slop (Prolijo, peligroso, excesivamente detallado):

// Función para calcular el descuento del usuario según el tipo
export function calculateDiscount(user: any): number {
  // Verificar si el usuario no es nulo y no es indefinido
  if (user !== null && user !== undefined) {
    // Verificar si existe el rol del usuario
    if (user.role) {
      if (user.role === 'VIP') {
        return 0.20; // 20 por ciento de descuento
      } else if (user.role === 'PREMIUM') {
        return 0.15; // 15 por ciento de descuento
      } else {
        return 0.05; // descuento estándar
      }
    } else {
      return 0;
    }
  } else {
    // Retornar cero si el usuario no existe
    return 0;
  }
}

Código de producto idiomático (Limpio, estrictamente tipado):

export type UserRole = "VIP" | "PREMIUM" | "STANDARD";

const ROLE_DISCOUNTS: Record<UserRole, number> = {
  VIP: 0.20,
  PREMIUM: 0.15,
  STANDARD: 0.05,
} as const;

export function getDiscount(role?: UserRole): number {
  return role ? ROLE_DISCOUNTS[role] ?? 0 : 0;
}

Filtro automático de rechazo de duplicados en CI/CD

Implementación de verificación de la base de código para detectar copias usando jscpd:

// .jscpd.json
{
  "threshold": 1.5,
  "reporters": ["console", "json"],
  "ignore": ["**/node_modules/**", "**/dist/**", "**/*.d.ts"],
  "absolute": true,
  "minTokens": 35,
  "minLines": 5
}

Si un commit de código generado eleva el porcentaje de duplicación por encima del 1.5%, el pipeline bloquea automáticamente el PR.

4. Escenarios prácticos de ingeniería en producción

01. Desacoplamiento del bundle del cliente tras limpiar el desperdicio

El equipo notó que el tamaño del bundle de JavaScript de Next.js aumentó de 180 KB a 950 KB en 3 meses de uso activo de agentes. Una auditoría reveló que los agentes instalaron 4 bibliotecas diferentes para trabajar con fechas (date-fns, dayjs, moment, luxon) y 3 paquetes de íconos diferentes. Tras eliminar duplicados y unificar a través de una importación base, el bundle se redujo en un 70%.

02. Prevención de fugas de memoria a través de oyentes de eventos espaguetis

Un agente generó un componente con suscripción a WebSocket, pero dentro de useEffect olvidó la función de limpieza (return () => socket.off(...)). En su lugar, el modelo añadió una verificación de la bandera isMounted. Al cambiar de rutas, los antiguos oyentes continuaron ocupando memoria, lo que llevó a que la pestaña del navegador se bloqueara debido a un desbordamiento de heap tras 20 minutos de sesión.

03. Limpieza de la base de datos de columnas alucinadas

Un desarrollador aplicó ciegamente una migración de Prisma sugerida por el modelo. El modelo añadió 8 campos redundantes a la tabla "para el futuro" con tipos incorrectos (varchar en lugar de jsonb). El arquitecto detectó esto en la etapa de revisión de código, eliminó la migración antes de su despliegue en staging y devolvió el modelo a un esquema minimalista.

5. Errores comunes, trampas y seguridad

1. Ilusión de completitud a través de comentarios: La presencia de buenos comentarios JSDoc antes de una función crea una impresión engañosa de alta calidad, mientras que dentro hay un algoritmo lento o una interpolación de cadenas peligrosa en SQL. Evalúe solo la lógica y la asintótica, no la apariencia externa.
2. Alucinación de dependencias (Package Slop / Slop Typosquatting): El modelo puede generar una importación de un paquete NPM inexistente (por ejemplo, import { superValidator } from 'fast-super-validator'). Los atacantes registran intencionalmente tales alucinaciones comunes en npmjs.com y colocan allí código malicioso que se ejecuta durante npm install en su servidor.
3. Pérdida de invariantes arquitectónicos del sistema: Si el proyecto se construyó bajo los principios de Clean Architecture o FSD (Feature-Sliced Design), un agente descontrolado rápidamente difuminará los límites de las capas, invocando métodos de bases de datos directamente desde componentes de UI. Exija a los agentes un estricto cumplimiento de las reglas del proyecto a través de .cursorrules o AGENTS.md.