Le buzz du moment : agentiques

À mon avis, les agents sont actuellement le principal moyen de faire progresser l’IA. La construction d’une couche d’outils et de processus de réflexion utiles autour d’un LLM (Large Language Model ou grand modèle de langage) offre encore beaucoup de potentiel, là où les modèles de langage purs commencent à se heurter à certaines limites.

Dans un précédent article de blog sur les agents, mon collègue Bert a déjà brièvement expliqué ce qu’est un IDE agentique. En bref, un agent est un fragment d’IA qui peut effectuer toutes sortes de tâches de manière (semi-)autonome (comme éditer des fichiers texte, par exemple, ce qui est l’activité principale en programmation). Nous connaissons déjà les environnements de développement intégrés : il s’agit des logiciels que nous utilisons pour écrire du code, composés d’un éditeur de texte et de tous les outils supplémentaires possibles pour compiler, exécuter, refactoriser le code, etc. Mon IDE préféré, par exemple, est Intellij IDEA.

Le terme IDE agentique désigne un IDE qui, parmi ses outils supplémentaires intégrés, comprend une fonctionnalité permettant à l’IA d’exécuter toutes sortes de tâches à votre place. En général, l’IDE affiche une fenêtre dans laquelle vous pouvez dialoguer avec l’IA, qui se met au travail dès que vous lui demandez quelque chose. La grande différence avec les assistants IA plus basiques réside dans le fait que l’agent peut utiliser pratiquement toutes les fonctionnalités de l’IDE : éditer toutes sortes de fichiers (pas nécessairement celui sur lequel vous travaillez à ce moment-là), compiler et exécuter le code, voire le déployer sur un serveur, exécuter des commandes dans le terminal, etc. Travailler de cette manière, en conversant simplement dans la fenêtre de dialogue et en laissant l’agent faire le reste, est ce que l’on appelle le “vibe coding”.

Quelques Exemples

Une petite recherche sur Internet nous permet de trouver rapidement plusieurs exemples d’IDE agentiques.

• https://bolt.new/ fonctionne entièrement sur le web et permet de créer des applications web complètes à partir d’une invite. La plateforme est très populaire, même si plusieurs tentatives sont parfois nécessaires (et donc plutôt une conversation entière qu’une seule invite) pour obtenir le résultat souhaité. Ce site de commerce en ligne (qui n’est pas entièrement fonctionnel) a par exemple été construit après une conversation avec 5 invites de plus en plus complexes: https://starlit-melba-287efe.netlify.app/products .
• GitHub CoPilot est sans doute l’un des plus connus. Il donne un nouvel élan à l’IDE Visual Studio Code (VS Code) grâce à une IA qui travaille pour vous, un peu comme la programmation en binôme.
• Codeium WindSurf, un autre IDE agentique basé sur VS Code, sera présenté plus en détail ci-dessous. WindSurf est actuellement en cours d’acquisition par OpenAI.
• Cursor est également un IDE basé sur VS Code et l’un des IDE agentique les plus connus et les plus populaires.
• https://cline.bot/ . Également basé sur VS Code, et open source.
• La liste continue : Lovable, V0, Replit Agent, Devin, Trae, …
• Le petit nouveau (disponible depuis quelques semaines seulement) : IntelliJ Junie. Il sera certainement intéressant pour nous de le tester plus en détail à l’avenir, car il est basé sur IntelliJ IDEA.

Testé : Codeium WindSurf

Avant de commencer à tester WindSurf (anciennement Codeium), je n’avais pratiquement aucune expérience avec VS Code, l’IDE sur lequel Windsurf est basé, mais cela s’est avéré ne pas poser de problème ! Une fois l’installation terminée, j’ai eu l’idée d’un test très simple : j’ai demandé à l’IDE de m’écrire un petit outil en Java, qui se connecterait à Confluence et lirait les données d’un tableau sur une page spécifique. L’outil devait ensuite transférer ces données dans un nouveau fichier Excel et l’enregistrer sur mon PC..

L’outil a bien démarré, mais il y avait quelques problèmes à surmonter. À titre d’exemple, la connexion à Confluence ne fonctionnait pas avec les identifiants que Windsurf m’avait demandés lors de notre conversation initiale. Après une petite recherche sur Confluence, j’ai compris comment la connexion au site devait fonctionner pour les outils programmés, et j’ai pu en informer WindSurf. L’IDE a rapidement apporté les modifications nécessaires et tout a fonctionné. Après une brève conversation pour obtenir quelques détails supplémentaires sur l’application afin qu’elle réponde à mes besoins, j’ai obtenu, en une heure environ, une version fonctionnelle de l’outil demandé.

