Aller au contenu principal
🤖Intelligence Artificielle
Bienvenue à bord du SDLC agentique : gardez la main jusqu'à l'atterrissage

Bienvenue à bord du SDLC agentique : gardez la main jusqu'à l'atterrissage

Axel LAYETAxel LAYET••
IA13 min

Le code n'est plus le goulot d'étranglement du développement. On ne se pose plus la question de savoir si l'IA sait écrire du code, elle le fait déjà. La valeur de l'IA dans la fabrication du logiciel se gagne, ou se perd, sur tout le reste de la chaîne du SDLC (pour Software Development Life Cycle, le cycle de vie du développement logiciel). Un SDLC agentique confie à des agents IA des pans entiers de ce cycle, du besoin métier jusqu'au run. Dans ce contexte, la valeur dépend d'une chose : la culture et les principes de chaque métier qui garde la main sur ses agents.

Sur mes missions comme dans les articles, je constate le même angle mort : on concentre l'IA sur le codage, parce que c'est le plus visible et le plus démonstratif, et on néglige la spécification, la conception, la revue, le run, la conformité.

Les chiffres cadrent l'enjeu. Sur le benchmark SWE-bench Verified, les meilleurs modèles sont passés d'environ 2 % de problèmes résolus en 2023 à 80,9 % fin 2025. Générer du code fiable est devenu un problème largement résolu. Le goulot s'est déplacé vers l'amont (spécifier le bon besoin) et vers l'aval (revue, run, conformité).

On quitte l'établi du mécanicien, où l'on visse chaque boulon à la main, pour le cockpit du pilote. Or, un pilote qui ne connaît pas a minima les principes de son moteur finit par crasher l'avion. La culture de son métier, c'est ce qui sépare le pilote du passager.

Bascule de l'établi du mécanicien au cockpit du pilote

En bref (TL;DR)

  • Le code n'est plus le goulot du développement : générer du code fiable est un problème largement résolu (SWE-bench Verified : environ 2 % de réussite en 2023, 80,9 % fin 2025).
  • Accélérer le code au x10 ne fait pas disparaître le travail. Le goulot se déplace vers l'amont (spécification) et vers l'aval (revue, run, conformité).
  • Le dividende ne tombe que si toute la chaîne de valeur, pas seulement les développeurs, sait absorber ce flux.
  • Ce qui garde la main sur les agents, à chaque maillon, c'est la culture et les principes du métier : poser les bons critères, exiger des tests, refuser un résultat bancal.
  • Par où commencer, sans acheter de licence : mesurer une baseline (cycle time, temps de revue, taux de rework) avant de passer à l'échelle.

Qu'est-ce que le SDLC agentique ?

Le SDLC agentique désigne un cycle de développement où des agents IA autonomes exécutent des pans entiers du travail (recherche, planification, codage, tests, revue, mise en production) sous la supervision d'un humain qui valide à chaque étape clé.

En 2026, la question n'est plus « l'IA peut-elle écrire du code ? » mais « comment l'orchestrer pour livrer du code de production ? »

Réussite des meilleurs modèles sur SWE-bench Verified Réussite sur SWE-bench Verified 0 %25 %50 %75 %100 % ≈ 2 %80,9 % 2023fin 2025 Source : SWE-bench, leaderboards publics, 2023-2025.

Un score de delivery de 80 % sur des tickets isolés ne signifie pas 80 % d'autonomie en production.

On ne produit plus le code, on pilote les agents

Un pilote supervise seul des instruments qui fonctionnent en autonomie

La valeur de chaque rôle se déplace, et pas seulement celle du développeur. Elle ne réside plus dans la production manuelle mais dans la capacité à cadrer l'intention, arbitrer les choix et contrôler la qualité de ce que l'agent produit. À chaque maillon, le travail s'organise en trois temps :

  • Humain, l'intention. On définit l'objectif, les contraintes, les critères de succès. Vrai pour une spec métier comme pour un plan de tests.
  • Agent, l'exécution. L'agent produit le livrable de l'étape (code, tests, documentation, diagnostic d'incident) en suivant le cadre reçu.
  • Humain, la validation. On relit, on vérifie la conformité, on signe. C'est l'humain qui signe, pas l'agent.

Pourquoi ce modèle tient-il ? Parce que le coût marginal d'une ligne de code s'effondre, tandis que le coût d'une mauvaise décision augmente. Quand le code est bon marché, ce sont les exigences mal spécifiées qui coûtent cher : elles produisent un résultat rapide mais faux, et font exploser le rework.

Le vrai changement de compétence n'est pas « savoir prompter ». C'est savoir, grâce à sa culture métier, formuler un critère de succès vérifiable pour une spec, un test ou un déploiement, et reconnaître un mauvais résultat en quelques minutes de lecture.

