~10 min de lecture

Ton agent IA code du Angular de 2022 : 6 tells qui le trahissent, 3 leviers pour le recadrer

TL;DR

  • Un agent de code ne sort pas "du Angular" : il sort le Angular le plus probable de son corpus d'entraînement. Un corpus très probablement dominé par des années de tutoriels d'avant la v17.
  • Six tells, au sens du poker (le tic qui trahit le jeu de l'adversaire), signalent ce code périmé : *ngIf/*ngFor, l'injection par constructeur, @Input()/@Output(), standalone: true explicite (voire un NgModule), une stratégie de change detection écrite à la main (le tell qui s'est inversé en v22), les suffixes Component.
  • Les recadrages qui marchent ne sont pas des incantations ("écris du Angular moderne") mais trois leviers : un contexte qui fige la version et liste les rejets réflexes, la doc à jour injectée dans son contexte (llms.txt, ng mcp), et des règles mécanisées relancées à chaque itération.

Le diff qui sent le réchauffé

Ton repo est propre : Angular 22, signals partout, control flow natif, zéro NgModule. Tu demandes à ton agent un composant de badge de statut, trois états, rien d'exotique. Il te livre ça :

// status-badge.component.ts
import { Component, Input } from '@angular/core';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'app-status-badge',
  standalone: true,
  imports: [CommonModule],
  template: `
    <span class="badge" *ngIf="status === 'active'">Active</span>
    <span class="badge badge-warn" *ngIf="status === 'pending'">Pending</span>
    <span class="badge badge-off" *ngIf="status === 'disabled'">Disabled</span>
  `,
})
export class StatusBadgeComponent {
  @Input() status: 'active' | 'pending' | 'disabled' = 'active';
}

Ça compile. Ça marche. Et c'est du Angular de 2022, posé au milieu d'une codebase qui n'en contient pas une ligne.

Si tu as lu l'article sur les conventions de codebase, tu sais qu'un agent imite le pattern majoritaire de ton repo, et qu'un repo propre suffit le plus souvent : le modèle connaît très bien input() et le control flow quand tes fichiers les lui montrent. Le plus souvent seulement. Quand il crée un fichier sans précédent proche, il n'a rien à imiter chez toi, et c'est l'autre force qui parle : son prior, ce qu'il tient pour normal avant d'avoir lu une ligne de ton code, hérité de son corpus d'entraînement.

Pourquoi il fait ça (et pourquoi ce n'est pas un bug)

Un LLM s'entraîne sur un instantané du web. Or Angular a eu deux vies. La première, de 2016 à 2023 : NgModules, décorateurs, zone.js, RxJS partout. La seconde, depuis la v16-v17 : signals, standalone devenu la norme, control flow natif, zoneless. La première vie a eu sept ans pour remplir internet. La seconde est récente, et une partie s'est écrite après la date de coupure du modèle, celle au-delà de laquelle il n'a plus rien lu.

Résultat : quand l'agent improvise, il retombe sur la forme qu'il a le plus vue. Ce n'est pas de la mauvaise volonté, c'est très probablement de la simple statistique. Ton repo tire dans un sens, son corpus tire dans l'autre, et sur du code neuf sans existant à imiter (du greenfield), c'est souvent le corpus qui gagne.

Bonne nouvelle : ce biais est prévisible, donc détectable, donc corrigeable. Commence par le détecter.

Les 6 tells à rejeter au premier regard

Chacun de ces tells est un marqueur daté, mais ils ne cassent pas tous pareil. Le NgModule du tell 4, écrit à l'ancienne sans standalone: false, ne compile plus en v22 (NG6008) : lui au moins s'arrête avant la revue. Le *ngIf du tell 1 posé sans importer NgIf ni CommonModule compile et n'affiche rien, la CLI se contentant d'un avertissement (NG8103). Les quatre autres ne cassent rien, et c'est bien le piège : le code marche, la revue passe, et ta codebase accumule un deuxième dialecte que le prochain agent imitera à son tour.

1. *ngIf / *ngFor, et l'import CommonModule qui les accompagne

Le control flow natif (@if, @for, @switch) est arrivé en v17 en developer preview et est stable depuis la v18. Un agent qui sort *ngIf en 2026 te signale qu'il puise dans son corpus, pas dans ta doc : NgIf est officiellement déprécié depuis la v20. Encore plus parlant : l'import entier de CommonModule pour une seule directive structurelle, réflexe de tutoriel d'époque.

2. L'injection par constructeur

constructor(private readonly http: HttpClient) {}

Depuis la v14, inject() s'utilise aussi dans les composants et les directives, et c'est la forme que recommande le style guide actuel : elle se lit mieux, infère mieux les types, et marche dans les contextes fonctionnels (guards, interceptors) où un constructeur n'existe pas. L'injection par constructeur n'est pas cassée, elle est datée. Sur du code neuf, c'est un tell.

3. @Input() et @Output()

Les inputs signal (input(), input.required()) et output() sont stables depuis la v19. La différence n'est pas cosmétique : un input() est un signal, donc il se branche directement dans computed() et linkedSignal() sans ngOnChanges ni setter intermédiaire. Un agent qui pose un @Input() dans un composant par ailleurs plein de signals te fabrique une frontière morte entre deux mondes réactifs.

4. standalone: true explicite, ou pire, un NgModule

standalone: true est le défaut depuis la v19 : l'écrire encore est du bruit qui signale un modèle resté en arrière. Et si l'agent te génère un SharedModule pour y déclarer ton badge, tu n'es plus face à un tell mais à une excavation archéologique. Refuse le diff entier, le reste est du même tonneau.

5. Une stratégie de change detection écrite à la main

Celui-ci a changé de sens avec la v22 : le piège parfait pour un prior daté. Jusqu'à la v21, le tell était l'absence de ChangeDetectionStrategy.OnPush. Depuis la v22, OnPush est le défaut, et le tell s'inverse : un changeDetection: ChangeDetectionStrategy.OnPush explicite est du bruit, comme le standalone: true du tell 4, et un ChangeDetectionStrategy.Default (alias déprécié d'Eager) posé sans raison écrite est un opt-out qui te ramène au monde d'avant. Les bonnes pratiques embarquées dans la CLI le disent noir sur blanc : ne pose plus OnPush explicitement en v22+. Deux cas échappent pourtant au tell : l'OnPush exigé par une convention écrite du repo (une décision, pas un réflexe), et les Eager d'un projet monté en v22, posés par ng update sur les composants sans stratégie, pas par un agent. Pour le reste, une stratégie écrite à la main dans un diff d'agent mérite une question.