Un deuxième test, dans lequel j’ai demandé une application plus importante en plusieurs composants (serveur API + interface web, etc.), a été interrompu en raison d’un manque de crédits dans la version gratuite. Il s’est avéré qu’un IDE agentique perd ici un peu de sa vue d’ensemble et commet des erreurs en raison de la taille du projet.

Pour le troisième test, armé d’une licence commerciale et soutenu par un architecte compétent, je me suis mis au travail sur le code existant d’un projet Java assez ancien, avec une structure monolithique et des dépendances et méthodes obsolètes. Du moins, c’était une partie de l’équation. L’application est en cours de réécriture chez Smals, et une partie du nouveau code était déjà disponible. L’objectif du test était de permettre à WindSurf d’ajouter une fonctionnalité complète dans le nouveau code source, sur la base de tout le code existant (hérité + nouveau).

La nouvelle architecture de cette application était extrêmement modulaire (une architecture dite “oignon”) et nous avons dû ajuster régulièrement l’IDE, car il ne fournissait pas les ajouts et modifications appropriés dans tous les modules en même temps. À un moment donné, nous avons également dû l’aider manuellement à rechercher une fonctionnalité dans l’ancienne version du projet, afin de pouvoir la reprogrammer dans la nouvelle version. Finalement, après deux heures de “vibe coding”, nous avons ajouté la fonctionnalité, ce qui aurait autrement été une tâche fastidieuse et répétitive (mais impossible à automatiser de manière traditionnelle) pour un programmeur.

Comment peut-on faire encore mieux ?

Comme nous avons pu le voir dans la section précédente, les IDE agentiques offrent de nombreuses possibilités pour raccourcir et automatiser en partie le travail de programmation, mais tout ne se passe pas toujours sans accroc, car l’agent se trompe, ne fait pas exactement ce que nous voulons ou oublie de faire certaines choses. Un peu comme un programmeur inexpérimenté, peut-être ? Le problème se pose d’autant plus que le projet prend de l’ampleur.

Nous nous posons alors naturellement la question suivante : comment pouvons-nous améliorer cela ? Nous ne sommes toutefois pas les seuls ; d’autres sur le web ont déjà réfléchi à cette question et confirment ce que nous soupçonnions déjà : il faut fournir davantage de contexte et de meilleure qualité pour aider l’agent à comprendre ce que nous voulons réellement. Cela peut se faire de différentes manières : vous pouvez ajouter une liste de tâches à l’invite, et/ou vous pouvez fournir un fichier dans le projet, avec une liste d’instructions supplémentaires, et/ou vous pouvez ajouter dans chaque dossier d’un projet existant un fichier contenant des informations utiles sur ce dossier, et vous pouvez le faire de manière hiérarchique pour les sous-dossiers. Il s’agit en fait d’une sorte de signalisation de votre projet, adaptée à l’IA.

Bien sûr, fournir tout ce contexte représente beaucoup de travail. Mais ne vous inquiétez pas : il est probablement possible de laisser l’IA le faire elle-même dans une étape préparatoire. Il existe même déjà des outils commerciaux à cet effet, qui agissent également comme des agents et utilisent également un LLM en arrière-plan.

Documenter le code existant et le rendre plus compréhensible de cette manière est utile pour un IDE agentique, mais aussi pour les développeurs humains ! Ce sera la prochaine piste de recherche sur ce que l’IA peut apporter à la programmation…

Conclusion

Les IDE agentiques sont actuellement l’incarnation ultime de la programmation assistée par l’IA. Ils vont bien au-delà de la simple assistance et peuvent coder à votre place, comme si vous parliez à un développeur (inexpérimenté) qui effectue le travail à votre place. Le “Vibe Coding” pourrait bien prendre en charge une grande partie de notre travail dans un avenir proche !
La seule nuance, que nous devons toujours apporter à l’IA, c’est qu’il ne s’agit pas de magie : elle ne sait pas automatiquement ce qui doit être fait, et vous devrez l’ajuster et lui fournir un contexte. Garbage in – Garbage out.
Il y a donc certainement encore matière à amélioration, mais vu la vitesse à laquelle la technologie évolue, cela pourrait bien arriver rapidement…

