Formation IA Développeurs - V2 - 2026

Formation créée le 14/10/2026.
Version du programme : 1

Type de formation

Présentiel

Durée de formation

14 heures (2 jours)

Accessibilité

Oui
3 700,00 € HT
Envoyer ma demande
3 700,00 € HT
Envoyer ma demande
3 700,00 € HT
Envoyer ma demande
Besoin d’adapter cette formation à vos besoins ? N’hésitez pas à nous contacter afin d’obtenir un devis sur mesure ! Nous contacter

Formation IA Développeurs - V2 - 2026


Piloter les assistants et agents de code par les spécifications et les tests, et intégrer des modèles d'IA (texte, code, vision, audio) en environnement cloud ou local dans des architectures applicatives fiables. Ce programme de 2 jours (14 h) forme les développeurs à une ingénierie logicielle augmentée moderne, loin des approches artisanales par simple conversation. La première journée pose les fondamentaux des modèles (LLM, Transformers, modèles de code, de vision et de Speech-to-Text), compare les déploiements cloud et locaux, puis structure l'IA coding autour des spécifications, de l'architecture du dépôt, des invariants et des boucles de vérification automatisées (exploration, modification multi-fichiers, tests, debugging, revue et merge request). La seconde journée approfondit les workflows agentiques dans l'IDE et aborde l'ingénierie d'applications intégrant l'IA (appels API ou runtime local, contrats de sortie typés, RAG, Tool Use et protocole MCP) avec observabilité et garde-fous. Les ateliers s'appuient sur un dépôt applicatif fictif, sans entraînement de modèles ni mise en production. À noter : Ce programme de formation est adaptable sur mesure en fonction du profil technique, des langages, des outils d'IA autorisés et des enjeux spécifiques de votre entreprise. Intra-entreprise : Sur site, ou distanciel, ou hybride 💰Tarif adhérent : 3700€ HT / entreprise 💰Tarif non adhérent : 4400 € HT / entreprise

Objectifs de la formation

  • Sélectionner et exploiter des modèles d'IA pré-entraînés (texte/NLP, code, vision/images, Speech to Text) en comparant les déploiements cloud et locaux selon l'usage, la confidentialité, la latence et le coût.
  • Structurer un environnement de développement IA natif (spécifications, règles d'architecture, contrats d'API, harnais de vérification) et piloter les modes d'un assistant de code.
  • Conduire une évolution logicielle de bout en bout (exploration, planification, modification multi fichiers, tests, diagnostic, documentation et merge request) en validant chaque étape par des contrôles déterministes.
  • Orchestrer un workflow agentique pour du refactoring ou de la maintenance sans régression et standardiser des workflows et skills réutilisables en équipe.
  • Concevoir et évaluer l'architecture d'une application intégrant un modèle d'IA en cloud ou en local (contrats de sortie typés, RAG, Tool Use, MCP) avec journalisation, gestion d'erreurs et supervision humaine.

Profil des bénéficiaires

Pour qui
  • Développeurs logiciels souhaitant industrialiser leur usage des assistants de code et intégrer l'IA dans leurs applications (Backend, Front-end, Fullstack, applicatif ou mobile).
  • Ingénieurs logiciels, intégration, validation et DevOps.
  • Tech Leads, architectes logiciels et responsables techniques.
