La boucle de rétroaction, c’est tout ce qui compte

Un modèle d’IA qui code tout seul n’est pas la partie intéressante. La partie intéressante, c’est ce qui se passe après qu’il a généré le code. À quelle vitesse le modèle peut-il savoir si son code est correct ? À quel point la boucle de rétroaction entre génération et validation est-elle serrée ?

Cette boucle détermine tout. Elle détermine si le modèle peut itérer sur sa propre sortie. Elle détermine si un humain peut faire confiance à la sortie sans inspection manuelle. Elle détermine dans quels domaines le codage assisté par IA fonctionne réellement.

La vitesse de la boucle n’est pas uniforme. Elle suit un spectre. Et ce spectre est déterminé par une vérité plus simple : l’IA est native du texte.

Le code backend est du texte. Les réponses API sont du texte. Les schémas de base de données sont du texte. L’ensemble du domaine est représenté sous forme de chaînes qu’un modèle de langage peut lire, générer et valider sans jamais quitter son médium natif. Même lorsque le backend implique des commandes en ligne de commande, ces commandes sont du texte. Le modèle n’a pas besoin de voir. Il a besoin de lire.

Les interfaces visuelles sont différentes. Une UI n’est pas une image statique. Elle est temporelle. Les états changent. Les animations font la transition. Les gestes déclenchent des cascades. Le modèle peut faire une capture d’écran d’un bouton, mais il ne peut pas ressentir le timing d’une pression. Il peut lire le CSS, mais il ne peut pas regarder la courbe d’easing se dérouler dans le temps. La correction visuelle est expérientielle, et l’expérience se produit dans le temps.

Backend : millisecondes

Le code backend se valide de manière déterministe. Une fonction a des entrées et des sorties. Un vérificateur de types vérifie le contract à la compilation. Une suite de tests exerce le comportement en millisecondes. Un endpoint API renvoie une réponse qui correspond à un schéma ou non. La migration de base de données s’applique proprement ou est annulée.

Chaque signal de validation est textuel, déterministe et rapide. Le modèle peut générer une fonction, exécuter le vérificateur de types, voir l’erreur et régénérer en quelques secondes. Il peut écrire un test, l’exécuter, voir l’échec et corriger l’implémentation. Le cycle d’itération est suffisamment serré pour que le modèle puisse fonctionner de manière semi-autonome dans une tâche backend délimitée.

C’est pourquoi le backend est le domaine où le codage assisté par IA semble le plus magique aujourd’hui. Le domaine est de la logique pure. La validation est instantanée. Le modèle sait quand il a tort — ce qui est exactement ce que les guardrails déterministes essaient d’apporter au reste de votre codebase.

Web : minutes

Le développement web ajoute la correction visuelle. Un composant peut avoir les bonnes props et le mauvais padding. Une mise en page peut passer tous les contrôles de type et avoir quand même l’air cassée. La surface de validation n’est plus purement déterministe.

Playwright aide. Vous pouvez rendre le composant, en faire une capture d’écran et le diff contre une référence de base. Mais c’est lent. Une suite de tests backend s’exécute en secondes. Une suite de régression visuelle Playwright s’exécute en minutes. L’IA ne peut pas itérer sur sa propre sortie à la même vitesse parce que l’étape de validation est d’un ordre de grandeur plus lente.

Le modèle peut générer du code React qui compile. Il ne peut pas vous dire si l’UI résultante semble correcte sans exécuter un navigateur, rendre le DOM et comparer des pixels. Ce goulot d’étranglement est réel. Le codage web assisté par IA fonctionne, mais la boucle de rétroaction est plus lâche.

Mobile : heures

Le mobile ajoute la réalité physique. Un geste a un timing et une physique. Une animation a des courbes d’easing qui semblent justes ou non. Un écran s’affiche différemment sur iOS 16 par rapport à iOS 18. Bluetooth, appareil photo, GPS et notifications push ont tous un comportement qui varie selon l’appareil, la version du système d’exploitation et la surcouche du fabricant.

Il n’y a pas de moyen rapide de valider cela. Les tests unitaires couvrent la logique métier mais pas la sensation d’un swipe. Les tests UI sur un simulateur détectent les problèmes de mise en page mais pas les pertes de frames sur un appareil Android vieux de trois ans. La vraie validation nécessite de builder, signer, installer et interagir avec l’application sur du matériel physique. La boucle de rétroaction se mesure en heures, pas en secondes.

Le modèle peut générer du code SwiftUI ou Jetpack Compose qui compile. Il ne peut pas vous dire si l’application semble native. Cela nécessite des mains humaines sur de vrais appareils. Le cycle d’itération est trop lent pour que le modèle s’auto-corrige efficacement — c’est pourquoi les apps React Native codées par IA ont besoin de guardrails pour passer à l’échelle.

Ce que le spectre signifie

Le codage assisté par IA ne progresse pas à la vitesse de la capacité des modèles. Il progresse à la vitesse de la validation.

Le modèle peut écrire du code mobile aujourd’hui. Ce qu’il ne peut pas faire, c’est savoir si ce code est bon. Savoir nécessite une infrastructure de validation que le mobile n’a pas. Le backend l’a. Le web est en train de la construire. Le mobile a des années de retard.

Pour les équipes qui choisissent où appliquer le codage assisté par IA, la réponse est évidente. Commencez là où la validation est la plus rapide. Le backend d’abord. Le web ensuite, avec un investissement dans les tests visuels. Le mobile en dernier, avec des mains humaines qui font encore la validation finale. Le coût de maintenance de ce choix s’accumule avec le temps — c’est pourquoi la version un n’est jamais le vrai problème.

Le modèle n’est pas plus intelligent en backend. Il est simplement mieux informé.