Être développeur à l'ère de l'IA qui raisonne

Par Mani Doraisamy

Être développeur à l'ère de l'IA qui raisonne, par Mani Doraisamy

Le lancement de o3 d'OpenAI m'a fait remettre en question mon identité de développeur. Il y a neuf mois, j'avais prédit que l'IA ajouterait bientôt un comportement déterministe à ses fondements probabilistes. Pourtant, j'ai été choqué de voir que cela se produisait la même année. Ce modèle n'est plus seulement un générateur de mots cohérents ; il surpasse 99,8 % des développeurs en matière de codage compétitif. Bien qu'OpenAI reste discret sur sa mise en œuvre, il semble qu'elle soit parvenue à ce résultat grâce à la synthèse de programmes, c'est-à-dire la capacité de générer des algorithmes à la volée, tout comme les développeurs écrivent du code pour résoudre des problèmes. Dans cet article, j'explique à quel point la pensée d'o3 est similaire à la façon dont nous pensons en tant que développeurs et j'explore notre pertinence dans cette nouvelle ère de l'IA.

Comment les utilisateurs créent de la logique

Les utilisateurs pensent avec des données. Imaginez que vous êtes caissier dans une épicerie. Vous apprenez à calculer le montant en regardant le propriétaire le faire pour quelques clients. Sur cette base, lorsqu'un client achète 10 carottes, vous déterminez que le prix est de 2 $, vous multipliez 2 $×10 et vous lui dites qu'il doit payer 20 $. C'est la raison pour laquelle les utilisateurs ont recours aux feuilles de calcul pour les tâches répétitives. Ils disposent d'un moyen intuitif de travailler avec des données tout en écrivant des formules qui peuvent être appliquées à des lignes consécutives et dont les résultats sont immédiatement visibles :


Les développeurs, quant à eux, pensent en termes d'algèbre (c'est-à-dire de métadonnées). Ils déclarent des variables, telles que le prix et la quantité, les multiplient et affectent le résultat à une autre variable, le montant. Ils ont la possibilité d'exprimer cette logique dans un IDE sans voir aucune donnée. Ce n'est qu'au moment de l'exécution qu'ils peuvent appliquer les données et vérifier si leur logique fonctionne correctement. Cette capacité à abstraire la logique est ce qui distingue les développeurs des utilisateurs. C'est ce qui leur permet de créer des logiciels de facturation qui calculent des millions de fois le montant des commandes pour des milliers de clients.

Comment l'apprentissage automatique crée de la logique

L'apprentissage automatique fonctionne comme les utilisateurs. Sur la base des exemples, il trouve le modèle à l'aide de la régression linéaire. Sur la base de ce modèle, il apprend que Montant = Prix × Quantité. C'est comme si un élève apprenait par cœur les tables de multiplication sans comprendre pourquoi la multiplication fonctionne.


Une fois qu'il a appris ce modèle, il applique cette logique à de nouvelles entrées, tout comme une formule de tableur qui est appliquée à des lignes consécutives.

Comment o3 crée de la logique à la volée

Avec o3, l'IA ne pense plus comme un utilisateur. Elle pense comme un développeur. Tout comme le cerveau d'un développeur peut réfléchir à un problème et trouver une solution à l'aide d'un code, o3 génère un programme (c'est-à-dire des métadonnées) à la volée pour résoudre le problème. Une fois le programme créé, il est exécuté comme un code écrit par le développeur, produisant des résultats cohérents pour les mêmes entrées. La première partie est appelée synthèse du programme et la seconde partie est appelée exécution du programme.


La synthèse du programme revient à entendre un problème et à créer une feuille de calcul entièrement nouvelle et un tas de formules pour résoudre ce problème. Il n'est plus nécessaire de disposer de données pour trouver des formules. Il peut créer un nouvel algorithme qui n'existait pas auparavant et vérifier l'exactitude de la solution pendant l'exécution du programme, tout comme les développeurs testent et valident leur code au moment de l'exécution.

Approche pratique et approche autonome


L'arrivée de modèles de raisonnement tels que o3 modifie la manière dont les développeurs écriront le code. La plupart d'entre nous s'appuieront sur du code généré par l'IA. Cependant, la question est de savoir si nous allons réviser ce code et en assumer la responsabilité. Il en résultera deux approches distinctes de la création de logiciels :

1. Approche pratique
   
   Les développeurs utiliseront des outils tels que GitHub Copilot, alimenté par o3, pour générer du code. Cependant, ils examineront, affineront et s'approprieront activement les résultats générés par l'IA. Nous voyons déjà des exemples de cette approche avec des applications nouvelles, mais o3 est prêt à en faire la norme pour tous les types de développement de logiciels.
2. Approche pratique
   
   Les utilisateurs se serviront d'outils tels que ChatGPT, qui s'appuient sur o3, pour résoudre leurs problèmes commerciaux. Leur demande initiale articulera les exigences de l'entreprise dans un langage simple. Après avoir affiné les exigences, les utilisateurs interagiront avec l'interface de chat pour les opérations suivantes. Ici, la synthèse du programme a lieu lors de l'invite initiale, tandis que l'exécution du programme se déroule au cours des conversations. Cette approche peut être étendue aux applications du GPT Store et à d'autres applications à l'aide d'API.

Résumé

Avec le lancement de o3, il est clair que les utilisateurs pourront bientôt générer du code fonctionnel sans effort. Plus concrètement, les bibliothèques bien définies que nous utilisons dans les applications, telles que les paquets npm et les projets open-source, seront probablement générées par l'IA d'ici quelques années. Bien que certains développeurs puissent réviser et publier ce code, nous devrions supposer que, dans de nombreux cas, seule l'IA comprendra réellement le fonctionnement de ces bibliothèques. Cela signifie-t-il que nous pouvons faire confiance à l'IA comme nous avons fait confiance à des contributeurs inconnus de logiciels libres dans le passé ? Si l'on étend cette analogie à la recherche sur le cancer, si l'IA propose une solution que les chercheurs ne peuvent pas comprendre, devons-nous l'utiliser pour sauver des vies ou l'éviter parce que les humains ne la comprennent pas encore ? Ces questions idéologiques façonneront l'avenir. Pour ma part, je souhaite que l'approche pratique soit couronnée de succès. Les développeurs doivent comprendre et assumer la responsabilité de la logique générée par l'IA s'ils veulent la lancer en tant qu'application pour d'autres. Si nous renonçons à notre compréhension, le raisonnement de l'IA mettra fin au raisonnement des humains. Notre capacité à comprendre le code généré par l'IA décidera si nous sommes les marionnettistes ou les marionnettes de l'IA.

Source : Being a Developer in the Age of Reasoning AI

Et vous ?

Pensez-vous que cette réflexion est crédible ou pertinente ?
Quel est votre avis sur le sujet ?

Voir aussi :

Au-delà du battage médiatique : Mes réflexions honnêtes sur l'IA générative, par Mensur Durakovic

L'utilisation de code généré par l'IA fera de vous un mauvais programmeur, par Rudis Muiznieks

L'IA est en train de créer une génération de programmeurs illettrés, par Namanyay