De rage van het moment: Agentic

Agents zijn, naar mijn mening, momenteel de belangrijkste manier waarop AI vooruitgang boekt. Het bouwen van een laag van nuttige tools en denkprocessen rondom een LLM (Large Language Model) biedt nog erg veel ruimte voor potentieel, daar waar zuivere taalmodellen op zich stilaan op een aantal limieten botsen.

In een vorige blogpost over Agents legde mijn collega Bert reeds kort uit wat een Agentic IDE is. Kort herhaald: een zogenaamde agent is een stukje AI dat (semi-)autonoom allerlei zaken kan doen (zoals b.v. tekstbestanden editeren; de voornaamste bezigheid bij het programmeren). Een Integrated Development Environment of IDE kennen we reeds: dat is de software die we gebruiken om code te schrijven, bestaande uit een tekst editor en daarnaast alle mogelijke extra tools om de code te compileren, uit te voeren, te refactoren, … , noem maar op. Mijn favoriete IDE is b.v. Intellij IDEA.

De term Agentic IDE slaat dan op een IDE, die, als een van de extra geïntegreerde tools, de functionaliteit zal bevatten om via het gebruik van AI allerlei zaken in jouw plaats te gaan doen. Typisch krijg je dan binnen de IDE een venster om te chatten met dit AI, en zal dit voor jou aan de slag gaan wanneer je er iets aan hebt gevraagd. Het grote verschil met de meer eenvoudige AI-assistants is dat de agent daarbij zowat alle functionaliteit van de IDE kan gebruiken: allerlei bestanden editeren (niet enkel het bestand waar je zelf op dat moment in werkt), de code compileren en runnen, of zelfs uitrollen op een server, terminal commando’s uitvoeren, enz. Op deze manier werken, door enkel in het chatvenster te praten en de agent de rest te laten doen, noemen we het zogenaamde vibe coding.

Een paar voorbeelden

Met een klein beetje zoekwerk op het internet vinden we algauw een aantal voorbeelden van Agentic IDEs.

• https://bolt.new/ draait volledig op het web, en laat toe om volledige webtoepassingen te bouwen op basis van een prompt. Het platform is erg populair, zelfs al zijn er soms toch meerdere pogingen nodig (en dus toch eerder een hele conversatie dan één enkele prompt) om tot het beoogde resultaat te komen. Deze (niet volledig functionele) webshop, werd bijvoorbeeld na een conversatie met 5 complexer wordende prompts gebouwd: https://starlit-melba-287efe.netlify.app/products .
• GitHub CoPilot is allicht een van de bekendste. Deze geeft de IDE Visual Studio Code (VS Code) een nieuw elan met een AI dat voor je werkt, een beetje zoals “pair programming”. GitHub Copilot Studio.
• Codeium WindSurf, nog een andere Agentic IDE gebaseerd op VS Code, bespreken we verderop in iets meer detail. https://windsurf.com/editor . WindSurf wordt momenteel overgenomen door OpenAI.
• Ook Cursor is een IDE gebaseerd op VS Code en één van de meer bekende en populaire Agentic IDEs.
• https://cline.bot/ . Gebaseerd op – opnieuw – VS Code, en open source.
• De lijst gaat verder: Lovable, V0, Replit Agent, Devin, Trae, …
• New kid on the block (pas sinds enkele weken algemeen beschikbaar): IntelliJ Junie. Voor ons zeker interessant om in de toekomst nog verder uit te testen, aangezien hij is gebaseerd op IntelliJ IDEA.

Getest: Codeium WindSurf

Voor ik begon te testen met Codeium’s IDE, had ik nauwelijks ervaring met VS Code, de IDE waar Windsurf op is gebaseerd; dit bleek echter geen probleem! Na de installatie kreeg ik een idee voor een erg eenvoudige test: ik vroeg de IDE om voor mij een kleine tool te schrijven in Java, die zou gaan inloggen op confluence en op een bepaalde pagina de gegevens van een tabel uitlezen. Vervolgens zou de tool deze data in een nieuw Excel bestand gieten en dit opslaan op mijn pc.

De tool schoot goed uit de startblokken, maar er waren enkele euvels te overkomen. Het inloggen in confluence werkte b.v. niet met de inloggegevens die Windsurf mij tijdens de initiële conversatie had gevraagd te voorzien. Na een kleine opzoeking op confluence zelf, had ik een idee van hoe het inloggen op de site moest werken voor geprogrammeerde tools, en kon ik dit aan WindSurf vertellen. De IDE maakte prompt de nodige wijzigingen en daarna werkte het wel. Na nog een kleine conversatie om wat details van de toepassing naar mijn wensen te krijgen, had ik, al bij al op een uurtje, een werkende versie van mijn gevraagde tool.

