Développement et Ingénierie logicielle assistés par l'IA : Du Spec-Driven Development à l'orchestration d'agents

Cette formation de 2 jours couvre l'intégralité du spectre de l'ingénierie logicielle assistée par l'IA : de la rédaction de spécifications à l'orchestration d'agents, en passant par la sécurité, la gestion du contexte, l'intégration CI/CD et l'intégration de l'IA sur des projets existants. Vos équipes repartiront avec des méthodes, et outils directement applicables à leurs projets.

C'est une approche ancrée dans le Spec-Driven Development, mais qui va bien au-delà. Agents autonomes, orchestration multi-agents, MCP, CI/CD augmentée, gestion de la dette technique, modèles locaux : chaque dimension de l'ingénierie logicielle moderne est couverte, avec pour fil rouge constant la question de la qualité et de la maîtrise.

Est inclus dans ce cours un module unique sur les modèles locaux et la confidentialité, pensé pour les environnements soumis à des contraintes réglementaires fortes : médical, défense, juridique, finance…etc

Une clôture lucide sur la productivité réelle de l'IA, avec des données indépendantes et un cadrage honnête sur les risques (atrophie des compétences, dette technique, hallucinations) pour que vos équipes restent les pilotes de leur code.

Durée : 2 jours, soit 14 heures.

• Composée à 50% de pratique, cette formation utilise des exercices illustrés et didactiques, une mise en situation sur des cas pratiques réels.
• Chaque module théorique est suivi d'un lab ou d'une démonstration sur des cas réels. Les stagiaires manipulent les outils, écrivent des spécifications, orchestrent des agents et implémentent un serveur MCP (ils ne sont pas uniquement en mode observateur).
• Une évaluation régulière de l'acquisition des connaissances de chaque chapitre est effectuée auprès de chaque participant.
• Une synthèse est proposée en fin de formation.
• Une évaluation à chaud sera proposée au stagiaire à la fin du cours.
• Un support de cours sera remis à chaque participant comprenant les slides sur la théorie, les exercices et leurs corrigés.
• Une feuille d'émargement par demi-journée de présence est fournie en fin de formation ainsi qu'une attestation de fin de formation si le stagiaire a bien assisté à la totalité de la session.
• Un suivi et un échange avec les participants seront mis en place quelques jours après la formation.
• Cette formation peut être animée en présentiel ou en distanciel (classe virtuelle avec formateur).
• Elle peut être organisée en journées non consécutives, en laissant du temps entre chaque jour de formation (quelques jours/semaines/mois de pratique terrain) pour une meilleure montée en compétences.

• Maîtriser le workflow Spec-Driven Development. De l'idée initiale à la mise en production, en passant par la spécification, la planification et l'implémentation assistée.
• Produire des spécifications exploitables par les agents. Formats BDD, EARS et ADR pour des specs structurées, testables et directement consommables par un agent IA.
• Tester avec et grâce à l'IA. TDD assisté, génération de suites de tests depuis des specs BDD, mutation testing pour valider la solidité des tests.
• Instruire l'IA sur l'architecture de vos projets. Encoder les décisions architecturales, définir une constitution, contraindre l'agent à respecter la structure cible.
• Gouverner l'IA au niveau de l'équipe. Fichiers de règles persistants, standards partagés, onboarding accéléré des nouveaux développeurs.
• Identifier et maîtriser les risques. Vulnérabilités du code IA, hallucinations, slopsquatting, propriété intellectuelle.
• Choisir les bons outils et modèles. Panorama du marché, matrice outil par cas d'usage, coûts réels et arbitrages selon votre contexte.

• Développeurs, Tech Lead, Architectes, DevOps

• Pas de prérequis demandé.
• Afin de valider les profils, les compétences et le niveau de connaissance de chaque participant, en amont de la formation, le formateur organise un entretien téléphonique ou visio. Il confirme alors que le participant a le niveau nécessaire et que le contenu répond bien à ses attentes.

Un regard d'expert qui va au-delà de l'IA.

