Google vient de Remporter la Bataille du Codage avec Gemini 2.5 Pro

Je pense que Sam Altman a agacé Google une fois de trop, et ils ont riposté avec Gemini 2.5 Pro qui est devenu numéro un au classement Arena du jour au lendemain. C’est le plus grand bond de score jamais vu, avec plus de 40 points par rapport à Grock 3 et GPT-4.5. Il est premier dans toutes les catégories, particulièrement en mathématiques, en écriture créative, et dans de nombreuses autres catégories importantes.

Les utilisateurs en sont enthousiastes. McKay Wrigley affirme que « c’est facilement le meilleur modèle pour le code, extrêmement puissant. La fenêtre de contexte d’un million de tokens est légitime. Il montre des éclairs de véritable perspicacité et brillance, et résout constamment des problèmes complexes en une seule fois. » C’est également mon expérience.

C’est le premier modèle capable de réaliser en une seule fois l’un des prompts les plus difficiles que j’ai testés : créer un jeu vidéo à partir de zéro, avec un pipeline complet d’apprentissage par renforcement pour apprendre aux petits bots à jouer, créer des réseaux de neurones, et exécuter ces bots dans des simulations pour développer leurs compétences. Plus spécifiquement, je lui ai demandé de créer plusieurs approches et de les tester les unes contre les autres pour voir laquelle était la meilleure.

Ce modèle a écrit le code, créé l’approche d’apprentissage machine, le pipeline d’entraînement, et l’a fait mieux que les autres modèles, avec une véritable perspicacité et brillance. Il est intelligent dès le départ, sans qu’on ait besoin de tout lui expliquer en détail. C’est le seul modèle à avoir réussi cela en une seule fois.

Si vous voulez l’essayer vous-même, rendez-vous sur AI studio.google.com, c’est gratuit. Le modèle dont nous parlons s’appelle Gemini 2.5 Pro, et actuellement il s’agit du modèle expérimental 0325. Notez que la limite de connaissances est janvier 2025.

Une auto-correction impressionnante pendant le processus de réflexion

Une chose qui m’a surpris est l’auto-correction et l’amélioration pendant le processus de réflexion. Habituellement, on voit un modèle réfléchir puis donner la réponse, mais celui-ci fonctionne différemment. Il réfléchit longuement, puis utilise ce contexte pour réfléchir davantage, comme une seconde étape de raisonnement, avant de produire la réponse finale.

Récemment, nous avons vu le modèle 03 mini qui était un excellent codeur, ainsi que Grock 3 et les modèles Claude 3.5 et 3.7, tous d’excellents codeurs. Dans mon esprit, ils sont tous plus ou moins au même niveau, certains meilleurs que d’autres sur certains aspects, mais tous très bons.

J’ai peut-être manqué la sortie de ce modèle parce que je supposais qu’il serait du même niveau que ce qu’OpenAI, Grock et Claude d’Anthropic proposent actuellement. J’ai été très surpris quand je l’ai essayé.

Un serpent avec un cerveau

L’un des tests les plus amusants que j’ai conçus pour ces modèles est de demander à l’IA d’entraîner une autre IA pour accomplir une tâche. Concrètement, utiliser un pipeline d’apprentissage par renforcement pour créer une IA capable d’effectuer une tâche spécifique.

Je n’ai jamais pu créer cela en un seul prompt. Habituellement, il faut créer la tâche d’abord (par exemple, un jeu de Snake), puis concevoir le pipeline d’apprentissage par renforcement, l’exécuter soi-même, et enfin tout combiner. Jamais je n’ai pu réaliser l’ensemble du processus du début à la fin avec un seul prompt… jusqu’à ce modèle, avec sa fenêtre de contexte d’un million de tokens.

La chose la plus proche était Manis AI, qui semblait tout exécuter mais ne m’a pas fourni tout le code et tous les fichiers pour que je puisse confirmer. Le rapport semblait légitime, mais je ne pouvais pas vérifier à 100%. Voyons si Google peut le faire.

J’ai demandé de créer un jeu à deux joueurs en Python où deux serpents s’affrontent pour le meilleur score, avec des barrières, des power-ups et des labyrinthes complexes. Le jeu doit fonctionner de manière autonome, avec un pipeline d’apprentissage par renforcement où les serpents apprennent à jouer et s’améliorent. Je voulais deux approches d’entraînement distinctes pour chaque serpent afin de comparer leurs performances.

Le modèle a déconstruit la demande : le jeu de base est un Snake à deux joueurs assez simple, mais nous utilisons l’apprentissage par renforcement pour enseigner aux serpents, donc ce n’est pas un simple script mais un réseau neuronal, un cerveau si vous voulez. L’objectif est de comparer deux approches différentes d’apprentissage par renforcement.