Een tweede test, waarbij ik een grotere toepassing vroeg in verschillende componenten (API server + web frontend, enz.), ben ik gestaakt wegens een gebrek aan credits in de gratis versie. Het bleek wel dat een agentic IDE hier wat het overzicht kwijtraakt en steken laat vallen door de omvang van het project.

Als derde test ging ik, gewapend met een commerciële licentie en ondersteund door een bekwame architect, aan de slag op bestaande code van een legacy project. Het betreft een vrij oud Java project met een monolitische structuur en verouderde afhankelijkheden en werkwijzen. Althans, dat was een deel van het gegeven. De toepassing wordt momenteel herschreven bij Smals, en een deel van de nieuwe code was ook reeds beschikbaar. Het doel van de test was om WindSurf een volledige feature te laten toevoegen in de nieuwe broncode, gebaseerd op al deze reeds bestaande code (legacy + nieuw).

De nieuwe architectuur van deze toepassing was extreem modulair (een zogenaamde onion architecture) en we moesten de IDE geregeld bijsturen omdat deze niet in alle modules tegelijk de juiste toevoegingen en wijzigingen voorzag. Op een bepaald moment moesten we hem ook manueel wat op weg helpen bij de zoektocht naar een stukje functionaliteit in de oude versie van het project, om dit te kunnen herimplementeren in de nieuwe versie. Maar al bij al hadden we na twee uur vibe coding de feature toegevoegd; iets wat anders een vervelend en repetitief (doch niet op een traditionele manier te automatiseren) karwei zou zijn voor een developer.

Hoe kan het nu nóg beter?

Zoals we in de vorige sectie zagen, bieden agentic IDEs heel wat mogelijkheden om programmeerwerk in te korten en deels te automatiseren, maar verloopt het toch niet altijd van een leien dakje, omdat de agent zich vergist, de dingen niet precies doet hoe we willen, of zaken vergeet te doen. Misschien een beetje zoals een onervaren programmeur? Het probleem stelt zich ook des te meer naarmate het project groter wordt.

We vragen ons dan uiteraard af: hoe kunnen we dit verbeteren? We zijn echter niet alleen; op het web hebben reeds andere mensen hierover nagedacht, en deze bevestigen wat we reeds vermoedden: er moet meer en betere context worden voorzien om de agent wegwijs te maken in wat we eigenlijk willen. Dit kan op verschillende manieren: je kan een lijst zaken toevoegen aan de prompt, en/of je voorziet een bestand in het project, met een waslijst aan extra instructies, en/of je voegt in elke folder van een bestaand project een bestand toe met nuttige info over die folder, en je doet dit op een hiërarchische manier voor subfolders. Eigenlijk is dit een soort van bewegwijzering van je project, op maat van het AI.

Het is uiteraard wel een pak werk, al die context voorzien. Maar niet getreurd: het is waarschijnlijk goed mogelijk om het AI dit eerst zelf te laten doen in een voorbereidende stap. Ondertussen zijn er zelfs al commerciële tools hiervoor te vinden, die eveneens als agents optreden en hiervoor op de achtergrond óók van een LLM gebruik maken.

Bestaande code documenteren en beter begrijpbaar maken op deze manier, is nuttig voor een Agentic IDE, maar ook voor menselijke developers! Dit wordt de volgende onderzoekspiste in wat AI kan doen voor het programmeren…

Conclusie

Agentic IDEs zijn momenteel de ultieme incarnatie van door AI geassisteerd programmeren. Ze gaan een stuk verder dan enkel assisteren en kunnen in jouw plaats coderen, alsof je tegen een (onervaren) developer praat en deze voor jou het werk doet. Vibe Coding kan in de nabije toekomst een heel stuk van ons werk overnemen!

De enige nuance, die we eigenlijk altijd moeten maken bij AI: het is geen magie, het weet niet vanzelf precies wat er moet gebeuren, en je zal moeten bijsturen en context geven. Garbage in – Garbage out.

Er is dus zeker nog ruimte voor verbetering , maar als we zien hoe snel de technologie evolueert, zou die wel eens snel kunnen komen…