Série d'entretiens avec le professeur Eran Yahav, cofondateur et codirecteur général de Tabnine.

Professeur Eran YahavCofondateur et codirecteur général de Tabnine, il est professeur d'informatique au Technion – Institut de technologie d'Israël. Ses recherches portent sur les langages de programmation, l'apprentissage automatique et le génie logiciel, notamment la synthèse de programmes et l'analyse de code à grande échelle. Parallèlement à ses activités universitaires, il a cofondé Tabnine (anciennement Codota) afin de concrétiser des années de recherche en outils pratiques pour les développeurs, contribuant ainsi à l'essor de la complétion et de l'automatisation du code pilotées par l'IA. Ses travaux font le lien entre le monde académique et l'industrie, avec pour objectif de rendre le code généré par l'IA plus fiable, plus sûr et plus adapté au contexte des environnements d'entreprise réels.

tabnine Tabnine est une plateforme de codage basée sur l'IA, conçue pour accompagner les développeurs tout au long du cycle de vie du développement logiciel, de l'écriture et du débogage du code à la génération de tests et de documentation. Lancée initialement comme un outil de complétion de code, elle est devenue une plateforme d'entreprise plus large intégrant l'IA générative et les flux de travail basés sur des agents. Elle permet aux équipes d'automatiser les tâches de développement complexes tout en garantissant un contrôle rigoureux de la confidentialité, de la sécurité et de la conformité. Compatible avec des dizaines de langages de programmation et s'intégrant aux principaux IDE, Tabnine vise à améliorer la productivité des développeurs tout en assurant la fiabilité du code généré par l'IA et sa conformité aux normes de l'entreprise.

Vous avez consacré des années à la recherche en analyse et synthèse de programmes au Technion et avez auparavant travaillé chez IBM Research. Quel problème de développement logiciel vous a convaincu de cofonder Tabnine, et comment vos recherches universitaires ont-elles influencé la vision initiale de l'entreprise ?

Mes travaux universitaires portaient sur l'analyse et la synthèse de programmes, c'est-à-dire l'apprentissage automatique du code. J'ai réalisé mon doctorat en analyse de programmes et c'est également dans ce domaine que j'ai effectué mes premières années de recherche appliquée. L'étude des problèmes de qualité logicielle par l'analyse de programmes a mis en évidence la difficulté à résoudre certains problèmes une fois le programme mal écrit. Mieux vaut prévenir que guérir. Cela m'a convaincu que la synthèse de programmes est la méthode la plus appropriée pour garantir la qualité logicielle, domaine auquel j'ai consacré la majeure partie de mon temps et de mon énergie de recherche.

J'ai d'abord travaillé sur la synthèse de programmes concurrents, en essayant d'automatiser la création de programmes concurrents à partir de programmes séquentiels. Je me suis ensuite orienté vers une synthèse de programmes plus générale utilisant l'apprentissage automatique.

La synthèse de programmes par apprentissage automatique était également l'idée fondamentale à la base de Tabnine. Cette idée, qui paraît aujourd'hui évidente, consistait à permettre aux modèles d'apprendre des schémas de codage directement à partir de vastes corpus de code et d'assister les développeurs en temps réel. Ce principe général s'applique à toutes les étapes du cycle de vie du développement logiciel : de la création du code à sa revue, en passant par le déploiement et au-delà.

Notre vision a toujours été d'assister les développeurs en leur fournissant des outils qui accélèrent le processus de développement et en fluidifient les processus. Le développement logiciel est une discipline créative et axée sur la résolution de problèmes ; l'objectif était que l'IA simplifie le processus en prenant en charge les tâches répétitives et en aidant les développeurs à rester concentrés. Cette vision nous guide encore aujourd'hui, même si la technologie a considérablement évolué depuis ses débuts.

Tabnine a été pionnière dans le domaine des assistants de programmation IA des années avant que l'IA générative ne se généralise avec des outils comme les modèles d'OpenAI. Rétrospectivement, comment le rôle de l'IA dans le développement logiciel a-t-il évolué depuis ces débuts, et quelles leçons l'industrie a-t-elle tirées de la première génération de copilotes de programmation ?

La première génération d'assistants de codage IA était principalement axée sur la prédiction. Il s'agissait essentiellement de systèmes de saisie automatique avancés qui aidaient les développeurs à écrire du code plus rapidement en prédisant la ligne ou la fonction suivante.

Ce qui a changé avec les boucles d'agents, c'est que l'IA peut désormais gérer des tâches avec une plus grande autonomie, au point que l'on peut considérer les agents (avec un encadrement approprié) comme des développeurs juniors indépendants.

Mais cela a aussi permis au secteur de tirer une leçon importante : la simple capacité d’un modèle ne suffit pas au développement de logiciels d’entreprise. Les modèles entraînés sur des données publiques peuvent produire des résultats impressionnants, mais ils ne tiennent souvent pas compte de l’architecture, des dépendances et des conventions de l’organisation.

