~9 min de lecture

Revue de code par agent IA : 3 bugs Angular qu'il attrape avant toi, 3 angles morts qui restent à toi

TL;DR

Un agent reviewer est redoutable sur les bugs dont la preuve tient dans le texte du diff : mutation d'un signal en place, effect qui fait le travail d'un computed, track $index sur des données serveur. Il est structurellement aveugle à tout ce dont la preuve vit ailleurs : l'intention produit et le comportement réel à l'exécution. Et quand ses findings (les remarques qu'il remonte) sont faux, ils sortent avec le même aplomb que les vrais. La revue assistée fonctionne quand tu cadres le périmètre, donnes à l'agent de quoi exécuter, et traites chaque finding comme une hypothèse, pas comme un verdict.

Ton équipe a mis un agent de code en reviewer sur ses PR Angular. Trois semaines plus tard, elle s'est coupée en deux camps : ceux qui mergent sur la foi de l'"APPROVED" de l'agent sans relire, et ceux qui ont arrêté de lire les pavés de quinze findings. Les deux camps se trompent sur la même chose : ce qu'un agent reviewer peut réellement prouver.

Cet article trace la ligne de partage : quels bugs sont du côté de l'agent, lesquels restent du tien, et comment écrire la demande de revue pour que chacun fasse sa part.

Ce qu'un agent reviewer voit vraiment

D'abord, ce que l'agent a réellement sous les yeux, parce que tout découle de là. Un agent en mode revue (Claude Code, Cursor, peu importe l'outil) fait trois choses : il lit le diff, il ouvre les fichiers autour pour comprendre le contexte, et, si tu lui en donnes les moyens, il lance des commandes (tests, lint, build) et lit leur sortie. C'est tout. Il n'a pas vu le ticket d'origine, pas assisté au daily où le comportement attendu s'est négocié, pas lancé ton app pour cliquer dedans, sauf invitation explicite.

D'où la ligne de partage : quand la preuve d'un bug est entièrement contenue dans le texte du code, l'agent est sur son terrain, souvent meilleur que toi parce qu'il ne fatigue pas à la quarantième ligne du diff. Quand la preuve vit à l'exécution ou dans une tête humaine, il extrapole. Et il extrapole avec le même ton assuré que quand il prouve.

Les 3 bugs qu'il attrape avant toi

1. La mutation en place d'un signal

Le grand classique du diff qui a l'air innocent :

import { Injectable, computed, signal } from '@angular/core';
import { Invoice } from './invoice';

@Injectable({ providedIn: 'root' })
export class InvoiceStore {
  readonly invoices = signal<Invoice[]>([]);
  readonly total = computed(() =>
    this.invoices().reduce((sum, invoice) => sum + invoice.amount, 0),
  );

  add(invoice: Invoice): void {
    this.invoices.update((list) => {
      list.push(invoice); // same reference returned
      return list;
    });
  }
}

L'égalité par défaut d'un signal repose sur Object.is : si ton update retourne la même référence, le signal considère que rien n'a changé et ne notifie aucun de ses dépendants. Ici, total ne se recalcule plus. Le piège, c'est que selon ton mode de change detection, la liste affichée peut continuer à se mettre à jour en apparence (le tableau muté contient bien la nouvelle facture), pendant que le computed reste figé. Un bug qui ne touche qu'une partie de l'écran, c'est des heures de debug.

Un agent repère ce pattern sans effort quand il est sous ses yeux : un update qui mute et retourne son argument, la preuve tient dans ces quelques lignes. Le correctif aussi :

add(invoice: Invoice): void {
  this.invoices.update((list) => [...list, invoice]);
}

Pour creuser, on a disséqué comment l'égalité d'un signal décide de qui est notifié.

2. L'effect qui fait le travail d'un computed

Deuxième pattern que l'agent repère très bien quand l'écriture est visible dans le diff, parce qu'il se reconnaît à la forme :

// Before: an effect to keep derived state in sync
readonly filter = signal('');
readonly invoices = signal<Invoice[]>([]);
readonly filtered = signal<Invoice[]>([]);

constructor() {
  effect(() => {
    this.filtered.set(
      this.invoices().filter((i) => i.ref.includes(this.filter())),
    );
  });
}

Trois problèmes, tous visibles dans le texte. filtered est un signal modifiable : n'importe qui peut écrire dedans et casser l'invariant (filtered = invoices filtrées par filter). L'effect ne tourne pas au moment où tu écris dans filter : il est planifié et s'exécute plus tard, donc il existe une fenêtre où filtered est désynchronisé de sa source. Et depuis Angular 19, écrire dans un signal depuis un effect ne lève plus d'erreur par défaut (avant, il fallait allowSignalWrites), donc plus rien ne te signale le détournement.

// After: derived state is a computed
readonly filter = signal('');
readonly invoices = signal<Invoice[]>([]);
readonly filtered = computed(() =>
  this.invoices().filter((i) => i.ref.includes(this.filter())),
);

Synchrone, lazy, en lecture seule. Et pour le cas légitime "dérivé mais localement modifiable" (une sélection qui se réinitialise quand la liste change), c'est linkedSignal, stable depuis Angular 20. Les autres détournements d'effect sont catalogués dans les pièges d'effect.

3. track $index sur des données serveur

@for (invoice of invoices(); track $index) {
  <app-invoice-row [invoice]="invoice" />
}

Tant que la liste ne fait que grandir par la fin, rien ne se voit. Supprime le premier élément, et Angular, qui identifie chaque nœud DOM par sa position, réassocie les lignes existantes aux nouvelles données : tout état local au DOM (un accordéon ouvert, un champ de saisie non lié, un focus) reste attaché à la position et se retrouve sur la mauvaise facture. La correction : track invoice.id, un identifiant métier stable.

C'est le finding parfait pour un agent : détectable au grep, corrigeable mécaniquement, facile à rater pour un humain, puisque le symptôme n'apparaît qu'avec des manipulations que la démo ne fait pas. Le détail des dégâts est dans les erreurs de track qui reconstruisent ton DOM.

Ces trois bugs ont un point commun : le code seul suffit à établir le défaut. C'est la zone où déléguer la vigilance à un agent est un gain net.

Les 3 angles morts qui restent à toi

1. L'intention produit n'est pas dans le diff

readonly saveTrigger = new Subject<InvoiceDraft>();

constructor() {
  this.saveTrigger
    .pipe(
      switchMap((draft) =>
        this.api.save(draft).pipe(catchError(() => EMPTY)),
      ),
      takeUntilDestroyed(),
    )
    .subscribe();
}

Ce code compile, passe le lint et passe les tests. L'opérateur, lui, est impossible à juger depuis le diff. switchMap abandonne la sauvegarde précédente quand une nouvelle arrive, mais côté client seulement : le serveur a pu la recevoir et l'appliquer quand même. Avec deux sauvegardes rapprochées, l'ancienne peut s'appliquer après la récente, et le brouillon final est la version périmée. switchMap est fait pour les lectures où seule la dernière réponse t'intéresse (une recherche, un autocomplete). Reste une question que le diff ne tranche pas : ton API rejette-t-elle une version plus ancienne que celle qu'elle a déjà ? Si oui, switchMap passe ; sinon, il faut sérialiser avec concatMap. Et cette réponse n'est écrite nulle part dans le repo.

Un agent peut soulever la question, et un bon le fera. Mais demande-lui un verdict sans ce contexte, et il va en choisir un, puis l'affirmer. Le choix d'un opérateur de concurrence est une décision produit déguisée en décision technique : elle reste à toi, et l'agent n'en juge qu'avec l'intention écrite dans la demande.

2. Le finding plausible mais faux

L'angle mort le plus coûteux n'est pas ce que l'agent rate : c'est ce qu'il invente. Exemple de bruit récurrent en revue Angular : un agent qui signale une "fuite mémoire" sur ceci.

export class InvoiceDetail {
  private readonly http = inject(HttpClient);
  protected readonly invoice = signal<Invoice | null>(null);

  load(id: string): void {
    this.http.get<Invoice>(`/api/invoices/${id}`).subscribe((invoice) => {
      this.invoice.set(invoice);
    });
  }
}

Le finding arrive avec son correctif prêt à coller : "ajouter takeUntilDestroyed pour éviter la fuite". Sauf que l'observable d'HttpClient émet une fois puis se termine (complete) : dès la réponse reçue, l'abonnement est clos, et tant que chaque requête aboutit, rien ne s'accumule. Le vrai sujet est plus fin : sans désabonnement, une réponse qui arrive après la destruction du composant exécute quand même le callback, et une requête en cours n'est pas annulée. C'est un argument valable pour te désabonner à la destruction, avec takeUntilDestroyed alimenté par un DestroyRef injecté en champ, puisque load() est une méthode, hors contexte d'injection. Mais ce n'est pas une fuite mémoire, et le distinguo compte quand tu demandes à l'équipe de corriger "les fuites" en priorité.

Le danger du finding plausible mais faux, c'est qu'il est actionnable : le correctif proposé s'applique en dix secondes, tout le monde passe à autre chose, et le temps de revue est parti là, pas sur le vrai bug trois fichiers plus loin. La parade est une règle de lecture : un finding sans scénario d'échec concret (quelles entrées, quel état, quel comportement observable) n'est pas un bug, c'est une opinion.

3. Ce qui ne se prouve qu'à l'exécution

Un agent qui n'a fait que lire ne peut valider que la couche textuelle. Un écart d'hydratation SSR (le HTML rendu par le serveur ne correspond pas à ce que le client s'attend à trouver en reprenant la main), une course entre deux requêtes, un debounce qui tombe une frame trop tard, une régression de taille de bundle : la preuve de ces bugs n'existe que machine allumée. Si ton agent reviewer n'a lancé ni les tests, ni le build, ni l'app, son "APPROVED" signifie ceci : "je n'ai rien trouvé dans le texte". C'est une information utile, et c'est tout.

La conséquence pratique : donne-lui un terminal, et exige qu'il s'en serve. Et ce qu'il n'a pas pu exécuter, exige qu'il le liste au lieu de le fondre dans un verdict global.

Before/after : la demande de revue

La différence entre un agent bruyant et un agent utile tient moins au modèle qu'à la demande. Avant :

Review cette PR et dis-moi si c'est bon.

Résultat typique : quinze findings où une douzaine de remarques de style noient un ou deux vrais bugs, un verdict global invérifiable, et aucune exécution. Après :

Revue de la branche feature/invoice-autosave (diff vs main).

Contexte produit : autosave de brouillon. Les sauvegardes doivent
s'appliquer dans l'ordre d'envoi ; l'API ne les versionne pas.

1. Lance pnpm lint, pnpm test et pnpm build, et colle leur sortie
   dans le rapport.
2. Cherche en priorité : réactivité (signals, effects, equality),
   change detection OnPush, concurrence des requêtes.
3. Pour chaque finding : fichier:ligne, scénario d'échec concret
   (entrées, état, comportement observé), et ton niveau de confiance
   (prouvé dans le code / à vérifier à l'exécution).
4. Liste séparément ce que tu n'as pas pu vérifier sans lancer l'app.

Chaque consigne vise un angle mort. Le contexte produit donne à l'agent de quoi juger l'opérateur de concurrence : "l'ordre d'envoi compte" transforme le switchMap du diff en finding motivé, et non plus en opinion. L'exécution imposée couvre une couche que la lecture seule ne voit pas. Le scénario d'échec obligatoire filtre les findings plausibles mais faux. Et le niveau de confiance t'indique où ta relecture humaine doit se concentrer.

Dernier réglage, contre-intuitif : cadrer le périmètre, oui ; souffler la conclusion, non. "Vérifie que le store est correct" oriente l'agent, qui a une tendance documentée à confirmer ce qu'on lui suggère. Décris le symptôme ou la zone à couvrir, pas ton diagnostic.

Récap actionnable

  1. Trace la ligne de partage : preuve dans le texte = terrain de l'agent ; preuve à l'exécution ou dans une tête humaine = le tien. Ne délègue que le premier.
  2. Donne un terminal et exige les sorties : un rapport qui cite pnpm test, pnpm lint et pnpm build couvre une couche de plus qu'une lecture seule.
  3. Mets l'intention produit dans la demande : les choix de concurrence (switchMap, concatMap, ordre des écritures) sont des décisions produit que le diff ne contient pas.
  4. Un finding sans scénario d'échec est une opinion : exige entrées, état et comportement observable pour chaque bug annoncé.
  5. Ne souffle pas ta conclusion, décris le symptôme : un agent orienté confirme.
  6. Relis le verdict pour ce qu'il est : "APPROVED" d'un agent qui n'a rien exécuté veut dire "le texte est propre", pas "la PR est bonne".

Et si ton agent reviewer trouve trop de vrais bugs à ton goût, le problème n'est peut-être pas la revue : une codebase cohérente et mécanisée lui donne moins de prise, et on a détaillé comment y arriver dans les 7 conventions qui rendent un repo lisible par un agent.

📧 Reste informé(e) !

Reçois les derniers articles et conseils EasyAngularKit directement dans ta boîte mail.

S'inscrire gratuitement

AngularKit

Suite d'outils pour développeurs Angular francophones. Apprends, modernise tes réflexes, audite ta codebase.

Produits

Contact

Légal

© 2026 AngularKit. Tous droits réservés.