AI Slop (Dégradation du code par l'IA)

1. Vue d'ensemble du concept et problème systémique

Avec la baisse du coût de génération des tokens, l'industrie du développement fait face à une nouvelle forme d'inflation : le coût de création d'une ligne de code a chuté presque à zéro, tandis que le coût de sa compréhension, de sa revue, de sa maintenance et de son débogage est resté inchangé, voire a augmenté.

AI Slop (Déchet artificiel) désigne un code syntaxiquement correct qui passe même les tests primitifs, mais qui est conceptuellement nuisible à la santé du projet. Il se caractérise par :

• Un gonflement injustifié de la taille des fichiers (Code Bloat).
• Une duplication cachée de fonctionnalités existantes.
• Des cas limites (Edge Cases) masqués, que le modèle a « lissés » avec des valeurs de fallback dangereuses au lieu de lever les exceptions appropriées.
• La perte du style d'ingénierie unique du projet.

Si 30 % d'AI Slop pénètre dans le dépôt, la base de code devient non maintenable en 6 à 12 mois : les nouvelles fonctionnalités cassent les anciennes de manière imprévisible, le temps d'onboarding des nouveaux développeurs triple, et la vélocité de développement tombe à zéro.

Le cycle d'accumulation de code bâclé (The Slop Accumulation Cycle) :
[Tâche] ---> [Prompt sans contexte] ---> [Le LLM génère 200 lignes de boilerplate]
                                                       |
                                                       v
[Fonction formatCurrency dupliquée générée] <--- [Clic aveugle sur « Accepter »]
                                                       |
                                                       v
[Gonflement du bundle + Nouveaux bugs cachés] <--- [Merge dans main sans revue approfondie]

2. Taxonomie architecturale et modèle mental

Les variétés de déchet générées lors d'une production de code sans réflexion :

1. Slop de réinvention (Reinvention Slop) :
   • Le modèle ne voit pas les helpers existants comme cn() (clsx/tailwind-merge) ou formatDate() et génère son propre équivalent local directement dans le composant.
   • Résultat : 20 implémentations différentes de la même opération, avec des comportements divergents pour null ou undefined.
2. Slop de programmation défensive (Defensive Bloat) :
   • Vérifications infinies du type if (user && user.profile && user.profile.settings) dans des environnements disposant déjà de l'Optional Chaining (user?.profile?.settings) ou d'un typage strict TypeScript garantissant la présence des champs.
3. Slop de dissimulation d'erreurs (Silent Failure Slop) :
   • Enrobage de tout problème potentiel dans un bloc try { ... } catch (e) { return null; }.
   • Résultat : le système ne plante pas, mais perd silencieusement des données ou génère des rapports corrompus, transformant le débogage en production en cauchemar.
4. Slop de commentaires (Comment Hallucination) :
   • Des dizaines de lignes de commentaires évidents ajoutés par le modèle pour faire volume, créant un bruit visuel et occultant la substance de l'algorithme.

3. Pipeline technique et mécanique interne

Comparaison : Code sain contre AI Slop

Exemple d'AI Slop (Gonflé, dangereux, verbeux) :

// Function to calculate user discount based on type
export function calculateDiscount(user: any): number {
  // Check if user is not null and not undefined
  if (user !== null && user !== undefined) {
    // Check if user role exists
    if (user.role) {
      if (user.role === 'VIP') {
        return 0.20; // 20 percent discount
      } else if (user.role === 'PREMIUM') {
        return 0.15; // 15 percent discount
      } else {
        return 0.05; // standard discount
      }
    } else {
      return 0;
    }
  } else {
    // Return zero if user does not exist
    return 0;
  }
}

Code de production idiomatique (Propre, strictement typé) :

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;
}

Filtre automatique de rejet des doublons dans CI/CD

Implémentation d'une vérification de la base de code contre le copier-coller via 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 code généré fait augmenter le taux de duplication au-delà de 1,5 %, le pipeline bloque automatiquement la PR.

4. Scénarios d'ingénierie pratiques en production

01. Allègement du bundle client après nettoyage du déchet

L'équipe a constaté que la taille du bundle JavaScript Next.js était passée de 180 Ko à 950 Ko en 3 mois d'utilisation intensive des agents. L'audit a révélé que les agents avaient installé 4 bibliothèques différentes de gestion des dates (date-fns, dayjs, moment, luxon) ainsi que 3 packs d'icônes distincts. Après suppression des doublons et unification via un import de base, le bundle a été réduit de 70 %.

02. Prévention des fuites mémoire via des listeners d'événements spaghetti

Un agent a généré un composant avec une souscription WebSocket, mais a oublié la fonction de nettoyage (return () => socket.off(...)) dans le useEffect. À la place, le modèle a ajouté une vérification du flag isMounted. Lors du changement de route, les anciens listeners restaient en mémoire, entraînant le crash de l'onglet du navigateur suite à un dépassement du heap après 20 minutes de session.

03. Nettoyage de la base de données des colonnes hallucinées

Un développeur a appliqué aveuglément une migration Prisma proposée par le modèle. Celui-ci avait ajouté 8 champs superflus « pour le futur » avec des types incorrects (varchar au lieu de jsonb). L'architecte a détecté cela lors de la code review, a supprimé la migration avant son déploiement en staging et a ramené le modèle vers un schéma minimaliste.

5. Pièges, erreurs courantes et sécurité

1. L'illusion de complétude grâce aux commentaires : La présence de bons commentaires JSDoc avant une fonction crée une fausse impression de haute qualité, alors que l'intérieur contient un algorithme lent ou une interpolation de chaîne SQL dangereuse. Évaluez uniquement la logique et l'asymptotique, pas l'apparence.
2. Hallucination de dépendances (Package Slop / Slop Typosquatting) : Le modèle peut générer l'import d'un paquet NPM inexistant (par exemple, import { superValidator } from 'fast-super-validator'). Des attaquants enregistrent intentionnellement ces hallucinations courantes sur npmjs.com et y publient du code malveillant qui s'exécute lors du npm install sur votre serveur.
3. Perte des invariants architecturaux du système : Si le projet a été construit selon les principes de Clean Architecture ou FSD (Feature-Sliced Design), un agent non contrôlé érode rapidement les frontières des couches, appelant des méthodes de base de données directement depuis les composants UI. Exigez des agents qu'ils respectent strictement les règles du projet via .cursorrules ou AGENTS.md.