Aller au contenu

Les agents de code ont tué les frameworks multiplateformes !

  • IA
  • Kotlin
  • Multiplatform
  • Opinion
  • 8 min.

Si vous traînez sur LinkedIn, vous avez forcément vu passer ce discours : le multiplateforme est mort. Kotlin Multiplatform, Flutter, React Native : de belles idées d'hier, qui passent déjà pour de l'histoire ancienne à l'heure de l'IA.

Oui, le titre est taquin. Mais l'argument derrière tient la route, et il mérite une vraie réponse.

Le raisonnement, c'est que le multiplateforme existe parce qu'écrire chaque fonctionnalité deux fois coûte cher. Or les agents rendent ça bon marché. Alors pourquoi garder une couche partagée ? Écrivez la spec une fois, laissez les agents et les skills produire une appli Swift et une appli Kotlin, et maintenez les deux. Deux produits natifs, un développeur product builder, un seul rythme.

Sur le papier, difficile de dire non. Et comme nous avons bâti notre activité autour de Kotlin Multiplatform, prenez ce qui suit avec un peu de recul. Je vais défendre une seule idée : partager la partie de votre application qui doit être identique. Mais d'abord, soyons fair-play avec les agents de code.

Ce que l'argument a de juste

Une appli entièrement native se comporte comme les utilisateurs l'attendent. Un seul développeur peut livrer une fonctionnalité sur les deux plateformes, donc on va plus vite. Les deux produits avancent au même rythme, donc la parité fonctionnelle n'est plus un chantier à part entière.

Les ingénieurs de Shopify ont défendu cette position en septembre 2026, en annonçant qu'ils repassaient leurs applications mobiles de React Native à Swift et Kotlin. Leur raisonnement : les agents de code ont changé ce que coûte une fonctionnalité construite deux fois.

Je pense qu'ils ont raison sur ce point. Traduire une fonctionnalité d'un langage à l'autre, les agents savent très bien le faire.

Mais cet argument cache une hypothèse, et c'est avec elle que je ne suis pas d'accord.

Je n'ai jamais vendu Kotlin Multiplatform comme un gain de productivité.

Je l'ai toujours vu comme une garantie : les mêmes règles, le même comportement, sur toutes les plateformes, vérifiés une seule fois. C'est de la valeur ajoutée au produit, pas du temps gagné sur le projet. Alors si les agents rendent l'écriture de code moins chère, tant mieux : ils démontent un argument que je n'ai jamais avancé.

Puis la réalité nous rattrape

J'aime les défis, et expérimenter jusqu'où on peut aller avec l'IA m'intrigue, alors quand un client a voulu essayer de faire du natif, j'ai dit oui. Les agents écrivent à peu près le même code en Swift et en Kotlin, et au premier coup d'œil, les deux bases de code se ressemblent.

Mais les deux plateformes ne sont pas parties du même point. L'appli Android a été écrite de zéro, AndroidX d'abord. L'appli iOS, elle, est partie du code d'une ancienne appli. Et les agents reprennent les habitudes qu'ils trouvent : le code existant fait partie du prompt. Android a ensuite dû rattraper son retard pour atteindre la parité.

Bien après l'écriture du code, j'ai repéré un truc par pur hasard. Certaines de nos briques devaient être jetables : petites, et la plupart du temps sans état. Sur iOS, sans framework d'injection de dépendances (DI), les agents les ont construites avec des factories, à chaque fois. Sur Android, le framework de DI en a fait des singletons.

Un détail ? Cela n'en est pas un. Un objet jetable qui vit éternellement peut traîner un état jusqu'à l'appel suivant, et il reste en mémoire alors que personne n'en a besoin.

Aucun utilisateur ne s'en est aperçu. Aucun rapport de bug, aucun incident. Juste de la dette.

Ironie du sort, le côté le plus sain était celui du code legacy, sans framework de DI : un pur accident. Mais c'est justement le point : les vrais projets ne sont jamais symétriques. Une spécification, ça s'écrit une fois. Le point de départ, non.

Nous avons passé la base de code au peigne fin, corrigé le problème et ajouté de nouvelles règles pour les agents. Mais personne ne peut écrire toutes les règles à l'avance : chaque dérive découverte est une règle que l'on n'avait pas encore. Et une question dérangeante me trotte dans la tête : si j'ai trouvé celle-ci par hasard, combien d'autres se cachent encore ?

Ce que personne ne compte

Quand on dit que les agents ont rendu le natif « gratuit », on ne compte qu'une chose : le temps d'écrire le code. Pas ce qui vient après.

Écrire deux fois, c'est relire deux fois. Et quand les deux relectures ne sont pas alignées, qui tranche ? Pour le relecteur iOS, c'est la factory qui a raison. Pour le relecteur Android, c'est le singleton. Aucune des deux bases de code n'est la référence, on l'a bien vu. Quelqu'un doit l'être, et ce quelqu'un, c'est un humain à l'attention limitée.

Et puis il y a la fatigue. À la seconde passe, on survole, et c'est exactement comme ça que notre dérive a survécu aussi longtemps.

Enfin, le coût n'est pas que technique. Les ingénieurs de Babbel ont rencontré le même problème côté produit. Leurs deux implémentations s'éloignaient l'une de l'autre sur les événements analytics et les A/B tests : une propriété nommée un peu différemment, une expérience déclenchée depuis un endroit différent sur chaque plateforme. Les corrections étaient simples. Le problème, c'est qu'il peut se reproduire partout. Des décisions produit se prenaient sur des tableaux de bord qui racontaient deux histoires un peu différentes. Une dérive que personne ne voit n'est pas inoffensive. Elle est juste silencieuse.

