~10 min de lecture

Migrer tes @Input vers les signals avec un agent IA : pourquoi le prompt "migre tout" te laisse un bug que tu ne peux plus revert

TL;DR

  • Migrer tout ton repo vers input() en un prompt d'agent, ça marche : un diff de plusieurs milliers de lignes, qui compile, que personne ne relira, et où des décisions de comportement sont prises en silence.
  • Le mécanique a déjà son outil déterministe, un schematic (un script de migration livré avec Angular, lancé par ng generate) : @angular/core:signal-input-migration et ses équivalents output et queries, depuis la v19. Il fait le gros du volume et, surtout, saute ce qu'il ne sait pas migrer sans changer le comportement.
  • Ce reliquat, inputs réécrits dans la classe, setters qui cachent de la logique, est le vrai travail de l'agent : chaque cas demande une décision, pas une transformation. La méthode : schematic d'abord ; agent sur le reliquat, un pattern à la fois ; tranches vérifiées par le build et les tests, verrouillées par un lint.

Le lundi matin qu'on ne peut plus revert

Ton repo a 140 composants, 18 mois d'historique, et le mélange habituel : le récent en input(), l'ancien en @Input(). Un lundi matin motivé, tu tapes le prompt qui semble évident :

Migre tous les @Input et @Output du repo vers input() et output().

Vingt minutes plus tard : 112 fichiers modifiés, 3 800 lignes de diff. Ça compile. Les tests passent. Tu merges, parce que relire 3 800 lignes de transformations prétendument mécaniques, personne ne le fait.

Trois semaines plus tard, un ticket : le panneau de détail ne se replie plus quand on change de commande. Un @Input() expanded que le composant réécrivait localement a été migré vers un pattern qui ne se réinitialise plus quand le parent pousse une nouvelle valeur. L'agent a pris une décision de sémantique, tout seul, à la ligne 2 714 d'un diff que personne n'a lu. Et le revert n'est plus une option : quinze merges sont passés par-dessus.

Le problème n'est pas que l'agent soit mauvais. Le problème est que tu lui as confié deux travaux très différents dans le même prompt : un travail de transformation mécanique, où il est moins bon qu'un outil déterministe, et un travail de décision cas par cas, où il est utile mais doit être relu. Mélangés, les deux se sabotent.

Pourquoi le big-bang par agent (tout migrer d'un coup) échoue

1. Tu paies un LLM pour un travail d'AST (l'arbre syntaxique de ton code). @Input() user!: User qui devient readonly user = input.required<User>(), les lectures qui deviennent des appels, le template mis à jour : de la transformation d'arbre, déterministe par nature. Un agent qui refait ça à la main peut produire trois styles différents selon le fichier, et chaque variation est du diff en plus à relire.

2. Le diff dépasse ta capacité de revue. La revue est le seul point de contrôle qui attrape une décision de comportement prise en silence : ces décisions-là compilent, et passent souvent les tests existants. Au-delà de quelques centaines de lignes, tu relis par échantillonnage, et l'échantillonnage rate exactement ce qui est rare. Un agent reviewer n'y verra pas mieux : lui aussi lit un diff, pas ton produit.

3. Le reliquat est fait de décisions, pas de transformations. Un input que la classe réécrit n'a pas de traduction automatique : il faut choisir une sémantique. Noyées au milieu de 3 000 lignes mécaniques, ces décisions existent toujours, mais c'est l'agent qui les prend, et toi qui les découvres en production.

La parade : chaque outil sur le travail pour lequel il est bon.

Temps 1 : le schematic d'abord

Depuis Angular 19, le framework livre les migrations signals en schematics, exécutables sur un sous-arbre du repo :

ng generate @angular/core:signal-input-migration --path src/app/orders
ng generate @angular/core:output-migration --path src/app/orders
ng generate @angular/core:signal-queries-migration --path src/app/orders

# ou les trois en une passe :
ng generate @angular/core:signals --path src/app/orders

Le schematic réécrit la déclaration, mais aussi les lectures de l'input, du moins celles que son analyse voit : la classe, le template, les host bindings. C'est déterministe : deux exécutions produisent le même diff, et ce diff a un seul style.

"Celles que son analyse voit" : c'est ton premier piège. La migration ne regarde que les fichiers des tsConfig déclarés par tes cibles, et la cible test d'un workspace récent n'en déclare souvent aucun. Tes specs ne sont alors pas migrées, et ta CI peut virer au rouge. Déclare "tsConfig": "tsconfig.spec.json" sur ta cible test avant de lancer quoi que ce soit ; les angles morts de ces migrations ont leur propre article.

