Les développeurs expérimentent aujourd'hui des approches très différentes pour travailler avec l'IA. Cette phase d'apprentissage traduit-elle une véritable évolution des pratiques de développement ?

Oui, nous sommes clairement dans une période de transition. Il n'existe pas encore de manière standardisée de développer avec l'IA. Certains développeurs continuent à programmer de manière traditionnelle en sollicitant ponctuellement un assistant IA. D'autres expérimentent le vibe coding, où l'IA génère une grande partie du code à partir d'instructions en langage naturel. À l'inverse, le spec-driven development repose sur des spécifications précises qui permettent de guider les agents vers des résultats plus fiables.

Les usages varient également selon les modèles. Certains privilégient Claude, d'autres GPT ou Gemini, et beaucoup passent de l'un à l'autre en fonction des tâches à réaliser. Cela soulève plusieurs questions : quel modèle utiliser pour quel besoin ? Comment les combiner efficacement ? Comment trouver le meilleur équilibre entre qualité des résultats, rapidité d'exécution et coûts d'utilisation ?

Aujourd'hui, chacun construit un peu sa propre méthode. Nous sommes encore dans une phase d'expérimentation où les bonnes pratiques restent à définir.

Cette multiplication des assistants IA et des modèles ne risque-t-elle pas de fragmenter le développement logiciel ?

C'est effectivement l'un des principaux défis. Les développeurs jonglent souvent entre plusieurs outils : leur IDE, GitHub Copilot, Claude Code dans un terminal, des agents exécutés localement ou encore différentes interfaces conversationnelles, comme ChatGPT ou Mistral AI. Chaque environnement possède son propre historique, son propre contexte et sa propre manière de fonctionner. Le développement devient rapidement fragmenté.

Chez JetBrains, notre approche consiste justement à réunifier cette expérience. Avec nos IDE, il est déjà possible de passer d'un modèle à un autre sans perdre le contexte du projet. Si un développeur commence une tâche avec Claude puis poursuit avec GPT ou Gemini, le nouvel agent retrouve immédiatement l'historique des échanges et comprend ce qui a déjà été réalisé. Le développeur peut ainsi choisir le modèle le plus pertinent selon la tâche, sans repartir de zéro à chaque changement.

Vous proposez également JetBrains Air, présenté comme un Agent Development Environment. En quoi cette approche se distingue-t-elle d'un IDE traditionnel ?

La philosophie est différente. L'IDE reste centré sur le développement interactif : le développeur écrit du code, l'analyse, le modifie et sollicite ponctuellement l'IA. JetBrains Air adopte une approche beaucoup plus AI first. L'objectif est de confier des tâches complètes à plusieurs agents capables de travailler en parallèle de manière autonome.

Le développeur ne pilote plus uniquement un assistant conversationnel. Il coordonne plusieurs agents qui avancent simultanément sur différentes parties d'un projet. On passe progressivement d'une logique d'assistance à une logique de collaboration avec l'IA.

Les environnements de développement agentique sont-ils appelés à remplacer les IDE ou ces deux approches sont complémentaires ?

Elles sont complémentaires, car elles répondent à des usages différents.
L'IDE reste indispensable pour explorer une base de code, analyser un comportement, vérifier précisément les modifications proposées ou intervenir manuellement sur des parties sensibles. Il permet notamment de comparer très facilement le code généré avec le code existant afin de conserver la maîtrise des changements.

JetBrains Air répond davantage à des contextes où l'objectif est d'accélérer le développement grâce à plusieurs agents autonomes qui travaillent en parallèle.
Dans des secteurs réglementés, comme la banque ou la finance, les exigences en matière de sécurité, de gouvernance et de validation restent très fortes. Les développeurs continueront donc à s'appuyer largement sur leur IDE pour contrôler les modifications proposées par les agents. À l'inverse, des start-up ou des équipes qui privilégient la rapidité d'exécution pourront davantage tirer parti d'un environnement orienté développement agentique.

Les modèles évoluent extrêmement vite. Comment éviter que les développeurs aient à remettre en question leurs pratiques à chaque nouvelle génération d'agents ?

