Panorama de l’IA pour le code
Panorama des outils IA code
- Taxonomie : assistants de code (Copilot, Cursor, Tabnine), Agents CLI (Claude Code, OpenCode, Aider),
- APIs LLM (Anthropic, Mistral, OpenAI Codex).
- Différence fondamentale entre autocomplétion, génération et agent autonome.
- Focus sur OpenCode : agent universel open source supportant modèles locaux et cloud.
- Critères de choix : latence, confidentialité, coût, qualité sur les langages cibles.
Architecture des LLM de code
- Pourquoi les LLM de code sont différents des LLM généraux : pré-entraînement sur code, Fill-in-the-Middle (FIM), context window et débit de tokens.
- Présentation des modèles clés :
- GPT-4o,
- Claude 3.5/3.7 Sonnet,
- Mistral Codestral,
- Qwen2.5-Coder,
- DeepSeek-Coder-V2.
- Benchmarks : HumanEval, SWE-Bench.
Installation des outils
- GitHub Copilot dans VS Code : configuration, raccourcis, modes (inline, chat, agent).
- Cursor IDE : interface, Composer, mode Agent.
- Claude dans le navigateur pour le code.
- Ollama : installation, pull de modèles (codellama:7b, qwen2.5-coder:7b), test via CLI.
- OpenCode : installation via npm, configuration du fichier config.json, connexion à Ollama local et aux APIs cloud
Lab — Premiers essais comparatifs
- Même exercice de génération de code sur 4 outils : Copilot, Claude, OpenCode+Ollama local, OpenCode+Claude API.
- Mesure de la pertinence, de la vitesse et de la complétude.
- Débrief collectif : quand utiliser quoi ?
- Avantage clé d’OpenCode : zéro dépendance cloud possible.
GitHub Copilot & Cursor — Maîtrise avancée
Copilot — Fonctionnalités avancées
- Inline suggestions : accepter, rejeter, voir alternatives.
- Copilot Chat : expliquer, documenter, déboguer, générer des tests unitaires.
- Mode Agent Copilot : édition multi-fichiers, terminal intégré, création de PR. Copilot CLI : génération de commandes shell.
- Personnalisation via .github/copilot-instructions.md.
Cursor — Composer & Mode agent
- Interface Cursor : différence entre Chat, Composer et Agent.
- Composer : édition simultanée de plusieurs fichiers, contexte de codebase.
- Mode Agent Cursor : exécution de commandes, lecture/écriture de fichiers, recherche web.
- Connexion à Claude 3.5 Sonnet et Mistral comme modèles backend.
- RULES for AI : définir le comportement de l’agent.
Prompting efficace pour le code
- Techniques de prompting adaptées au code : spécifier le langage, les conventions, les contraintes.
- Fournir des exemples (few-shot) pour les fonctions complexes.
- Utiliser les commentaires comme instructions.
- Gérer les hallucinations : validation systématique, tests automatiques.
- Patterns : Explain/Refactor/Optimize/Test.
Lab — Projet refactoring guidé IA
- Partir d’un projet Python legacy fourni : identifier les problèmes, générer une suite de tests, refactoriser avec Cursor Agent, documenter avec Copilot.
- Comparer les approches.
Claude Code, OpenCode & Mistral — Agents CLI
Claude Code — CLI agentique
- Installation et configuration de Claude Code.
- Mode interactif vs mode headless.
- Commandes clés : analyse de codebase, génération de fichiers, exécution de tests.
- Permissions et sécurité : quelles actions autoriser. CLAUDE.md : fichier de contexte de projet.
- Cas d’usage : bootstrapper un projet from scratch.
OpenCode — Agent CLI universel
- Présentation d’OpenCode : agent de code open source en ligne de commande, développé en TypeScript.
- Installation via npm.
- Architecture : modèles interchangeables via configuration JSON.
- Connexion à des modèles locaux (Ollama : Qwen2.5-Coder, DeepSeek-Coder) et cloud (Claude, Mistral, OpenAI).
- Commandes clés : analyse, génération, modification de fichiers, exécution de commandes.
- Comparaison OpenCode vs Claude Code vs Aider : cas d’usage de chacun.
- Cas pratique : utiliser OpenCode entièrement offline avec Qwen2.5-Coder:14b.
API Anthropic & Mistral Codestral
- API Anthropic : SDK Python et Node.js, tool use / function calling, streaming, gestion du contexte long.
- Mistral Codestral : spécialisation FIM (Fill-in-the-Middle), performances sur Python/JS/TS/Rust, endpoint codestral-latest.
- Comparaison des APIs : format des requêtes, pricing, limites de tokens. Codestral dans VS Code (extension officielle).
Lab — Atelier agents CLI multi-modèles
- Parcours comparatif : exécuter la même tâche de développement (ajout d’une fonctionnalité + tests) avec Claude Code, OpenCode + Claude, OpenCode + Ollama local et Mistral Codestral.
- Mesurer : qualité du code produit, temps d’exécution, nombre de tokens.
- Choisir la combinaison optimale selon le contexte.
Ollama — Modèles locaux de code
Ollama — Architecture & installation
- Fonctionnement d’Ollama : GGUF, quantification (Q4_K_M, Q8_0), layers GPU/CPU.
- Installation sur Linux/macOS/Windows.
- Variables d’environnement clés : OLLAMA_HOST, OLLAMA_NUM_GPU, OLLAMA_KEEP_ALIVE.
- Gestion des modèles : pull, list, rm, show. Accès réseau et configuration pare-feu.
Catalogue des modèles de code
- Comparatif des modèles disponibles :
- Qwen2.5-Coder (7b/14b/32b),
- DeepSeek-Coder-V2 (16b/236b),
- CodeLlama (7b/13b/34b),
- StarCoder2,
- Phi-3.5-mini.
- Benchmarks : HumanEval, MultiPL-E, FIM.
- Stratégie de sélection : RAM disponible vs qualité. Ollama et les Modelfiles : personnaliser un modèle
API locale compatible OpenAI
- L’API REST d’Ollama : /api/generate, /api/chat, /api/embeddings.
- Compatibilité OpenAI : endpoint /v1/chat/completions.
- Intégration dans VS Code via Continue.dev avec modèle local. Connecter Cursor à Ollama comme modèle backend. Streaming et performances.
Lab — Benchmark et sélection de modèle
- Déployer 3 modèles locaux, les tester sur un même jeu d’exercices de code (algo, API REST, tests unitaires).
- Mesurer qualité/vitesse/RAM.
- Choisir le modèle optimal pour un contexte donné.
Continue.dev & Intégration IDE + Local
Continue.dev — Configuration avancée
- Installation et structure de config.json.
- Configurer plusieurs modèles simultanément : Ollama local + Claude API + Mistral API.
- Modes : Chat, Autocomplete, Edit.
- Choisir le bon modèle par tâche dans le config.
- Utiliser les embeddings locaux pour l’indexation de codebase (Nomic Embed).
Slash commands & Context providers
- Créer des slash commands personnalisées : /test, /doc, /review, /explain.
- Context providers : @codebase, @file, @git, @terminal, @docs.
- Indexation de la documentation locale ou externe.
- Définir des system prompts personnalisés par modèle.
- Partage de configuration d’équipe
Stratégie local vs cloud
- Matrice de décision : quand utiliser un modèle local (données sensibles, offline, coût) vs cloud (complexité, performance, multimodal).
- Chiffrement, conformité RGPD et traitements on-premise.
- Fallback automatique : local si disponible, cloud sinon.
- Gestion des clés API et des quotas
Lab — Workspace IA hybride
- Configurer un environnement Continue.dev complet avec 4 modèles (2 locaux, 2 cloud).
- Créer des slash commands /test-python, /review-security, /doc-api.
- Indexer un projet existant et interroger sa codebase.
- Mesurer la différence de qualité par modèle.
Agents de code — Architecture & Premiers agents
Architecture des agents codeurs
- Différence entre agent de code et simple appel LLM.
- Le cycle React appliqué au code : lire le fichier → analyser → planifier → écrire → exécuter → observer.
- Les outils indispensables d’un agent codeur : read_file, write_file, run_command, search_codebase, git_operations.
- Gestion du contexte long (repo-map)
Tool Use avec l’API Anthropic
- Définir des tools en JSON Schema pour l’API Anthropic.
- Boucle d’exécution : appel API → tool_use → exécuter l’outil → tool_result → appel suivant.
- Implémentation Python d’un agent avec outils de fichiers.
- Gestion de la profondeur de récursion et des erreurs.
- Différences avec l’API OpenAI (function calling).
Aider & OpenCode — Agents CLI open source
- Présentation d’Aider : modes architect/editor, repo-map, connexion à Claude, GPT-4o ou Ollama.
- Comparaison avec OpenCode : architecture, cas d’usage différenciants.
- OpenCode en profondeur : configuration avancée (températures, system prompts, outils activés), mode batch headless pour scripts CI, gestion des sessions.
- Commandes avancées OpenCode : –model, –no-confirm, –output.
- Bonnes pratiques partagées : commits atomiques, validation humaine.
-
Lab — Agent lecteur/modifieur de code
- Construire from scratch un agent Python avec l’API Anthropic : outils read_file, write_file, run_python.
- L’agent reçoit une tâche (ajouter une fonctionnalité à un projet), planifie, modifie les fichiers et exécute les tests.
- Tester avec Claude 3.5 via l’API, puis avec OpenCode+Qwen2.5-Coder local, puis avec Aider.
- Comparer les résultats.
Génération de tests & Documentation automatique
Génération de tests unitaires par IA
- Stratégies de génération : analyser la fonction → identifier les cas limites → générer les assertions.
- Frameworks cibles : pytest (Python), Jest (JavaScript), JUnit (Java).
- Prompts optimaux pour la génération de tests : fournir la signature, les types, les exemples d’entrée/sortie.
- Taux de couverture et qualité des tests générés.
Tests d’intégration & mutation testing
- Générer des tests d’intégration à partir d’une architecture en couches.
- Mocking et fixtures générées par IA.
- Introduction au mutation testing assisté : détecter les tests faibles.
- Agent de test en boucle : générer → exécuter → corriger → régénérer.
- Cas pratique : API REST Flask avec base de données.
Documentation automatique par agents
- Génération de docstrings (Google style, NumPy, reStructuredText).
- Génération de documentation OpenAPI/Swagger depuis le code source.
- Architecture Decision Records (ADR) générés par IA.
- README automatique avec badges, exemples et schémas.
- Maintenir la documentation synchronisée avec le code : hook pre-commit.
Lab — Agent TDD complet
- Partir d’une spécification textuelle (user story) :
- l’agent génère les tests
- le développeur valide
- l’agent génère l’implémentation
- exécution des tests
- correction si nécessaire.
- Workflow TDD IA-assisté de bout en bout
Génération de tests & Documentation automatique
Cartographie et indexation de codebase
- Techniques de repo-map : tree-sitter pour l’AST, extraction de signatures.
- Chunking intelligent du code (par fichier, par classe, par fonction).
- Embeddings de code : nomic-embed-text, text-embedding-3-small.
- Stockage vectoriel pour la recherche sémantique sur code.
- Requêtes : ‘où est la gestion des erreurs HTTP ?
Agent de revue de code automatique
- Construire un agent de code review :
- Lire les fichiers modifiés
- Analyser chaque changement
- Évaluer : style, logique, sécurité, performance
- Générer des commentaires structurés.
- Intégration avec git diff.
- Format de sortie : commentaires inline (SARIF, JSON).
- Comparaison Claude vs Mistral pour la revue.
Détection de bugs & refactoring intelligent
- Agent de détection de bugs : analyser les stack traces, corréler avec le code, proposer un correctif.
- Refactoring multi-fichiers : renommage, extraction de module, injection de dépendances.
- Valider le refactoring : lancer les tests avant/après.
- Gestion des conflits de merge assistée par IA.
Lab — Agent analyse de projet legacy
- Fournir un projet legacy Python/JS (~500 lignes).
- L’agent produit : cartographie du code, liste des problèmes (bugs, dette technique, failles sécurité), plan de refactoring priorisé, génération des correctifs pour les 3 premiers problèmes.
- Revue humaine et validation.
CI/CD Agentique & Pipelines IA
Architecture CI/CD agentique
- Principes d’un pipeline IA : étapes déterministes + étapes agentiques.
- Quelles tâches déléguer à l’IA en CI/CD : revue de code, génération de tests manquants, vérification sécurité (SAST), génération de changelog, vérification de la documentation.
- Sécurisation des clés API dans les runners CI. GitLab CI Artifacts et rapports
Implémentation GitLab CI / GitHub Actions
- Job de revue IA : déclencher sur Merge Request, appeler l’API Anthropic ou Mistral, poster les commentaires via l’API GitLab/GitHub.
- Job de tests IA : détecter les fonctions non couvertes, générer les tests manquants, les exécuter.
- Utiliser OpenCode en mode headless (–no-confirm) dans un job CI pour des modifications automatiques de code.
- Conditions d’échec : bloquer le merge si la qualité est insuffisante.
- Utiliser un runner avec Ollama pour zéro coût API.
Human-in-the-Loop & sécurité des agents CI
- Mécanismes de validation humaine en CI : approbation manuelle avant merge, rapport d’audit des actions de l’agent.
- Limiter les permissions des agents CI : lecture seule vs écriture.
- Journalisation des décisions de l’agent.
- Gestion des faux positifs et des alertes.
- Cas particulier des secrets et données sensibles dans le code scanné
- Valider le refactoring : lancer les tests avant/après.
Lab — Pipeline CI/CD complet avec agent IA
- Construire un pipeline GitLab CI complet : lint → tests → [Agent IA : revue + sécurité + changelog] → build → deploy (staging).
- L’agent poste ses retours en commentaire de MR.
- Le merge est conditionné à l’approbation humaine du rapport IA.
Projet Final — Agent autonome de développement
Déploiement & bonnes pratiques agents
- Packaging d’un agent de code : Docker, variables d’environnement, secrets.
- Monitoring : logs structurés, métriques (tokens consommés, taux de succès, latence).
- Gestion des coûts : budgets par modèle, fallback local/cloud.
- Versioning du prompt système de l’agent.
- Documentation et onboarding d’un agent pour une équipe.
Projet final — Implémentation (matin)
- Chaque participant ou groupe implémente un agent codeur sur un sujet au choix : agent de migration de code (Python 2→3), agent de génération d’API REST depuis un schéma, agent de sécurité (scan + correction), agent de traduction de stack (ex : Flask → FastAPI).
- Liberté sur le stack : Claude Code, OpenCode+Ollama, OpenCode+API, Aider, ou agent custom Python.
- Objectif : agent fonctionnel, testé, documenté.
Démonstrations & bilan de formation
- Présentation en direct des agents par groupe (15 min + questions).
- Retours du formateur : points forts, axes d’amélioration, sécurité.
- Bilan collectif des 10 jours : les patterns qui fonctionnent, les pièges courants.
- Roadmap personnelle : comment continuer à progresser.
- Ressources : papers, dépôts GitHub, communautés.
10 jours