La vraie qualité du schematic, celle qui structure toute la méthode, c'est qu'il refuse de deviner. Un input réécrit, par exemple, n'est pas migré :

@Component({
  selector: 'app-order-panel',
  changeDetection: ChangeDetectionStrategy.OnPush,
  /* ... */
})
export class OrderPanel {
  @Input() order!: Order;      // migrated
  @Input() expanded = false;   // skipped: written to in toggle()

  toggle(): void {
    this.expanded = !this.expanded;
  }
}

order ressort en readonly order = input.required<Order>(), order.id devenant order().id jusque dans le template. expanded reste un décorateur, parce qu'un signal input est en lecture seule : le migrer impose de choisir où vit l'état local, et ce choix change le comportement. Avec l'option --insert-todos, le schematic marque chaque cas sauté d'un commentaire qui explique pourquoi : "Your application code writes to the input. This prevents migration." pour un input réécrit, "Accessor inputs cannot be migrated as they are too complex." pour un setter. Attention : "application code" couvre tout le programme analysé, specs comprises. Un test qui fait component.order = ... suffit à déclencher ce TODO sur un input que la classe, elle, ne touche jamais.

Il existe aussi un --best-effort-mode, qui convertit quand même les inputs réécrits, sans trancher où vit l'état local : l'affectation devient une écriture dans un signal en lecture seule, et ton build casse (TS2540). Les setters, eux, restent sautés même dans ce mode. Évite-le : tu échanges une liste propre de cas à décider contre du code cassé à réparer à la main.

Commite ce diff seul : mécanique, un seul style, relecture rapide. Il te reste la liste des cas à décider : les TODO posés sur les inputs et les queries, plus les @Output() sautés, que output-migration ne marque pas (pas de --insert-todos chez lui). Ceux-là se retrouvent au grep. C'est le cahier des charges de l'agent.

Temps 2 : l'agent sur le reliquat, un pattern à la fois

Reste les cas où le schematic a eu la sagesse de s'abstenir. Deux patterns reviennent plus que les autres.

L'input réécrit : linkedSignal, et une sémantique à assumer

// Before
@Input() expanded = false;

toggle(): void {
  this.expanded = !this.expanded;
}
// After
readonly expanded = input(false);
protected readonly isExpanded = linkedSignal(() => this.expanded());

toggle(): void {
  this.isExpanded.update((open) => !open);
}

Le template passe de expanded à isExpanded(). Et surtout : linkedSignal (stable depuis Angular 20) se réinitialise quand l'input change de valeur. C'est la sémantique du décorateur : quand le parent pousse une nouvelle valeur d'expanded, par exemple s'il le fait passer de true à false, elle écrase l'état local ; une valeur identique à la précédente ne déclenche rien. Un signal(false) local alimenté une seule fois aurait l'autre sémantique, celle du bug du lundi matin. Et si le panneau doit se replier à chaque nouvelle commande, même quand expanded ne bouge pas, ajoute la commande en source : linkedSignal({ source: this.order, computation: () => this.expanded() }) se réinitialise à chaque nouvelle référence d'order. Comportement différent du décorateur, à assumer.

Tu viens de prendre une décision de comportement. C'est pour ça que ce code ne pouvait pas sortir d'un schematic, et c'est exactement ce que tu veux voir isolé dans un petit diff plutôt qu'enterré dans un gros.

Le setter avec logique : ça dépend de ce que le setter faisait

// Before
private _query = '';

@Input() set query(value: string) {
  this._query = value.trim();
  this.applyFilter(this._query);
}

Un setter, c'est trois intentions possibles, et trois traductions différentes :

  • il normalise la valeur : c'est un transform ;
  • il dérive un état : c'est un computed() sur l'input, et la propriété privée disparaît ;
  • il déclenche un travail (filtre, fetch, tracking) : c'est le cas piégeux. Le réflexe effect() reproduit à peu près le comportement, avec un timing différent, mais effect() utilisé pour propager de l'état a ses propres pièges ; si le travail est un appel HTTP, la bonne cible est plutôt un resource (stable en v22). Autrement dit : une décision d'architecture, pas une transformation.

Le setter ci-dessus cumule d'ailleurs le premier et le troisième cas, et c'est fréquent, d'où la règle : un setter se lit avant de se traduire. Le trim devient un transform :

// After (the normalizing part)
readonly query = input('', { transform: (value: string) => value.trim() });

L'appel à applyFilter, lui, se décide selon ce qu'il fait vraiment.

C'est ici que l'agent gagne sa place : il lit le setter, classe le cas, propose la traduction. Mais tu ne lui donnes pas "migre le reliquat". Tu lui donnes un brief par pattern et par périmètre :