L'objectif est justement de ne pas enfermer les développeurs dans un modèle particulier.
Les modèles progressent très rapidement et chacun possède ses points forts. Notre approche consiste à pouvoir intégrer facilement différents agents afin que les développeurs puissent choisir celui qui répond le mieux à leurs besoins sans bouleverser leur façon de travailler.

Cette flexibilité devient également essentielle lorsque plusieurs agents interviennent simultanément sur un même projet. L'un des défis consiste alors à coordonner leurs interventions afin d'éviter les conflits entre les modifications produites et à permettre aux développeurs de faire évoluer leurs pratiques sans dépendre d'une technologie unique.

Selon vous, de quoi dépend la qualité des résultats produits par un agent ?

On parle souvent de la puissance du modèle utilisé, mais en réalité le contexte joue un rôle tout aussi important.
L'un des avantages d'un IDE est qu'il connaît déjà le projet. Il a indexé le code et comprend les relations entre les fichiers, les références. Lorsqu'un agent travaille directement depuis un terminal, il doit souvent commencer par rechercher lui-même toutes ces informations avant de pouvoir agir.

En s'appuyant sur les fonctions natives d’un IDE comme JetBrains, les agents disposent immédiatement d'un contexte beaucoup plus riche. Ils trouvent plus rapidement les informations utiles, ce qui améliore la pertinence des réponses tout en réduisant les traitements inutiles.

Nous avons également constaté que cette meilleure compréhension du contexte a un impact direct sur les coûts. Plus l'agent reçoit rapidement les bonnes informations, moins il consomme de ressources pour les rechercher. Lors de nos expérimentations internes, cette approche a permis de réduire significativement le temps d'exécution de certaines tâches, mais aussi la consommation associée aux appels des modèles. À mesure que les coûts d'utilisation des LLM évolueront, la capacité à optimiser les traitements deviendra un enjeu de plus en plus important. C’est dans cette logique que JetBrains a récemment lancé JetBrains Context, une solution qui synthétise le contexte d’un projet ou d’un répertoire avant de partager les informations aux agents IA. L’objectif étant de réduire le temps d'exécution et le coût par tâche tout en améliorant la qualité du résultat.

Il ne faut pas oublier non plus que les modèles restent probabilistes. Deux requêtes similaires peuvent produire des résultats différents, tant en qualité qu'en temps de calcul ou en coût. Fournir davantage de contexte permet justement de guider plus efficacement l'agent vers le résultat attendu.

Existe-t-il aujourd'hui des bonnes pratiques pour développer efficacement avec des agents IA ?

Les bonnes pratiques sont encore en train d'émerger. Nous voyons apparaître de nouvelles approches, comme le spec-driven development, qui consiste à consacrer davantage d’efforts à définir précisément les spécifications et les règles que devront suivre les agents, plutôt qu'à produire soi-même chaque ligne de code. Cette démarche s'accompagne de nouveaux mécanismes, comme les fichiers agents.md ou skills.md, qui permettent de formaliser les instructions afin d'orienter le comportement des agents et d'obtenir des résultats plus fiables.

À quoi pourrait ressembler le quotidien d'un développeur d'ici trois à cinq ans ?

Difficile de prédire l’avenir étant donné la vitesse à laquelle la technologie évolue ! Je pense qu’une partie croissante des tâches sera confiée à des agents spécialisés, mais les développeurs conserveront un rôle essentiel pour définir les objectifs, valider les résultats et arbitrer les choix techniques.

Plus largement, le développeur devra apprendre à collaborer avec les agents. Son rôle ne consiste plus uniquement à écrire du code, mais aussi à fournir les bonnes instructions, structurer le contexte et organiser efficacement le travail entre plusieurs agents. La revue de code prendra également une place croissante : il lui reviendra de vérifier les productions de l'IA, d'en corriger les éventuelles erreurs et de garantir la qualité du code final. À terme, sa valeur reposera autant sur sa capacité à guider, coordonner et contrôler le travail des agents que sur sa maîtrise du code lui-même.