C’est pourquoi la prochaine étape de l’évolution ne consiste pas seulement à utiliser des modèles plus grands ou des fenêtres de contexte plus larges, mais à relier ces modèles au contexte réel dans lequel les logiciels sont construits.

De nombreuses entreprises constatent que le déploiement à grande échelle d'agents d'IA exige plus que de simples modèles plus grands : il requiert un contexte organisationnel plus approfondi. Pourquoi pensez-vous que le contexte devient le véritable enjeu d'un développement fiable piloté par l'IA ?

Les systèmes logiciels sont des réseaux complexes de relations. Une seule modification peut affecter plusieurs services, API ou composants en aval.

Les modèles d'IA actuels excellent dans la génération de code plausible, mais ils fonctionnent souvent sans une compréhension structurée des relations entre ces relations. Sans cette compréhension, l'IA ne peut pas raisonner de manière fiable sur les conséquences d'une modification.

Les entreprises constatent que la fiabilité des systèmes d'IA dépend de la qualité du contexte dans lequel ils opèrent. Si un système d'IA comprend l'architecture du système, les dépendances entre les services et les normes de codage de l'organisation, il peut générer un code bien plus conforme au fonctionnement réel de ce système.

En ce sens, le contexte devient la prochaine frontière du développement de l'IA en entreprise.

Votre nouveau moteur de contexte d'entreprise vise à doter les agents d'IA d'une compréhension structurée de l'architecture, des dépendances et des pratiques d'ingénierie d'une organisation. En quoi cette approche diffère-t-elle des méthodes courantes telles que la génération augmentée par récupération, sur lesquelles s'appuient actuellement de nombreuses entreprises ?

La génération augmentée par la recherche est une technique utile. Elle permet aux modèles d'intégrer des documents ou des extraits de code pertinents lors de la génération d'une réponse.

Mais la simple récupération d'informations ne permet pas de comprendre. Elle donne accès à l'information, pas à une structure.

Le moteur de contexte d'entreprise est conçu pour aller plus loin en construisant une représentation structurée de l'environnement logiciel. Il analyse les référentiels, les services, les dépendances, les API et les relations architecturales et les organise dans un modèle du fonctionnement réel du système.

Cela permet aux systèmes d'IA de raisonner sur les relations entre les composants plutôt que de simplement extraire des fragments de texte. Dans les environnements d'entreprise complexes, cette distinction est cruciale.

Les outils de programmation basés sur l'IA évoluent, passant de la simple saisie semi-automatique à des agents autonomes capables d'exécuter des flux de travail complexes. Comment voyez-vous l'évolution de l'équilibre entre les développeurs humains et les systèmes automatisés au cours des cinq prochaines années ?

Les agents d'IA prendront de plus en plus en charge les tâches de développement courantes. Ils sont déjà capables de mettre en œuvre des fonctionnalités de bout en bout, y compris les tests et la documentation. Chaque développeur deviendra chef d'équipe de développeurs IA. Le principal défi consistera à communiquer les exigences à cette équipe et à vérifier que les livrables produits correspondent aux exigences définies.

Cependant, le développement logiciel repose fondamentalement sur la résolution de problèmes et la conception. Les développeurs humains continueront de définir l'architecture, de faire des compromis et d'orienter la direction générale des systèmes.

Ce qui va changer, c'est le niveau d'abstraction auquel travaillent les développeurs. Au lieu de se concentrer sur le code, ils orchestreront de plus en plus des flux de travail de haut niveau et collaboreront avec des systèmes d'IA qui exécuteront certaines parties de ces flux.

Autrement dit, le rôle des développeurs devient plus stratégique à mesure que l'IA prend en charge une plus grande partie du travail mécanique.

Tabnine a indiqué que les entreprises peuvent constater des taux d'acceptation du code généré par l'IA atteignant environ 80 % dans certains environnements. Quels indicateurs les organisations devraient-elles utiliser pour déterminer si les outils de codage IA améliorent réellement la productivité des développeurs plutôt que de simplement générer plus de code ?

La question essentielle n'est pas de savoir quelle quantité de code l'IA génère, mais quelle quantité de travail utile elle produit réellement.

Les organisations devraient suivre plusieurs indicateurs. Parmi eux, le taux d'acceptation dès la première tentative, qui mesure la fréquence à laquelle le code généré par l'IA peut être utilisé sans modification. Un autre indicateur est le délai de révision, c'est-à-dire le nombre d'itérations nécessaires avant qu'une demande de fusion puisse être acceptée.

Les organisations devraient également examiner le temps que les développeurs consacrent aux corrections, ainsi que le délai de mise en œuvre des modifications entre le développement et la production.

Si les outils d'IA améliorent réellement la productivité, vous devriez constater des améliorations sur tous ces indicateurs. Les développeurs consacrent moins de temps à corriger le code généré et plus de temps à des tâches à plus forte valeur ajoutée.