6. Les suffixes Component et .component.ts

Le style guide révisé avec la v20 abandonne les suffixes : classe StatusBadge dans status-badge.ts, pas StatusBadgeComponent dans status-badge.component.ts (et ng generate suit ce défaut). C'est le tell le plus bénin, mais c'est celui qui se voit dans l'arborescence avant même que tu ouvres le fichier.

Les 3 leviers qui recadrent vraiment

Dire "écris du Angular moderne" dans ton prompt ne marche pas : "moderne" n'a aucun sens pour un modèle dont le corpus s'arrête quelque part, et la consigne s'évapore dès que le contexte se compacte (quand l'agent résume la conversation pour libérer de la place). Ce qui marche, c'est ce qui est précis, persistant et vérifiable. Les leviers 1 et 3 prolongent les conventions 5 et 6 de l'article sur les conventions : même mécanique, appliquée ici à la version. Le levier 2 est le seul propre au prior.

Levier 1 : un contexte qui fige la version et liste les rejets

Ton fichier d'instructions (CLAUDE.md, AGENTS.md ou équivalent) doit contenir deux choses : la version exacte, et la liste des formes interdites. Pas une dissertation, une liste de rejets réflexes :

## Angular

Target: Angular 22. Reject on sight in your own output:

- `*ngIf` / `*ngFor` / `*ngSwitch` -> native control flow `@if` / `@for` / `@switch`
- constructor injection -> `inject()`
- `@Input()` / `@Output()` -> `input()` / `output()`
- `standalone: true` (default since v19) and any `NgModule`
- explicit `changeDetection: ChangeDetectionStrategy.OnPush` (default since v22)
  and any `Eager` / `Default` opt-out without a written reason
- `Component` / `Directive` class suffixes and `.component.ts` file suffixes

La formulation "reject on sight in your own output" compte : tu donnes un critère binaire que l'agent applique à sa propre sortie avant de te la montrer. D'expérience, et sans mesure à l'appui, une liste de rejets est mieux suivie qu'une liste de recommandations. C'est la convention "écris les décisions, pas la doc" appliquée au prior : ici, la décision, c'est la version.

Levier 2 : la doc à jour dans son contexte

Le prior du modèle date ? Donne-lui une source plus fraîche que son corpus. Angular en publie plusieurs, des fichiers de règles par IDE au best-practices.md téléchargeable ; deux canaux font l'essentiel du travail.

Le premier : angular.dev expose un llms.txt (un index des pages clés) et un llms-full.txt (un jeu de ressources compilé, bien plus gros). Référence le premier dans tes instructions, ou télécharge le second dans ton repo pour les agents sans accès réseau.

Le second : la CLI embarque un serveur MCP (Model Context Protocol, le protocole standard par lequel un agent appelle des outils externes) depuis la v20.1, ng mcp. La doc le présente encore comme expérimental ; ses outils sont pourtant stables dans la CLI 22. Son outil get_best_practices lit le guide de bonnes pratiques embarqué dans le @angular/core installé dans ton repo : la réponse vient de ton node_modules, pas de 2022. C'est lui qui dira à ton agent de ne plus poser OnPush en v22. L'outil search_documentation, lui, interroge l'index en ligne d'angular.dev, aligné sur la version majeure que l'agent lui indique : au lieu de deviner une API à partir de son corpus, l'agent lit la doc de la version qu'il annonce.