Une réflexion approfondie sur la conception du jeu

Le modèle a réfléchi à la boucle de jeu, à la représentation des états pour l’apprentissage par renforcement, à l’espace d’action, à la fonction de récompense et aux algorithmes d’apprentissage par renforcement comme le Deep Q Network.

C’est important de comprendre qu’avant, il fallait beaucoup de connaissances pour faire ce genre de choses. Maintenant, nous pouvons simplement nous lancer et commencer à expérimenter, le modèle d’IA nous fournissant les roues d’entraînement. Bien sûr, si on se contente de copier-coller le code sans comprendre ce qu’il fait, on passe à côté de l’essentiel. Mais si on utilise ce processus pour approfondir et essayer de comprendre ce qui se passe, cela peut être extrêmement utile.

Voici la fonction de récompense : le serpent obtient 20 points pour avoir mangé de la nourriture, 15 pour un power-up, perd 30 points s’il perd, gagne 30 points s’il gagne, et il y a une petite pénalité par pas pour encourager la vitesse. Cela signifie que plus il agit rapidement, moins la pénalité est importante – en gros, « dépêche-toi de gagner, ne prends pas ton temps ».

Auto-correction pendant le processus de réflexion

On remarque comment le modèle fait de l’auto-correction et des améliorations pendant son processus de réflexion. Sa pensée initiale est peut-être de terminer le jeu quand les deux serpents meurent, mais après réflexion, il corrige cette idée : « Non, ce n’était pas une bonne idée. Terminer le jeu quand un seul meurt simplifie les récompenses de gagnant/perdant et rend les épisodes potentiellement plus courts. »

Il réfléchit à comment rendre cela efficace et plus rapide sans perdre en qualité. Il y a d’autres éléments qu’il examine et corrige. Par exemple, il pense d’abord utiliser le même algorithme pour les deux serpents, puis se corrige : « Non, nous avons besoin de deux approches différentes. » Nous utiliserons donc Q-learning et DQN, et nous testerons ces approches l’une contre l’autre.

Je lui avais demandé de créer des power-ups, et sa pensée initiale était de créer des power-ups très complexes, mais il se corrige en disant : « Non, concentrons-nous d’abord sur le fonctionnement de base de l’apprentissage par renforcement, nous pourrons ajouter plus de complexité plus tard. » Je dois le féliciter pour cela, car si la complexité avait été augmentée mais que le code ne fonctionnait pas, cela aurait été une perte de temps.

C’est parfois bizarre de lire ces sorties, car ce n’est que du texte sur une page, mais pas vraiment. C’est un raisonnement sur la façon de créer un projet que vous venez d’inventer. Vous dites : « Hé, fais combattre ces deux serpents avec l’apprentissage par renforcement », et le voilà qui réfléchit à toutes les permutations futures possibles pour trouver la réponse la plus optimale, puis il le fait. Je sais que nous avons déjà vu cela auparavant, mais j’espère que cela ne perdra jamais sa magie.

Structure du projet et code

Le modèle crée une structure de projet complète, ce qui est bon. Pour ce cas précis, je lui demande toujours de tout condenser en un seul fichier, mais pour un « vrai » projet, cette approche serait meilleure.

Il crée un fichier d’exigences (requirements.txt), qui liste tous les packages nécessaires comme PyTorch, un système d’apprentissage par renforcement open source créé par Meta (anciennement Facebook). Cela permet de ne pas avoir à savoir comment installer chaque élément individuellement – on tape simplement une ligne pour installer tout ce qui est dans ce fichier.

Ensuite, il fournit le code principal qui définit le jeu, le réseau neuronal et la logique de l’agent, puis le script d’entraînement. Je reçois parfois des commentaires me disant que j’exagère l’enthousiasme, mais comment ne pas être enthousiaste? Il y a 3-4 ans, l’IA ne pouvait pas coder. Maintenant, elle peut coder et faire de l’apprentissage automatique pour créer ses propres petits agents d’IA. Où en serons-nous dans quatre ans?

Résolution des erreurs et exécution du jeu

Le modèle explique les concepts clés, décrit chaque document et fichier, et indique comment exécuter le code avec des suggestions d’améliorations potentielles pour plus de complexité une fois terminé.

Malheureusement, il n’a pas pu réussir du premier coup – j’ai dû lui soumettre un message d’erreur, qu’il a essayé de corriger. Même cela n’a pas suffi, et nous avons encore rencontré des messages d’erreur. Il insistait pour ne donner que la portion corrigée, en disant « et le reste du code va ici ». J’ai dû lui demander de réécrire tout le code avec toutes les corrections.

À ce stade, on pourrait penser que nous étions dans une boucle sans fin, mais non, il l’a fait! J’ai dû soumettre l’erreur trois fois pour qu’il puisse tout dépanner et résoudre, ce qui me semble très raisonnable dans le cadre du processus de dépannage.