Dans src/app/orders, traite uniquement les TODO "Your application code
writes to the input" laissés par signal-input-migration. Pour chaque TODO,
cherche d'abord où a lieu l'écriture. Si elle n'est que dans une spec,
corrige la spec avec fixture.componentRef.setInput(...), relance le
schematic, puis supprime le TODO devenu obsolète. Si elle est dans la classe, applique le pattern input() +
linkedSignal, nom du signal local en isXxx, et écris dans le message de
commit la sémantique choisie et pourquoi. Un commit par composant.
Interdiction de toucher à autre chose que ces fichiers et leurs specs.
Après chaque commit : ng build, ng test, ng lint.

Un agent cadré comme ça produit des commits d'une trentaine de lignes, chacun portant une décision visible et justifiée. Les setters passent dans le brief suivant.

Temps 3 : des tranches, des gates, un cliquet

Reste à ne pas refaire le big-bang en plus lent. Trois règles :

Une tranche = un dossier, une PR. Tu découpes par feature (src/app/orders, puis src/app/catalog...), via le --path du schematic et le périmètre du brief. Une PR par tranche, relisible en un quart d'heure, mergeable indépendamment. Si une tranche tourne mal, elle se revert seule.

Des gates entre chaque étape, des contrôles qui doivent passer avant d'aller plus loin : le build, les tests et le lint, lancés par l'agent lui-même après chaque commit, non négociable dans le brief. Le build, pas un tsc --noEmit : tsc ne vérifie pas les templates, là même où la migration réécrit les lectures. Un agent qui ne peut pas vérifier son travail te rend du code plausible ; un agent qui compile et teste te rend du code vérifié.

Un cliquet par tranche migrée. Un cliquet, c'est un verrou qui ne laisse tourner que dans un sens. Une fois src/app/orders au vert, verrouille-le pour que ni un collègue ni le prochain agent n'y réintroduise un @Input() ou un @Output(). Pas besoin de plugin : une règle ESLint no-restricted-syntax, dans un override limité aux dossiers migrés, suffit.

// eslint.config.js: one more entry in the config array
{
  files: ['src/app/orders/**/*.ts'],
  rules: {
    'no-restricted-syntax': [
      'error',
      {
        selector: "Decorator > CallExpression > Identifier[name=/^(Input|Output)$/]",
        message: 'Dossier migré : utilise input() / output().',
      },
    ],
  },
},

Le cliquet transforme ta migration en phénomène monotone : ça ne peut qu'avancer. Chaque dossier verrouillé est un dossier cohérent, et le pattern majoritaire que ton prochain agent imitera bascule à mesure que les tranches avancent.

Before / after : le même lundi matin

Avant. Un prompt, 3 800 lignes, 112 fichiers, une revue par échantillonnage, une sémantique changée en silence, un bug trois semaines plus tard, et plus de revert possible.

Après. Par tranche : un commit schematic purement mécanique, relu en diagonale ; des commits d'agent d'une trentaine de lignes, chacun avec sa décision écrite dans le message ; une PR de quelques centaines de lignes dont tu as réellement lu la partie qui pense ; un override ESLint qui verrouille. Même agent, même repo, même semaine : seule la répartition du travail a changé.

Récap actionnable

  • Ne confie jamais à un agent ce qu'un schematic fait de façon déterministe : ng generate @angular/core:signal-input-migration (v19 minimum), plus output-migration et signal-queries-migration, ou @angular/core:signals pour les trois.
  • Avant tout, déclare "tsConfig": "tsconfig.spec.json" sur ta cible test : sinon tes specs ne sont pas migrées.
  • Lance le schematic avec --path sur une feature et --insert-todos, et commite ce diff seul. Les @Output() sautés n'ont pas de TODO : complète la liste au grep.
  • Évite --best-effort-mode : il convertit les inputs réécrits sans trancher où vit l'état local, et te laisse un build cassé (TS2540) au lieu d'une liste de cas à décider.
  • Brief par pattern pour l'agent : écriture venue d'une spec, corriger la spec (setInput) et relancer le schematic ; input réécrit par la classe vers input() + linkedSignal (stable v20) ; setter vers transform, computed(), effect() ou resource selon l'intention. Un commit par composant, la décision justifiée dans le message.
  • Les gates dans le brief : build, tests et lint après chaque commit, lancés par l'agent.
  • Le cliquet : un override ESLint no-restricted-syntax qui rejette @Input() et @Output() dans chaque dossier migré.
  • Une tranche = un dossier = une PR. Si tu ne peux pas la relire en quinze minutes, ta tranche est trop grosse.

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