Levier 3 : des règles, pas des consignes

Le levier le plus fiable : une consigne de prompt finit par disparaître du contexte, une règle ESLint est relancée à chaque itération. Avec les bonnes règles, angular-eslint couvre cinq des six tells, le tell 4 dans sa seule moitié NgModule. Côté TypeScript :

// eslint.config.js (extract)
rules: {
  '@angular-eslint/prefer-inject': 'error',             // constructor injection
  '@angular-eslint/prefer-signals': 'error',            // @Input()
  '@angular-eslint/prefer-output-emitter-ref': 'error', // @Output()
  '@angular-eslint/prefer-standalone': 'error',         // NgModule (flags standalone: false)
  '@angular-eslint/prefer-on-push-component-change-detection':
    ['error', { allowExplicitOnPush: false }],          // opt-outs + redundant explicit OnPush
},

Côté templates, @angular-eslint/template/prefer-control-flow, déjà incluse dans la config templateRecommended, signale les *ngIf et *ngFor. Un composant déclaré dans un NgModule doit porter standalone: false pour compiler : prefer-standalone attrape donc tout NgModule qui déclare un composant et compile, NG6008 ayant déjà arrêté l'autre. Et prefer-on-push-component-change-detection ne signale par défaut que les opt-outs : son option allowExplicitOnPush: false lui fait aussi voir l'OnPush explicite redondant, que --fix retire tout seul. Si ton repo relève d'un des deux cas qui échappent au tell 5, adapte : garde allowExplicitOnPush au défaut tant que la convention OnPush tient, et retire les Eager de migration à la main, composant par composant, en vérifiant que chacun tient en OnPush, car aucune migration officielle ne le fait ; d'ici là, garde la règle en warn. Restent le standalone: true redondant et les suffixes : pour ces deux-là, c'est ta liste de rejets du levier 1 qui travaille.

Branche le lint dans la boucle de l'agent (il doit le lancer avant de conclure, et la CI le relance derrière), et le recadrage devient automatique : l'agent produit du @Input(), le lint hurle, l'agent corrige, tu n'as rien relu. Un garde-fou mécanisé est un reviewer qui ne dort jamais, et sa sortie coûte quelques lignes d'erreur là où une consigne occupe le contexte en permanence.

Before / after : le même prompt, le harnais en place

Même demande, mais avec le contexte versionné, la liste de rejets et le lint branchés :

// status-badge.ts
import { Component, input } from '@angular/core';

type Status = 'active' | 'pending' | 'disabled';

@Component({
  selector: 'app-status-badge',
  template: `
    @switch (status()) {
      @case ('active') { <span class="badge">Active</span> }
      @case ('pending') { <span class="badge badge-warn">Pending</span> }
      @case ('disabled') { <span class="badge badge-off">Disabled</span> }
    }
  `,
})
export class StatusBadge {
  readonly status = input.required<Status>();
}

Zéro import superflu, un @switch qui dit "états exclusifs" là où trois *ngIf disaient "peut-être plusieurs à la fois", un input requis typé au lieu d'un défaut arbitraire, et pas une ligne de bruit : ni standalone: true ni changeDetection explicite ; les défauts de la v22 travaillent pour toi. Ce n'est pas l'agent qui est devenu intelligent entre les deux : c'est toi qui as remplacé son prior par ton harnais.

Récap actionnable

  1. Apprends les 6 tells : *ngIf/*ngFor + CommonModule, injection par constructeur, @Input()/@Output(), standalone: true ou NgModule, stratégie de change detection écrite à la main, suffixes Component. Un seul tell dans un diff d'agent impose une relecture complète : il arrive rarement seul.
  2. Fige la version dans tes instructions avec une liste de rejets réflexes formulée en "reject on sight", pas en recommandations.
  3. Injecte de la doc plus fraîche que son corpus : llms.txt d'angular.dev en référence, ng mcp (CLI v20.1+) pour les bonnes pratiques de la version installée et la doc de la version que l'agent lui indique.
  4. Mécanise avec angular-eslint : prefer-inject, prefer-signals, prefer-output-emitter-ref, prefer-standalone et prefer-on-push-component-change-detection (avec allowExplicitOnPush: false) en error, plus template/prefer-control-flow côté templates, et le lint dans la boucle de l'agent, pas seulement en CI. Le lint ne voit ni le standalone: true superflu ni les suffixes : ta liste de rejets s'en charge.
  5. Nettoie l'existant avec les migrations officielles (control-flow-migration, inject-migration, signal-input-migration, output-migration) : un repo sans dialecte legacy est la meilleure instruction, parce que c'est celle que l'agent retrouve dans chaque fichier qu'il ouvre. L'article sur les conventions détaille pourquoi une migration à moitié faite est pire que pas de migration.

Le prior d'un modèle, tu ne le changeras pas. Son environnement, si. Et entre les deux, c'est toujours l'environnement qui a le dernier mot, parce qu'il parle après le prior.

📧 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.