Prérequis
  • Bonne connaissance d'au moins un langage de programmation courant (Python, Java, JavaScript/TypeScript, C#…) et pratique régulière d'un IDE (VS Code, IntelliJ ou équivalent).
  • Accès recommandé à un assistant IA de développement autorisé par l'entreprise (GitHub Copilot, Devin, Claude Code ou équivalent), ou suivi en binôme sur environnement préparé.
  • Connaissances de base de Git, des API et du cycle de développement logiciel.
  • Aucun prérequis mathématique ni expérience préalable en création de modèles de Machine Learning (les concepts fondamentaux de l'IA sont rappelés en début de session).

Contenu de la formation

Jour 1 matin · Séquence 1 : fondamentaux des modèles, déploiement cloud/local et environnement IA natif (3 h 30)
  • Objectif : comprendre le fonctionnement des modèles d'IA pré-entraînés, arbitrer entre déploiement cloud et local, et structurer un dépôt logiciel pour guider les assistants et agents par les spécifications et les preuves.
  • Apports théoriques · bloc 1, modèles pré-entraînés et déploiement cloud ou local (45 min) : concepts clés de l'IA, du Machine Learning et des architectures Transformers. Panorama des modèles pré-entraînés : LLM pour le langage naturel (NLP) et le code, modèles de reconnaissance d'images (vision), de Speech-to-Text (audio) et petits modèles spécialisés (SLM). Fenêtre d'attention, génération probabiliste et causes d'hallucination en ingénierie logicielle. Comparaison des modes de déploiement : API cloud, instance privée et exécution locale (Ollama, vLLM) selon qualité, confidentialité, souveraineté, latence et coût. Démonstration commentée.
  • Apports théoriques · bloc 2, environnement de développement IA natif et ingénierie pilotée par les spécifications (45 min) : dépasser l'approche par requêtes isolées au profit d'un système d'ingénierie structuré. Comparaison des modes d'assistance dans l'IDE (complétion, édition ciblée, planification, exécution multi fichiers et agent autonome) selon rayon d'action et permissions. Structuration du dépôt pour l'IA : décisions d'architecture, contrats d'API, typage, conventions, exemples de référence et commandes de validation automatisées (tests, linters, build). Démonstration commentée.
  • Mise en pratique · atelier du matin (2 h) : sélectionner des modèles pré-entraînés et leur mode de déploiement (cloud ou local) sur plusieurs cas d'usage (texte, code, vision, audio) à l'aide d'une grille d'arbitrage. Configurer son IDE augmenté, puis instrumenter le dépôt fil rouge (règles d'architecture, contrats, invariants et commandes de vérification) pour encadrer le comportement de l'assistant.
  • Évaluation des acquis · livrable du matin : grille de sélection de modèles argumentée et socle d'ingénierie du dépôt testé sur le fil rouge.
Jour 1 après-midi · Séquence 2 : IA coding de bout en bout, modification multi fichiers, tests et debugging (3 h 30)
  • Objectif : piloter un assistant de développement à partir d'une spécification pour explorer un dépôt, modifier plusieurs fichiers, générer les tests, diagnostiquer un défaut et livrer une merge request vérifiée.
  • Apports théoriques · bloc 3, exploration, planification et édition multi fichiers (45 min) : cartographier les impacts d'une exigence dans un dépôt, vérifier les références identifiées et faire produire un plan d'implémentation vérifiable avant toute écriture de code. Borner le périmètre et imposer les invariants, interfaces publiques et contrats applicatifs à préserver. Démonstration commentée.
  • Apports théoriques · bloc 4, boucles de rétroaction par les tests, diagnostic assisté et revue (30 min) : générer des suites de tests unitaires et d'intégration (cas nominaux, cas limites, propriétés). Exploiter les sorties de compilation, journaux d'exécution et échecs de test comme boucle de rétroaction déterministe, en distinguant hypothèses de l'IA et faits observés. Auditer le changement (régressions, sécurité), mettre à jour la documentation et structurer la merge request. Démonstration commentée.
  • Mise en pratique · atelier de l'après-midi (1 h 45) : réaliser sur le fil rouge une évolution complète, de la spécification à la merge request : analyse d'impact, plan validé, modification multi fichiers, génération et exécution de tests, diagnostic d'un défaut par les journaux, revue critique et rédaction de la merge request avec preuves de validation.
  • Évaluation des acquis · livrable de l'après-midi : évolution multi fichiers testée et merge request documentée.
Jour 1 · Synthèse de fin de journée (30 min)
  • Restitution par binôme : retour sur les cas traités, gains observés et erreurs de l'assistant interceptées par les tests et la revue.
  • Synthèse : contrôle individuel court sur le choix des modèles, la structuration du dépôt et la validation par les preuves.
Jour 2 matin · Séquence 3 : workflows agentiques de développement, refactoring et standardisation (3 h 30)
  • Objectif : orchestrer un workflow agentique dans l'IDE avec boucles de vérification et validations intermédiaires, conduire un refactoring sans régression et standardiser des workflows d'équipe.
  • Apports théoriques · bloc 5, anatomie et contrôle d'un workflow agentique dans l'IDE (45 min) : boucle de planification, d'action outillée et de vérification automatique d'un agent de code. Cadrage de la mission, du périmètre, des outils autorisés, des points d'arrêt et de la traçabilité. Frontière entre exécution autonome (lecture, tests, analyse) et actions soumises à approbation humaine. Prévention des dérives de périmètre et des contournements de tests. Démonstration commentée.
  • Apports théoriques · bloc 6, refactoring multi fichiers, non régression et standardisation d'équipe (45 min) : conduite d'une maintenance évolutive ou d'un refactoring transverse avec analyse d'impact et filet de non-régression. Maîtrise de la dette technique et de la lisibilité plutôt que volume de code produit. Revue croisée (preuves d'exécution, temps de validation, reprises) et formalisation de workflows et skills réutilisables dans le dépôt de l'équipe. Démonstration commentée.
  • Mise en pratique · atelier du matin (2 h) : conduire un refactoring multi fichiers sous workflow agentique encadré avec validation par les tests de non-régression. Réaliser une revue croisée entre binômes (preuves fournies, écarts, reprises) et packager un workflow ou skill réutilisable adapté aux conventions de l'équipe.
  • Évaluation des acquis · livrable du matin : refactoring validé sans régression, grille de revue croisée et workflow/skill d'équipe réutilisable.
Jour 2 après-midi · Séquence 4 : ingénierie d'applications IA, sorties typées, RAG, Tool Use et MCP (3 h 30)
  • Objectif : intégrer un modèle d'IA pré-entraîné (cloud ou local) dans une architecture applicative, mobiliser les briques d'ingénierie IA (contrats typés, RAG, Tool Use, MCP) et sécuriser les flux.
  • Apports théoriques · bloc 7, architecture applicative IA, contrats typés, RAG et Tool Use (45 min) : intégration programmatique d'un modèle pré-entraîné via API cloud ou runtime local pour le traitement du langage (NLP), l'analyse d'images (vision) ou la transcription (Speech-to-Text). Architecture minimale : service applicatif, contrats d'entrée/sortie strictement typés (JSON Schema / validation déterministe), gestion des erreurs, timeouts, journalisation et évaluation. Ancrage documentaire par RAG et exécution d'actions par Tool Use (Function Calling) sous contrôle du code applicatif. Démonstration commentée.
  • Apports théoriques · bloc 8, protocole MCP, sécurité et gouvernance des accès (30 min) : architecture client-serveur du Model Context Protocol (MCP), exposition d'outils et de ressources, comparaison avec une intégration directe. Modèle de menace applicatif : permissions excessives, injections indirectes via les données, entrées non fiables. Étude d'un serveur MCP pédagogique en lecture seule exposant des opérations bornées sur une API métier d'exercice. Démonstration commentée.
  • Mise en pratique · atelier de l'après-midi (1 h 45) : intégrer ou expérimenter un appel de modèle (cloud ou local) avec validation de schéma en sortie et gestion des cas d'échec. Inspecter le serveur MCP pédagogique en lecture seule, puis concevoir et évaluer l'architecture d'une fonctionnalité IA sur un cas applicatif concret (flux de données, séparation entre logique déterministe et brique générative, moindre privilège, journalisation et supervision humaine).
  • Évaluation des acquis · livrable de l'après-midi : schéma d'architecture et grille d'évaluation d'une fonctionnalité IA sécurisée.
Jour 2 · Synthèse de fin de formation (30 min)
  • Restitution par binôme : présentation de l'architecture conçue, des contrôles déterministes retenus et des limites identifiées.
  • Synthèse : questionnaire final corrigé en séance, autoévaluation sur les objectifs et remise des gabarits d'ingénierie.

Équipe pédagogique

Hammouche Hamza – Formateur IA Proovup – hhammouche@proovup.com Stéphane MOSNIER – Référent pédagogique – s.mosnier@digital-league.org // 07 62 42 23 23 Julia DELRIEU – Référente handicap – j.delrieu@digital-league.org Quentin POYET – Référent administratif et financier – q.poyet@digital-league.org

Suivi de l'exécution et évaluation des résultats

  • Emargements numériques
  • Positionnement initial et recueil des besoins avant la session.
  • Exercices et mises en pratique pendant la formation, avec quatre livrables évalués, un par demi-journée.
  • Évaluation sur quatre critères (arbitrer ses modèles/outils et structurer le dépôt, livrer une évolution testée et vérifiée, piloter un refactoring sous workflow agentique, concevoir l'architecture d'une fonctionnalité IA sécurisée).
  • Remédiation en séance et questionnaire final corrigé.
  • Autoévaluation sur les objectifs en fin de formation et formulaires d'évaluation de la formation.
  • Point individuel à J+30.
  • Certificat de réalisation de l'action de formation.
  • Questionnaires de satisfaction à chaud + à froid

Ressources techniques et pédagogiques

  • Supports de cours
  • Lexique IA
  • Cartographie des usages sur le cycle de développement
  • Grille d'arbitrage des modèles (texte, code, vision, audio, cloud/local)
  • Outils
  • Gabarit de configuration de dépôt IA natif (architecture, conventions, workflows/skills)
  • Modèle de merge request avec preuves
  • Checklist de revue et de sécurité
  • Exemple d'intégration à sorties typées
  • Schéma d'application IA (RAG, Tool Use, MCP)
  • Serveur MCP pédagogique en lecture seule
  • Canvas d'évaluation d'architecture

Capacité d'accueil

Entre 2 et 10 apprenants

Délai d'accès

3 semaines

Accessibilité

Les personnes en situation de handicap souhaitant suivre cette formation sont invitées à nous contacter directement, afin d'étudier ensemble les possibilités de suivre la formation.