Pourquoi les Règles Sont l'Arme Secrète
du Code Review IA

Chez diffray, nous avons résolu ce problème avec les règles structurées. Laissez-moi vous montrer pourquoi elles sont la clé pour faire fonctionner le code review IA.

Le Problème : La Dilution du Contexte Tue la Performance de l'IA

Quand vous déversez un PR entier dans un LLM avec un prompt comme « révise ce code », plusieurs choses tournent mal :

La Solution : Les Règles Structurées

Une règle structurée n'est pas juste un prompt — c'est une spécification complète qui dit à l'IA exactement quoi chercher, où chercher, et comment rapporter les résultats.

Voici à quoi ressemble une règle :

rules:
  - id: sec_sql_injection
    agent: security
    title: "Injection SQL via concaténation de chaînes"
    description: "Les entrées utilisateur concaténées dans les requêtes SQL permettent aux attaquants d'exécuter du SQL arbitraire"
    importance: 9

    match:
      file_glob:
        - "src/api/**/*.ts"
        - "src/routes/**/*.ts"
        - "!**/*.test.ts"
      content_regex:
        - "query.*\$\{|\+.*query"

    checklist:
      - "Trouver tous les endroits où les entrées utilisateur sont utilisées dans les requêtes SQL"
      - "Vérifier si des requêtes paramétrées ou des prepared statements sont utilisés"
      - "Vérifier que la concaténation de chaînes N'EST PAS utilisée pour construire les requêtes"

    examples:
      bad: |
        const query = `SELECT * FROM users WHERE id = ${userId}`;
        await db.execute(query);
      good: |
        const query = 'SELECT * FROM users WHERE id = ?';
        await db.execute(query, [userId]);

Cette structure permet trois capacités critiques qui font vraiment fonctionner le code review IA.

1. Résultats Déterministes Grâce au Ciblage Précis

Remarquez la section match ? C'est du pattern matching qui détermine quand la règle s'exécute.

Sans pattern matching, réviser un PR de 50 fichiers signifie analyser les 50 fichiers pour chaque problème possible. Avec le pattern matching :

Si un PR a 5 fichiers API contenant des requêtes SQL, seuls ces 5 fichiers sont envoyés pour les vérifications d'injection SQL. L'IA voit exactement ce qu'elle doit évaluer — rien de plus.

Cette précision élimine l'aléatoire qui affligeait les tentatives précédentes de code review IA. Même code + mêmes règles = mêmes résultats. À chaque fois.

2. Architecture Multi-Agent : Le Bon Expert pour Chaque Problème

C'est là que ça devient intéressant. diffray n'utilise pas une seule IA pour tout réviser — il utilise 31 agents spécialisés, chacun focalisé sur ce qu'il fait le mieux :

Chaque agent a un prompt système spécialisé avec une expertise du domaine. Un agent sécurité connaît le Top 10 OWASP. Un agent React comprend les règles des hooks. Cette spécialisation améliore dramatiquement la qualité de détection.

Mais voici la clé : les règles déterminent quel agent gère quoi.

- id: react_useeffect_cleanup
  agent: react              # Géré par le spécialiste React
  match:
    file_glob: ["**/*.tsx"]
    content_regex: ["useEffect"]
  checklist:
    - "Vérifier si useEffect retourne une fonction de cleanup"
    - "Vérifier que les event listeners et subscriptions sont nettoyés"

Cette règle va uniquement à l'agent React, uniquement pour les fichiers TSX, uniquement quand useEffect est présent. L'agent reçoit un contexte focalisé sur exactement une chose — pas 50 préoccupations différentes en compétition pour l'attention.

3. Curation du Contexte : Le Secret pour Ne Pas Diluer l'Attention de l'IA

Les LLMs modernes peuvent gérer 200k+ tokens. Mais la recherche montre que la performance pratique atteint un plafond autour de 25-30k tokens pour le raisonnement complexe. Au-delà, vous payez pour des tokens que le modèle ne peut pas utiliser efficacement.

Le système de gestion de contexte de diffray garantit que chaque agent reçoit précisément les informations dont il a besoin :

Chaque agent obtient exactement ce dont il a besoin pour faire son travail. Pas plus. Le résultat : attention focalisée, meilleurs résultats, moins de faux positifs.

4. Flexibilité : Règles Spécifiques au Projet et à l'Équipe

C'est là que les règles brillent vraiment pour les équipes. Chaque base de code a des conventions que les outils génériques ne connaissent pas :

Vos bibliothèques internes :

- id: use_internal_http_client
  agent: consistency
  title: "Utiliser le wrapper HTTP client interne"
  match:
    file_glob: ["src/**/*.ts"]
    content_regex: ["\\bfetch\\(", "axios\\."]
  checklist:
    - "Trouver les appels fetch() ou axios bruts"
    - "Vérifier si le code devrait utiliser httpClient de @/lib/http-client"
  examples:
    bad: |
      const response = await fetch('/api/users');
    good: |
      import { httpClient } from '@/lib/http-client';
      const data = await httpClient.get('/api/users');

Vos patterns spécifiques au domaine :

- id: money_use_decimal
  agent: bugs
  title: "Utiliser Decimal pour les valeurs monétaires"
  match:
    content_regex: ["(price|amount|total)\\s*:\\s*(number|float)"]
  checklist:
    - "Trouver les champs monétaires utilisant les types float/number"
    - "Vérifier que le stockage utilise des cents (integer) ou le type Decimal"

Vos exigences de conformité :

- id: pii_logging_check
  agent: compliance
  title: "Ne jamais logger les PII directement"
  tags: [compliance-gdpr, compliance-hipaa]
  match:
    content_regex: ["log.*(email|phone|ssn|password)"]

Déposez-les dans .diffray/rules/ et ils sont actifs sur le prochain PR. Pas de changements d'infrastructure, pas de mises à jour d'outils — ajoutez juste du YAML et votre réviseur IA apprend vos standards.

Pourquoi YAML ? La Structure Permet l'Intelligence

Vous vous demandez peut-être pourquoi nous utilisons du YAML structuré au lieu de simples prompts. La structure permet des capacités que les prompts libres ne peuvent pas offrir :

Un prompt plat ne peut pas fournir cette séparation des préoccupations.

Le Résultat : Un Code Review IA Qui Fonctionne Vraiment

Quand vous combinez des règles structurées avec une architecture multi-agent et une gestion intelligente du contexte, vous obtenez :

C'est ce qui fait la différence entre « code review IA » comme démo et code review IA comme infrastructure sur laquelle votre équipe compte vraiment.