Entraînement des serpents IA

Voici comment nous exécutons le jeu : d’abord, nous lançons le mode d’entraînement avec une commande qui nous permet de définir le nombre d’épisodes. Par exemple, si nous voulons l’exécuter pour 10 000 épisodes, cela signifie que ces deux petits serpents vont, dans cette simulation du « Jour de la marmotte », se réveiller chaque matin et parcourir leurs petits parcours jusqu’à ce que l’un d’eux gagne.

Cela se produira 10 000 fois, et chaque fois, ils seront récompensés pour certaines stratégies. Plus ils réussissent, plus ils obtiennent de récompenses, et avec le temps, ils découvriront comment jouer au mieux de leurs capacités, dans la limite de ce qu’ils ont appris au cours de ces 10 000 simulations.

Nous pouvons l’exécuter en mode « headless » (sans interface graphique), ce qui est plus rapide car nous ne voyons pas de visuels, tout se passe en arrière-plan. Ou nous pouvons utiliser l’entraînement visuel, qui s’exécute avec une visualisation mais est très lent – 10 000 épisodes prendraient des jours, voire des semaines.

J’ai lancé l’entraînement pour 10 000 épisodes, et cela a commencé assez rapidement. En observant les progrès, on voit les améliorations des modèles qui deviennent de plus en plus performants. Nous examinons le score moyen des 100 derniers épisodes pour chaque joueur.

Au début, les scores moyens étaient très bas (0,4 et 0,6). Après 1 500 épisodes environ, les scores augmentent (0,7 et 1,0). Le joueur 2 (DQN) semble gagner jusqu’à présent, atteignant 3,1 tandis que le joueur 1 progresse plus lentement.

L’entraînement a pris entre 6 et 10 minutes, et comme prévu, le joueur 2 a gagné avec des scores bien meilleurs et des capacités d’apprentissage plus rapides. La durée des parties s’est considérablement allongée vers la fin, car les serpents étaient capables de jouer plus longtemps sans mourir.

Différences entre les deux approches d’apprentissage

J’ai demandé au modèle d’expliquer les différences clés entre les deux approches d’entraînement utilisées. Le joueur 1 utilisait Q-learning, une approche plus simple qui stocke les valeurs dans une table, tandis que le joueur 2 utilisait Deep Q-learning (DQN), qui stocke les informations dans un réseau neuronal.

Le DQN est beaucoup plus proche de ce que nous considérons comme l’IA aujourd’hui. Il offre une excellente évolutivité, tandis que le Q-learning est limité. Pour le Q-learning, vous voulez que l’espace d’action et l’état soient petits et discrets, alors que pour les environnements plus grands et continus, vous préférez le DQN.

Le DQN offre également une meilleure efficacité d’échantillonnage d’expérience via le replay d’expérience. C’est plus complexe, et nous avons vu cela en action : ils commencent à peu près au même niveau, mais après 1 000 itérations, le DQN prend l’avantage et continue de progresser rapidement, devenant de plus en plus efficace. Vers la fin, il est bien plus performant que l’approche Q-learning.

Il est intéressant de noter que nous aurions probablement pu continuer et l’améliorer davantage, mais voyons comment ces serpents se comportent en action. Nous pouvons exécuter une commande pour jouer 20 parties et observer leurs performances.

En regardant le jeu, on voit que le joueur 2 (bleu) gagne facilement contre le joueur 1 (vert). Le joueur 2 semble plus adaptable et plus intelligent dans sa façon de jouer. L’environnement est assez simple, et le modèle a choisi de le garder ainsi, mais il a également suggéré des moyens de l’améliorer et de le rendre plus complexe.

Une première dans mes tests

C’est la première fois qu’un modèle que j’ai testé a pu réaliser cela en une seule fois. Je ne considère pas les allers-retours pour le dépannage comme un problème – il l’a résolu rapidement, c’est l’essentiel.

Dans le passé, avec d’autres modèles, une fois qu’ils avaient terminé la première étape, je devais souvent revenir leur demander d’afficher des données intéressantes pendant l’entraînement. Ici, il l’a fait par défaut. Remarquez que je n’ai jamais expliqué comment afficher ces petites sorties – il a décidé de le faire de lui-même, ainsi que les commandes nécessaires pour exécuter l’entraînement.

Tout était clairement expliqué, tout était dans un seul fichier. C’était de loin la meilleure tentative pour ce prompt particulier, d’une complexité considérable, que j’ai vue. La seule chose qui s’en approchait était Manis, un agent IA fonctionnant sur Claude 3.5, mais comme tout le code et la documentation étaient sur sa propre machine virtuelle, je n’ai pas pu extraire le code et le vérifier.