Ce que change une couche partagée

Kotlin Multiplatform ne vous oblige pas à partager vos écrans. Il permet de partager votre comportement et vos règles métier, et vous laisse libre pour l'UI : native, ou partagée avec Compose Multiplatform. L'essentiel, c'est de partager ce pour quoi avoir deux versions n'a jamais été un atout : les règles, les données, les flux.

Voyez ça comme un curseur. À vous de le placer, selon votre produit et votre équipe. Babbel l'a mis au niveau du view model, a gardé tous les écrans natifs, et dit que les divergences ont disparu. D'autres équipes le poussent tout en haut et partagent aussi l'UI. Deux réponses valables à la même question : qu'est-ce qui mérite de n'exister qu'une fois ?

Ça ne règle pas tout : selon l'endroit où est votre curseur, il vous reste peut-être deux UI à relire. Mais vous avez réduit la surface de contrôle, et quand le code ne coûte presque rien et l'attention beaucoup, c'est elle qui compte.

Là où les agents m'aident vraiment

Les agents m'aident à produire plus de ce que je construis déjà : des applis KMP et Compose Multiplatform, et des librairies open source que je n'avais jamais eu le temps de créer ni de maintenir. Ils n'ont pas changé ce en quoi je crois. Ils ont juste facilité le passage à l'acte.

Je pense aussi que les agents abaissent la barrière à l'entrée. Pendant des années, l'idée n'a jamais été le problème : c'est le démarrage d'un projet qui coinçait. Mise en place du projet, comportements propres à chaque plateforme, Kotlin/Native dans une appli iOS existante… c'est là qu'un agent peut vous tenir compagnie.

Trivago est un bon exemple. Dans un post LinkedIn, l'un de leurs responsables d'ingénierie raconte avoir migré leurs applications mobiles vers Kotlin Multiplatform en une dizaine de semaines, avec environ 95 % du code écrit par l'IA. Ce sont leurs chiffres, mais regardez la direction : les agents ne les ont pas renvoyés vers le natif, ils les ont aidés à passer au code partagé.


Alors, qu'est-ce qui est mort ?

Pas le multiplateforme. Ce qui a changé, c'est la question.

Pendant des années, on s'est demandé qui écrirait le code. Maintenant qu'il ne coûte presque rien, la question, c'est ce qu'on peut se permettre de vérifier. Deux bases de code, ce sont deux bases de code presque identiques auxquelles se fier, et une pile de règles qui grossit pour les garder alignées.

Alors non, les agents de code n'ont pas tué le multiplateforme. Ils ont rendu une idée du multiplateforme plus précieuse : partager ce qui doit être identique, et le vérifier une seule fois. Kotlin Multiplatform promet le même comportement partout, et cette promesse vaut plus quand le code est bon marché et que la confiance ne l'est pas.

Ces articles pourraient vous plaire

Tutoriels, retours d'expérience et bonnes pratiques autour de KOSI et de l'écosystème Kotlin, par ceux qui maintiennent les librairies.

Kotlin Multiplatform Architecture Technique
8 min.

17/11/2026

Inara n’a rien de magique : lisez le code qu’elle écrit

Dans la plupart des frameworks de DI, un module est un sac anonyme de bindings, et les dépendances sont recherchées par type. Inara donne une identité aux modules. Ouvrons le capot et lisons le code qu'elle génère : aucun tour de magie, seulement du Kotlin ordinaire que vous pouvez parcourir d'un Cmd+clic.

Lire plus
Opinion
9 min.

09/11/2026

LARPing enthusiasm : le spectre du désengagement

Je peux confier le travail à l'IA, pas le jugement ni le sens du produit. Récit d'un glissement vers le désengagement, et d'une reconquête en cours.

Lire plus
Architecture
7 min.

02/11/2026

Inara : injectez vos dépendances à la compilation

J'ai créé Kodein, et pourtant je crois aujourd'hui qu'il nuit à l'écosystème Kotlin Multiplatform. Voici Inara, un Kotlin Symbol Processor qui résout vos dépendances à la compilation, et découvrez pourquoi nous mettons Kodein en fin de vie.

Lire plus
Opinion
6 min.

19/10/2026

LARPing enthusiasm : la frénésie créative de l’IA

L'IA me permet de construire en quelques semaines ce qui demandait des années, et c'est grisant comme une drogue. Est-ce que je crée vraiment, ou est-ce que je joue l'enthousiasme ? Une réflexion personnelle sur la volonté, l'agentivité et le code partagé.

Lire plus
Kotlin Multiplatform Technique
9 min.

17/10/2026

MocKMP : un processeur de mocking pour Kotlin/Multiplatform

Envie d'exécuter vos tests unitaires sur toutes les cibles Kotlin/Multiplatform ? MocKMP génère mocks et fakes à la compilation avec un Kotlin Symbol Processor, sans réflexivité, et conserve une API de mocking familière.

Lire plus
Kotlin Multiplatform Technique
10 min.

04/09/2025

Utiliser Swift dans une librairie Kotlin/Multiplatform

Besoin d'utiliser une API iOS réservée à Swift, comme CryptoKit, dans votre librairie Kotlin/Multiplatform ? Salomon montre comment la relier via Objective-C et le cinterop de Kotlin/Native, avec du code testé.

Lire plus