Le brevet de pilote : la culture métier qui garde la main

Cinq métiers différents, chacun pilotant son agent IA

Si l'exécution part à l'agent, que reste-t-il d'humain ? Le jugement : la capacité à cadrer l'agent et à reconnaître un mauvais résultat. Les développeurs ont un nom pour ça, la culture de dev : revue, tests, lisibilité, sécurité, conception. C'est elle qui permet de piloter un agent sans signer à l'aveugle. Le brevet de pilote, en somme : sans lui, on n'a rien à faire aux commandes. L'IA ne supprime pas ces réflexes, elle les rend vitaux.

Ce rôle n'est pas que défensif : le pilote ne fait pas que valider ou bloquer, il fait grandir l'agent : affiner son contexte, transformer les bonnes pratiques en règles et en skills réutilisables, lui donner de quoi vérifier son propre travail. Chaque cycle rend l'agent meilleur. Poser des garde-fous, oui, mais surtout outiller et faire progresser.

Ma conviction : la culture de dev n'est qu'un cas particulier. Sur toute la chaîne, chaque métier doit porter la culture et les principes de son propre métier pour cadrer ses agents : le PO sa discipline de specs, l'analyste sa rigueur sur la donnée, le juriste son exigence de conformité, l'ops sa culture de fiabilité.

À chaque maillon, la même mécanique : une expertise humaine qui garde la main et fait progresser une IA. C'est aussi ce qui résout la contrainte déplacée que nous verrons plus bas.

Une culture ne se décrète pas, elle s'acquiert au fil des cycles. On y monte par paliers : solo, équipe augmentée, entreprise, transformation. Le futur, ce n'est pas moins de spécialistes, c'est la culture de chaque métier diffusée sur toute la chaîne, où chacun devient garant de ce que produit son propre agent.

Phase par phase : un agent à chaque maillon du SDLC

Le SDLC va du besoin métier jusqu'au run où chaque maillon a désormais son agent, et chaque maillon a un humain qui joue les garde-fous. L'erreur la plus courante est de concentrer l'IA sur le code, là où elle est la plus visible, en oubliant que la valeur se gagne ou se perd sur l'ensemble de la chaîne.

La chaîne SDLC de bout en bout La chaîne SDLC : l'IA outille chaque maillon, mais inégalement Besoin Conception Codage Tests Revue Déploiement Run Maintenance ››››››› Bien outillé — inner loop (codage, tests) Moins outillé — outer loop (spec amont, run, maintenance) Source : rapport DORA, 2025.

Besoin et spécification, piloté par le PO ou le métier

La phase la moins outillée, et pourtant la plus déterminante : c'est là que se décide quoi construire. Les approches spec-driven (GitHub Spec Kit, AWS Kiro) transforment un brief métier en spécification exécutable qui sert de contrat à l'agent. Ici, le garde-fou n'est pas un développeur mais le PO ou l'expert métier : un besoin sous-spécifié produit un code rapide et faux.

Conception et architecture, piloté par l'architecte

Les agents proposent des architectures, mais l'arbitrage reste humain. C'est ici que se joue la dette future : une décision documentée dans le contexte évite à l'agent de répéter la même erreur dix fois. Avec Claude Code, le plan mode force l'agent à exposer son plan avant d'écrire la moindre ligne.

Codage, piloté par le développeur

La phase la mieux couverte. Claude Code, GitHub Copilot coding agent, Cursor et Devin dominent. Le basculement est documenté : l'analyse Anthropic d'environ 400 000 sessions Claude Code (octobre 2025 à avril 2026) montre que l'humain prend l'essentiel des décisions de planification, le quoi, pendant que l'agent prend celles d'exécution, le comment (Anthropic, Economic Index, mars 2026). La frontière producteur/pilote est devenue mesurable.

Tests et QA, piloté par le QA

Les agents génèrent des tests à grande échelle. Meta a déployé ACH, un générateur guidé par mutation : appliqué à 10 795 classes Android, il a produit 571 tests, dont 73 % acceptés par les ingénieurs (Meta, Mutation-Guided LLM-based Test Generation, arXiv 2501.12862, 2025). Le garde-fou QA est crucial : un test généré qui valide un comportement incorrect donne une fausse assurance.

Revue, piloté par le pair ou le tech lead

72,6 % des développeurs qui utilisent la revue de code Copilot disent qu'elle a amélioré leur efficacité (GitHub, Octoverse 2025). Mais la précision des agents reste imparfaite, et nous verrons que la revue devient justement le nouveau goulot de toute la chaîne.

Déploiement et run, piloté par l'ops ou le SRE