Nos formateurs sont des praticiens seniors en développement, architecture et conception logicielle. Les stagiaires bénéficient de conseils concrets sur la qualité du code, les choix architecturaux et les bonnes pratiques, indépendamment de l'IA.

Jour 1 — Panorama et fondamentaux

• Histoire de l'IA pour le code : de l'autocomplétion à l'agent autonome
• Modèles du marché : GPT-5, Claude, Gemini, Mistral et leurs différences clés
• Comprendre les LLM : tokens, fenêtre de contexte, température, limites
• Vibe coding : définition, pourquoi ça séduit, pourquoi ça ne tient pas en production

Jour 1 - Prompt engineering

• Anatomie d'un bon prompt : rôle, contexte, instruction, format de sortie
• Itérer plutôt qu'espérer : la boucle de raffinement
• Pièges classiques : ambiguïté, sur-spécification, contradictions

• Travaux pratiques : Comparaison d'approches de prompt : comparer trois stratégies sur un même problème et analyser les écarts de résultat

Jour 1 - De l'idée à la mise en production

• Le workflow SDD complet : Brainstorm, Spec, Plan, Tasks, Implement, Validate
• Les trois phases : spécifier, planifier, implémenter avec le rôle humain à chaque étape
• Outils de la chaîne : LLM conversationnel, modèle de raisonnement, agent de code
• GitHub Spec Kit : les 6 commandes /specify, /clarify, /plan, /tasks, /implement, /constitution

• Travaux pratiques : De l'idée au plan d'implémentation : produire une spécification fonctionnelle complète et un plan directement exploitable par un agent

Jour 1 - Écrire de bonnes spécifications

• Ce qu'une spec doit contenir : formats entrée/sortie, règles métier, cas limites, contraintes d'intégration, sécurité
• Séparer le QUOI du COMMENT : pourquoi c'est non-négociable
• Formats efficaces : Markdown structuré, BDD/Gherkin (Given/When/Then), ADR, notation EARS
• Spec fonctionnelle versus détails techniques : où tracer la ligne

• Travaux pratiques : Réécriture d'une spec en BDD et EARS : transformer une spécification mal rédigée en spécification structurée et testable

Jour 1 - Tests assistés par IA

• TDD assisté par IA : le LLM comme partenaire du cycle red/green/refactor
• Specs BDD comme tests exécutables : le lien naturel Given/When/Then vers test code
• Génération de tests unitaires, intégration et e2e : ce que l'IA détecte bien
• Mutation testing assisté : vérifier la solidité des tests générés

• Travaux pratiques : Génération d'une suite de tests depuis une spec BDD : produire automatiquement les tests et mesurer la couverture obtenue

Jour 1 - Instruire l'IA sur l'architecture logicielle

• Encoder les décisions architecturales : ADR comme source de vérité pour l'agent
• La notion de constitution : invariants, patterns imposés, anti-patterns interdits
• Contraindre l'IA à respecter la structure cible : couches, frontières, conventions de nommage
• Cas pratique : clean architecture, hexagonale, microservices

• Travaux pratiques : Rédaction d'une constitution architecturale : définir les règles d'architecture et vérifier que l'agent les respecte lors d'une tâche d'implémentation

Jour 2 — Conventions, règles persistantes et standards d'équipe

• Fichiers de règles persistants : CLAUDE.md, .cursor/rules/, AGENTS.md (standard Linux Foundation)
• Les 4 modes d'activation Cursor : Always, Auto, Agent Requested, Manual
• Divulgation progressive : dire à l'IA comment trouver l'info plutôt que tout inclure
• SKILL.md : encapsuler des capacités réutilisables, distinction règles (contraindre) vs skills (étendre)
• Standards d'équipe : prompts réutilisables, patterns partagés, onboarding accéléré

• Travaux pratiques : Mise en place d'un contexte d'équipe complet : construction d'un AGENTS.md intégrant des règles persistantes et des skills réutilisables

Jour 2 - Introduction aux agents

