Agentic Data & Software Engineering

La productivité avec l'IA de votre équipe se mesure dans Git, pas en enquêtes

Par Xavier Franco, CEO de Elternativa · Grupo Zemsania
· 6 min de lecture

Rédigé avec l’aide de l’IA et relu par Xavier Franco

Souche d’un arbre fraîchement coupé en forêt, avec ses cernes de croissance bien marqués, certains plus larges et d’autres plus étroits.
Dans cet article

Si vous demandez à votre équipe de développement si l’IA la rend plus productive, il y a fort à parier qu’elle vous répondra que oui. Et elle le croit probablement sincèrement. Le problème, c’est que le croire et le mesurer ne sont pas la même chose. Je le formule ainsi : la productivité avec l'IA de votre équipe ne se mesure ni dans des enquêtes ni dans des impressions. Elle se mesure dans votre Git.

La perception trompe, et beaucoup

Une étude le montre mieux que n’importe quel argument. En 2025, METR a mené un essai contrôlé avec 16 développeurs expérimentés de projets open source, sur 246 tâches réelles. Avec l’IA, ils ont mis 19 % de temps en plus pour les terminer.

Ce qui est intéressant, c’est ce qu’ils pensaient. Avant de commencer, ils s’attendaient à ce que l’IA les rende 24 % plus rapides. Et après avoir fini, alors que le retard était déjà mesuré, ils croyaient toujours que l’IA les avait accélérés de 20 %.

Je n’en conclus pas que l’IA ne sert à rien. L’étude est un cas précis, avec ses limites. J’en conclus autre chose : si les personnes qui l’ont vécu ne l’ont pas bien perçu, une enquête interne ne vous dira pas la vérité.

Concrètement : avant de lancer une enquête sur l’IA, décidez quelle donnée de votre dépôt confirmera ou démentira ce que l’on vous répondra.

Que mesurer : les métriques DORA

Pour mesurer la livraison logicielle, il existe déjà un standard très établi : les métriques DORA. Elles regroupent cinq indicateurs en deux blocs.

Performance de livraison :

  • Délai de livraison d’un changement : du moment où il est enregistré dans le contrôle de version jusqu’à sa mise en production.
  • Fréquence de déploiement : combien de déploiements vous faites sur une période.
  • Temps de rétablissement après un déploiement en échec.

Stabilité :

  • Taux de changements en échec : quelle part des déploiements nécessite une intervention immédiate.
  • Taux de reprise : quelle part des déploiements n’était pas planifiée et provient d’un incident en production.

L’avantage de ces métriques, c’est qu’elles sortent de ce que vous avez déjà : votre Git, vos pull requests et votre CI/CD. Elles ne dépendent pas de ce dont chacun se souvient.

Vitesse sans stabilité, ce n’est pas de la productivité

Voici le piège le plus fréquent. L’IA fait sortir plus de code, plus vite. Si vous ne regardez que la vitesse, tout semble aller mieux.

Mais le rapport DORA 2025 le met en garde : l’adoption de l’IA améliore la performance de livraison, mais elle reste négativement liée à la stabilité. Plus de changements, sans contrôles solides, conduisent à plus d’instabilité.

C’est pourquoi il faut regarder les deux blocs en même temps. Si vous livrez deux fois plus mais que la moitié revient sous forme d’incident, vous n’avez rien gagné : vous avez simplement déplacé le travail.

Concrètement : mettez sur le même tableau de bord la fréquence de déploiement et le taux de changements en échec. Si l’une monte et l’autre aussi, il faut en parler.

Avec et sans IA, dans le même dépôt

La question qui intéresse vraiment celui qui dirige est : combien de plus mon équipe livre-t-elle avec l’IA que sans elle ? Et pour y répondre, il faut comparer dans le même dépôt.

Cela suppose de savoir quelle livraison vient d’un flux avec IA et laquelle n’en vient pas. Sans ce marquage, tout se mélange. C’est pourquoi, dans notre méthode, chaque tâche est tracée : qui l’a réalisée, combien de temps elle a pris et si elle a passé la validation. Et le tableau de bord de performance montre, mesuré sur votre propre dépôt :

  • Le multiplicateur réel : livraisons hebdomadaires avec et sans la méthode.
  • Quelle part fait l’IA : le pourcentage de livraisons issues du flux avec IA.
  • L’agilité : le temps jusqu’à l’intégration et la validation, et son évolution chaque mois.
  • Vers la production : les déploiements et les validations signées par des personnes.

Ce qu’il ne faut pas mesurer

Il est tout aussi important de savoir ce qu’il ne faut pas regarder :

  • Les lignes de code. L’IA en écrit beaucoup. Plus de lignes ne signifie pas plus de valeur ; parfois c’est le contraire.
  • Le nombre de requêtes à l’IA. Cela mesure l’usage, pas le résultat.
  • Les heures « économisées » selon chaque personne. Nous avons déjà vu à quel point la perception est fiable.

Ce qui compte, c’est ce qui arrive en production, validé et stable.

Concrètement : si quelqu’un vous présente un rapport de productivité avec l'IA fondé sur les lignes de code, demandez le même rapport avec les déploiements et les changements en échec.

Comparer avec vos données, pas avec des promesses

Ce que je propose, c’est toujours la même chose : ne vous fiez ni à nos chiffres ni à ceux de personne. Comparez avec vos données. Choisissez un service que vous avez déjà, exécutez-le en parallèle avec une IA orchestrée sur un périmètre délimité et comparez coût, délai et qualité dans votre propre dépôt.

Au final, Git n’a pas d’opinion. Il enregistre ce qui a été intégré, quand et combien de fois il a fallu revenir en arrière.

Par où commencer

  1. Établissez la ligne de base des métriques DORA des derniers mois.
  2. Marquez quelles livraisons viennent d’un flux avec IA.
  3. Regardez vitesse et stabilité ensemble, jamais séparément.
  4. Écartez les métriques de vanité, comme les lignes de code.
  5. Comparez avec et sans IA sur un périmètre délimité, avec vos données.

Comment nous vous aidons

Chez Agentic Data & Software Engineering, nous orchestrons les IA de développement que vous avez déjà sur l’ensemble du SDLC, et nous commençons sur un service que vous avez déjà : nous l’exécutons en parallèle, sur un périmètre délimité, et nous comparons avec vous coût, délai et qualité avec vos données.

Nous le faisons avec Agentagile, notre méthodologie pour développer avec l’IA, qui mesure la productivité dans votre Git : livraisons avec et sans IA, quelle part fait l’IA, temps jusqu’à l’intégration et la validation, et déploiements signés par des personnes.

Questions fréquentes

Comment mesure-t-on la productivité avec l'IA en développement ?

Avec les données du dépôt et du CI/CD, comme les métriques DORA, en comparant les livraisons issues d’un flux avec IA à celles qui n’en viennent pas.

Que sont les métriques DORA ?

Cinq indicateurs de livraison logicielle : délai de livraison d’un changement, fréquence de déploiement, temps de rétablissement, taux de changements en échec et taux de reprise.

Les enquêtes servent-elles à mesurer la productivité avec l'IA ?

Comme complément, mais pas comme mesure : dans l’étude de METR, les développeurs croyaient aller 20 % plus vite alors qu’ils mettaient en réalité 19 % de temps en plus.

Les lignes de code mesurent-elles la productivité ?

Non. L’IA génère beaucoup de code ; ce qui compte, c’est ce qui arrive en production, validé et stable.

Continuer la lecture