Les entreprises restent prudentes quant à l'exposition de leur code propriétaire à des modèles externes. Comment le concept de « codage IA de confiance » répond-il aux préoccupations de gouvernance, de confidentialité et de conformité qui ont freiné l'adoption des outils de développement d'IA par les entreprises ?

La confiance est l'un des facteurs les plus importants dans l'adoption de l'IA par les entreprises.

La confiance est le défi ultime pour la mise en œuvre de l'ingénieur IA. Comment s'assurer que l'ingénieur IA agisse de manière autonome pour accomplir des tâches critiques de développement logiciel ? Comment garantir que ses actions soient conformes à nos exigences en matière de qualité, de sécurité et de respect de nos politiques ? Pour que l'ingénieur IA soit pleinement intégré à nos équipes d'ingénierie, il doit inspirer autant confiance que nos collègues, rigoureusement sélectionnés et correctement formés.

Relever ce défi repose sur deux piliers essentiels :

• Personnalisation: Fournir à l'ingénieur en IA une compréhension approfondie de votre organisation, de votre base de code et de vos meilleures pratiques.
• Contrôle: Mise en place de systèmes robustes pour garantir que tout le code, qu'il soit généré par l'IA ou écrit par l'homme, réponde aux normes de qualité, de sécurité, de performance et de fiabilité de votre organisation.

De plus, le codage IA de confiance implique de donner aux organisations le contrôle sur la manière dont l'IA est déployée et de garantir une gouvernance et un contrôle centralisés.

Vous avez suggéré que le contexte organisationnel pourrait devenir une couche fondamentale de l'architecture d'IA d'entreprise, à l'instar des bases de données ou de l'infrastructure cloud des époques informatiques précédentes. À quoi ressemblera cette future architecture ?

Si l'on observe l'évolution des technologies d'entreprise, on constate souvent l'émergence de nouvelles couches d'infrastructure.

Les bases de données sont devenues la base de la gestion des données. Les plateformes cloud sont devenues la base de l'exécution d'applications à grande échelle.

À l’ère de l’IA, les organisations auront besoin d’une infrastructure permettant aux systèmes d’IA de comprendre la structure interne de l’entreprise : ses systèmes, ses relations et ses contraintes opérationnelles.

Cette couche d'infrastructure fournira un contexte structuré que plusieurs systèmes d'IA pourront utiliser, qu'il s'agisse d'assistants de programmation, d'agents de support ou d'outils d'automatisation opérationnelle.

En ce sens, le contexte devient un socle commun pour l'IA d'entreprise.

De nombreuses entreprises développent des assistants de programmation étroitement liés à un modèle de base unique. Tabnine, en revanche, permet aux entreprises de connecter différents modèles selon leurs besoins. Pourquoi la flexibilité des modèles est-elle importante pour l'évolution à long terme des outils de développement d'IA en entreprise ?

L'écosystème de l'IA évolue très rapidement. De nouveaux modèles sont fréquemment mis sur le marché, et différents modèles présentent souvent des atouts dans différents domaines.

Les entreprises ne devraient pas avoir à repenser leurs processus de développement à chaque évolution des modèles. En leur permettant de choisir et de passer d'un modèle à l'autre, nous leur offrons la flexibilité nécessaire pour pérenniser leur stratégie d'IA.

La flexibilité du modèle permet également aux organisations d'équilibrer les performances, les coûts, les exigences en matière de confidentialité et les contraintes de déploiement.

À long terme, les entreprises évolueront probablement dans un environnement multi-modèles, et les plateformes de développement devront être conçues en tenant compte de cette réalité.

Pour les directeurs techniques et les responsables de l'ingénierie qui évaluent aujourd'hui les plateformes de développement d'IA, quelles sont les plus grandes erreurs commises par les organisations lors du déploiement d'outils de codage d'IA, et comment peuvent-elles les éviter ?

Une erreur fréquente consiste à se concentrer uniquement sur les capacités du modèle. Les modèles plus complexes sont certes essentiels, mais leur fiabilité en situation réelle dépend de la capacité de l'IA à comprendre le système dans lequel elle opère.

Une autre erreur consiste à déployer des outils d'IA sans tenir compte des exigences de gouvernance et de sécurité. Les entreprises ont besoin de politiques claires concernant l'accès au code, le déploiement des modèles et la validation des résultats.

Enfin, les organisations s'attendent parfois à ce que l'IA génère des gains de productivité immédiats sans adapter leurs flux de travail ni fournir un contexte suffisant. Les déploiements réussis impliquent généralement d'intégrer l'IA aux processus de développement existants et de la connecter au code et à l'architecture de l'organisation.

Lorsque ces éléments se conjuguent, l'IA peut devenir un puissant accélérateur de développement logiciel plutôt qu'un simple outil de plus.

Merci pour cette excellente interview, les lecteurs qui souhaitent en savoir plus devraient visiter tabnine.