• La boucle agentique : plan, agir, observer, affiner
• Agent unique : configuration, portée des tâches, supervision
• Quand confier une tâche à un agent et quand garder la main
• Horizons temporels : ce qu'on peut attendre d'un agent en quelques minutes

• Travaux pratiques : Agent en action : configuration et exécution d'un agent sur une tâche de développement complète

Jour 2 - Gestion du contexte et économie de tokens

• La fenêtre de contexte : évolution, enjeux, le problème du "lost in the middle"
• Structurer ses fichiers et prompts pour maximiser la pertinence de la réponse
• RAG pour le code : indexation, chunking syntaxique, scoring sémantique
• Économie de tokens : caching, divulgation progressive, découpage des tâches

Jour 2 - Choix des modèles et des outils

• Panorama : Cursor, Claude Code, GitHub Copilot, Windsurf, Aider, Kiro, Antigravity
• Matrice outil par modèle par cas d'usage : autocomplétion, refactoring, debugging, architecture
• Coûts réels : licences, consommation API, TCO selon profil d'usage
• Quand combiner les outils : par exemple flow et le raisonnement profond

Jour 2 - Sécurité et hallucinations

• Vulnérabilités du code IA : 3 fois plus que le code humain, XSS 2,74 fois plus fréquent
• Hallucinations et slopsquatting : packages fictifs recommandés par les LLM, exploitables par des attaquants
• Rules File Backdoor : injection de code malveillant via fichiers de configuration IA
• Propriété intellectuelle et ce qu'il n'est pas recommandé de déléguer

• Travaux pratiques : Audit de sécurité d'un code généré par IA : identifier les hallucinations et failles, corriger et documenter les risques

Jour 2 - Greenfield vs brownfield

• Adopter le SDD sur un projet existant : audit du codebase, génération du CLAUDE.md initial, migration progressive
• Rendre un projet agentic-coding compliant : structurer pour que l'IA comprenne le contexte
• Plan de migration legacy : de l'analyse à la roadmap de refactoring assisté par agent
• Pièges spécifiques au brownfield : dette existante amplifiée, tests absents, architecture implicite

Jour 2 - Lucidité sur la productivité

• Le paradoxe perception/réalité : +20% ressenti vs -19% réel (étude METR) pour calibrer ses attentes
• Atrophie des compétences : maintenir sa capacité de raisonnement sur le code sans IA
• Éthique et responsabilité : le développeur reste le signataire du code
• Synthèse : du codeur à l'orchestrateur, la compétence clé est de penser clairement ce qu'il faut construire

1490 € HT

Le distanciel est une modalité que nous pratiquons couramment.

Retengr vous permet aussi de suivre cette formation à distance, sous forme de classe virtuelle (6 participants maximum), avec un formateur expert sur le sujet. La formation se déroule via une connexion en visio conférence (ZOOM, GoogleMeet, Teams ou autres) et vous permet d'alterner théorie et pratique de façon accompagnée ou autonome, le tout dans le respect des objectifs pédagogiques et des évaluations des acquis.

Les émargements, évaluations, attestation de formation, remises des supports de cours et autres documents se feront en ligne.

En ce qui concerne le matériel informatique du participant, il est seulement préconisé un ordinateur et une connexion internet. Nous nous chargeons du reste.

Chaque participant se verra attribuer une Machine Virtuelle qui sera exécutée dans le Cloud d'Amazon. Il disposera alors de la puissance et des outils nécessaires pour le bon déroulement de la formation. Aucune installation de la part du participant n'est requise avant la formation.

Une journée type de formation à distance se décompose de la façon suivante :

Matin :

• 2h de théorie en visioconférence
• 10 à 15 minutes de présentation d'exercices en visio
• 1h de TP en autonomie avec possibilité de solliciter le formateur (partage d'écran à distance pour une assistance efficace).

Après-midi :

• 2h de théorie en visioconférence
• 10 à 15 minutes de présentation d'exercices en visio
• 1h de TP en autonomie avec possibilité de solliciter le formateur (partage d'écran à distance pour une assistance efficace).