Ici, Gemini l’a fait sans être un agent – c’est juste un grand modèle de langage qui génère du code, que j’exécute ensuite. Sans structure d’agent, sans être connecté à Cursor, il a tout réalisé en une seule fois. Je dois féliciter Google : ils ont créé quelque chose de vraiment spécial.

Autres exemples impressionnants

Simulation de football

J’ai vu Trudy Painter créer une simulation de football basée sur un jeu rétro. J’ai téléchargé une capture d’écran d’un jeu Nintendo de 1990 et demandé de créer un jeu similaire, une simulation de football qui se joue toute seule, avec deux équipes, chaque joueur laissant une traînée montrant son parcours, et des statistiques en direct qui se mettent à jour pendant le jeu.

Le modèle a choisi d’utiliser Pygame et a produit un jeu fonctionnel. Les traînées auraient pu être un peu plus longues et j’aurais aimé plus de statistiques, mais c’était très impressionnant pour la rapidité et la précision avec laquelle tout a été fait. Il n’y avait aucun bug ni erreur.

J’ai ensuite demandé d’allonger les traînées, de donner un numéro à chaque joueur, et d’afficher les statistiques de tous les joueurs de l’équipe de gauche (temps de possession du ballon, passes, tirs, buts). Le modèle a implémenté toutes ces fonctionnalités parfaitement.

Simulation de distribution de Galton

J’ai demandé de créer un code pour animer un tableau de Galton, qui montre la distribution des choses lorsqu’elles ont une probabilité 50/50 de rebondir à gauche ou à droite. Le modèle a créé une simulation interactive avec plusieurs options : nombre de balles, lignes de chevilles, vitesse de chute, taille des balles, biais gauche/droite, facteur de largeur des bacs, activation de la physique, et affichage des traînées.

Tout fonctionnait parfaitement, chaque curseur faisait exactement ce qu’il était censé faire. Le modèle a même ajouté des effets visuels supplémentaires lorsque je lui ai demandé de rendre la simulation plus attrayante visuellement.

Ce qui est remarquable, c’est la rareté des bugs dans tous les tests que j’ai effectués. Le code produit est généralement utilisable et fonctionnel du premier coup.

Flappy Bird 3D contrôlé par les mains

Inspirée par un projet du Vibe Jam 2025 de Peter Levels, j’ai demandé de créer un jeu similaire à Flappy Bird, mais en 3D, utilisant la webcam de l’utilisateur pour suivre les mouvements de ses mains. Lorsque l’utilisateur bouge sa main de haut en bas, cela fait battre les ailes de l’oiseau.

Le modèle l’a fait, ça a fonctionné, et il l’a exécuté sur un serveur local pour qu’on puisse y accéder via une page web. Ce modèle a été le plus fluide jusqu’à présent pour réaliser cela, c’était phénoménal. Je n’ai pas pu l’enregistrer car je devais utiliser ma webcam et enregistrer en même temps était problématique.

Blood Bowl : simulation de football fantastique

J’ai demandé de créer un jeu ressemblant à Blood Bowl, un jeu de plateau qui s’est transformé en jeu vidéo, où des créatures fantastiques comme des orcs et des elfes jouent au football américain dans une version plus violente. J’ai spécifié que chaque joueur devait avoir des statistiques de force, d’endurance, d’agilité et de vitesse, et que chaque action nécessitait un jet de dé à 20 faces pour déterminer si elle réussissait.

Initialement, le modèle a créé un jeu textuel, ce qui n’était pas ce que j’attendais, mais c’était en fait une excellente interprétation de ce que je lui avais demandé. Il a parfaitement capturé l’esprit du jeu, avec des jets de dés, des blessures, et des joueurs qui se font assommer.

Lorsque j’ai précisé que je voulais un jeu avec des graphismes de base et en temps réel, il a créé une version avec des graphismes simples. Après quelques ajustements, j’ai obtenu un jeu où les équipes se battaient, certains joueurs étaient blessés ou tués, et le porteur du ballon courait vers la zone d’en-but.

Conclusion

Gemini 2.5 Pro est véritablement impressionnant. Sa capacité à comprendre des demandes complexes, à générer du code fonctionnel, et à s’auto-corriger pendant son processus de réflexion le place au-dessus des autres modèles que j’ai testés.

La fenêtre de contexte d’un million de tokens fait une réelle différence, permettant au modèle de réfléchir plus profondément et de gérer des tâches plus complexes. Le fait qu’il puisse résoudre des problèmes en une seule fois, que d’autres modèles nécessiteraient plusieurs étapes pour accomplir, est remarquable.

Google a créé quelque chose de vraiment spécial ici. Cette bête d’IA est capable de réaliser des projets complexes avec une facilité déconcertante, et je suis impatient de voir comment elle évoluera à l’avenir.