Phase émergente, côté outer loop. L'agent SRE d'Azure (le SRE, Site Reliability Engineer, est l'ingénieur garant de la fiabilité en production) a traité plus de 35 000 incidents en interne et fait tomber le délai de mitigation d'un service de 40,5 heures à 3 minutes, pour plus de 50 000 heures d'ingénieurs économisées (Microsoft, Azure SRE Agent, 2026). Spectaculaire, mais réservé aux organisations dont l'observabilité est déjà mature.

Maintenance et évolution, piloté par toute l'équipe

Le maillon le plus durable et le plus négligé. Migrations, montées de version, correction de dette, documentation : autant de tâches répétitives où les agents excellent, à condition d'un cadre clair. C'est aussi là que se paie, ou s'évite, la dette technique accumulée en amont.

Le x10 sur le code est réel, encore faut-il le convertir

La rupture de vélocité est réelle : sur des tâches cadrées, l'accélération est spectaculaire, et les capacités n'ont fait que progresser depuis le premier essai contrôlé GitHub/MIT de 2023, qui mesurait déjà +55,8 % de vitesse avec Copilot (Peng et al., arXiv 2302.06590).

Avec les modèles de 2026, le x10 de vélocité sur un périmètre bien défini n'est plus un slogan mais cette vélocité ne se convertit pas seule en valeur livrée. METR a mené un essai contrôlé randomisé rigoureux : 16 développeurs expérimentés, 246 tâches, dans leurs propres dépôts matures. Résultat, ils étaient 19 % plus lents avec l'IA, tout en estimant avoir gagné 20 % (METR, juillet 2025).

La mise à jour de février 2026 nuance le chiffre, et la réplication a buté sur des développeurs qui refusaient désormais de coder sans IA. La leçon tient quand même : la vitesse brute, sans culture de dev pour cadrer l'agent sur un dépôt réel, se retourne contre vous. C'est ce qu'on observe sur le terrain.

Effet de l'IA sur la vitesse de développement Effet de l'IA sur la vitesse de développement +55,8 %−19 % GitHub/MIT — 2023tâche jetable METR — 2025dépôts réels matures Sources : Peng et al. GitHub/MIT (arXiv 2302.06590) ; METR (2025). Tâche jetable contre dépôts réels.

Le paradoxe se confirme à l'échelle organisationnelle. Faros AI, sur plus de 10 000 développeurs et 1 255 équipes, mesure +98 % de PR mergées dans les équipes à forte adoption, mais aussi +91 % de temps de revue, et aucune amélioration mesurable des métriques DORA d'équipe (Faros AI, AI Engineering Report : The Acceleration Whiplash, 2026).

Les gains individuels s'évaporent au niveau du système et la cause est mathématique. La loi d'Amdahl est implacable : si le codage ne représente que 25 à 35 % du cycle, alors même un codage infiniment rapide ne réduit le temps total que de 15 à 25 %. Le x10 sur le code ne devient jamais un x10 sur la livraison.

Accélérer le code au x10 ne supprime pas le goulot, ça le déplace, le plus souvent vers l'amont métier (spécifier le bon besoin) et vers l'aval (revue, run). La vraie question n'est pas « de combien l'IA code-t-elle plus vite ? » mais « toute la chaîne de valeur, pas seulement les développeurs, sait-elle absorber ce flux ? »

La contrainte s'est déplacée : Goldratt appliqué au SDLC

Des flux de code s'engorgent à un goulot humain signalé en rouge

La théorie des contraintes d'Eliyahu Goldratt énonce une loi simple : tout système est limité par une seule contrainte, et accélérer un maillon qui n'est pas le goulot ne fait que gonfler la file d'attente devant le vrai goulot. Appliquée au SDLC agentique, elle explique beaucoup.

Le code était historiquement le goulot, l'IA l'a desserré. La contrainte s'est donc déplacée, et elle est désormais largement humaine.

  1. La revue de code devient le goulot. Chez Salesforce, le volume de code a bondi de 30 % et les PR dépassent régulièrement 20 fichiers et 1 000 lignes ; la latence de revue grimpe, et le temps passé sur les plus grosses PR plafonne, signe que les relecteurs décrochent (Salesforce Engineering, Scaling Code Reviews, 2026). La charge retombe sur les seniors, détournés du design et du mentorat.
  2. Les pipelines CI/CD montent en pression. Le débit explose : chez les équipes du top 5 %, le nombre de workflows quotidiens a quasi doublé en un an (6,8 puis 13,4), sur près de 28 millions de runs analysés (CircleCI, 2026 State of Software Delivery). Des systèmes de validation rarement conçus pour ce rythme.
  3. L'instabilité du run augmente. DORA (le programme de recherche DevOps Research and Assessment de Google, référence sur la performance des équipes de développement) constate qu'« avec une adoption IA, l'instabilité de livraison croît, car les systèmes sous-jacents n'ont pas évolué pour gérer en sécurité un développement accéléré ».

En résumé, on accélère le maillon déjà le plus rapide, produire du code, pendant qu'on empile devant le vrai goulot tout ce qu'aucune machine ne fait à notre place : comprendre, vérifier, maintenir. La dernière contrainte n'est pas la vitesse de la machine, c'est notre bande passante cognitive.

Ce qui marche vraiment : discipliner l'agentique

Un constat revient sur toutes mes missions : l'IA agit comme un révélateur. Elle démultiplie les forces d'une organisation saine et les faiblesses d'une autre. Si la revue est déjà un goulot, plus de volume créera plus de délai ; si le pipeline est fragile, il cassera plus souvent.

Tableau d'instruments d'avion relié, évoquant garde-fous et checklist avant vol

Trois leviers font la différence, quel que soit l'outil.

1. Le context engineering, le « harnais ». Le contexte compte plus que le prompt. Règles maison (un fichier CLAUDE.md ou équivalent), hooks de vérification automatique, skills partagés : tout cet outillage est versionné dans Git, au même titre que le code. Résultat : une répétabilité parfaite pour toute l'équipe, et zéro friction. Chaque skill publié profite à tous.

2. La boucle Explore, Plan, Code, Verify. C'est la pratique à plus fort levier selon Anthropic pour Claude Code : donner à l'agent un moyen de vérifier son propre travail (Anthropic, 2026 Agentic Coding Trends Report). Sans critères de succès vérifiables, l'agent produit du code qui a l'air correct et qui, souvent, ne l'est pas. En pratique : Opus pour planifier, Sonnet ou Haiku pour exécuter, un humain à chaque porte.

3. L'effet compound, capitaliser. Chaque bug résolu, chaque décision d'architecture est documentée dans le contexte pour que l'IA ne répète jamais la même erreur. Chaque cycle devient un peu plus rapide que le précédent. C'est une croissance composée, pas un gain ponctuel.

Reste l'erreur stratégique la plus fréquente : croire que l'adoption se résume à un achat de licences. Ma règle, héritée des grands programmes de transformation : 70 % de l'effort va aux personnes, aux process et à la culture ; 20 % à la donnée ; 10 % seulement à la technique.

Orchestrer une flotte d'agents

Une escadrille d'avions autonomes dirigée depuis le sol par un contrôleur radar humain

Si votre équipe maîtrise déjà la boucle plan, execute, verify, l'étape suivante est l'orchestration parallèle, et elle exige une discipline supplémentaire.

L'idée : faire travailler plusieurs agents en parallèle sur des tâches isolées (un git worktree par agent évite les conflits), avec des sous-agents spécialisés. Un sous-agent security-reviewer relit chaque diff sensible, un autre vérifie la couverture de tests. La revue redevient adversariale : un agent cherche activement à réfuter le travail d'un autre avant qu'il n'atteigne un humain.

Le prérequis non négociable est d'avoir des filets de sécurité déterministes qui scalent à la vitesse machine. Type checkers stricts, linters, analyse statique, tests de propriété, contract tests, CI/CD rigoureux. Ils déplacent les vérifications de base hors des yeux humains, pour que la revue humaine se concentre sur l'intention, l'architecture et la logique métier, les seules choses qu'un agent ne peut pas valider seul.

Le conseil des praticiens du secteur : « pariez sur le pattern, pas sur un outil spécifique ». Spec Kit, AI-DLC, la boucle de Claude Code convergent tous vers le même enchaînement : research, plan, execute, review, ship, l'humain en supervision à chaque étape.

Par où commencer

Cockpit à l'aube face à une piste, avec une checklist avant décollage

Votre première action ne demande aucune licence : mesurez. Sans baseline, vous ne pourrez jamais attribuer quoi que ce soit à l'IA.

  • Figez vos baselines (semaines 1 à 4). Mesurez le cycle time, le taux de rework, le temps de revue des PR et le change failure rate avant tout déploiement large. Taggez le code généré par IA dans votre gestion de versions.
  • Identifiez votre vrai goulot. Faites un Value Stream Mapping. N'accélérez pas le code si la revue ou la QA sont déjà saturées : vous ne feriez qu'allonger la file d'attente en aval.
  • Disciplinez l'amont. Pour tout travail non trivial, imposez une spec revue avant génération. Définissez les exigences de sécurité avant le code, jamais après.

Une crainte revient souvent : « l'IA va ralentir mon équipe au début ». C'est vrai, et c'est normal. La prochaine frontière n'est pas un meilleur modèle, c'est une meilleure orchestration. Commencez par figer une baseline cette semaine : c'est gratuit, et c'est la seule façon de savoir si l'IA vous fait vraiment avancer.

Sources

Partager

Continuer votre exploration

Découvrez d'autres articles du cluster agents-systemes-agentiques dans l'univers Intelligence Artificielle

Explorer tous les articles Intelligence Artificielle