Pillar page

Développement logiciel avec l'IA

Un processus éprouvé d'automatisation du développement logiciel avec une équipe d'agents IA — de l'analyse des besoins, au codage et aux tests multicouches (unitaires, intégration, E2E, sécurité, performance), jusqu'au déploiement en production avec un audit trail complet.

Parlons d'un pilote Nos services

Nous disposons d'une équipe d'agents IA spécialisés qui participe à chaque étape du cycle de développement logiciel — de l'analyse des besoins, à la conception d'architecture, au codage et aux tests multicouches, jusqu'à la revue de code, la documentation et le déploiement avec un audit trail complet.

C'est ainsi que nous construisons nos propres produits ESKOM AI — la plateforme multi-agents HybridCrew, le système d'audit Compliance, le microservice KRS+CRBR et un portefeuille d'intégrations. Nous appliquons le même processus dans les projets clients : aussi bien pour les nouveaux microservices que pour la modernisation des systèmes legacy.

Cet article décrit comment cela fonctionne en pratique : quelles tâches sont prises en charge par les agents, lesquelles restent du ressort de l'humain, quels tests sont exécutés, et pourquoi ce processus est reproductible d'un type de projet à l'autre.

Pourquoi automatiser le développement logiciel ?

Un cycle classique de développement logiciel (analyse → code → tests → revue → déploiement) prend typiquement 2 à 4 semaines pour une fonctionnalité de taille moyenne dans une équipe mature. La plupart de ce temps est consacré à des tâches répétitives : écriture de boilerplate, génération de tests unitaires, revue des modifications, mise à jour de la documentation, génération de migrations de base de données. Toutes se prêtent à l'automatisation.

L'objectif de notre processus est simple : deux ou trois personnes travaillant avec des agents IA délivrent la valeur d'une équipe de 8 à 10 personnes — sans burn-out, avec une qualité supérieure (plus de tests, meilleure revue de code, documentation complète) et un time-to-market réduit.

Il ne s'agit pas de « l'IA va remplacer les développeurs ». Il s'agit de « les développeurs avec l'IA vont remplacer les développeurs sans IA ». Les ingénieurs expérimentés restent essentiels — ils conçoivent l'architecture, prennent les décisions stratégiques, examinent les modifications complexes. Les agents IA prennent en charge la routine.

Le processus en six étapes

Le pipeline des besoins jusqu'à la production. Chaque étape est exécutée par des agents IA spécialisés, tandis que les humains supervisent et approuvent les décisions clés.

Analyse des besoins et architecture

Les agents IA analysent la documentation métier, les conversations clients (à partir des transcriptions) et le code existant. Ils proposent une architecture microservices, un schéma de base de données, une liste d'endpoints et un modèle de permissions. Un humain (CTO/architecte) examine et approuve la proposition avant le début du codage.

Écriture du code (TDD)

Tests d'abord, puis implémentation. Un agent backend écrit les API en FastAPI/Express, un agent frontend écrit les composants React. Chaque modification est une pull request distincte avec un message de commit propre. Les standards de codage (Black, ESLint, Prettier) sont appliqués automatiquement.

Tests multicouches

Unitaires (pytest, Jest), intégration (testcontainers avec un vrai PostgreSQL), E2E (Playwright), snapshots UI, sécurité (OWASP, gitleaks, bandit), performance (k6/locust), accessibilité (axe). Chaque PR exécute le pipeline complet — un test en échec bloque le merge.

Revue de code par l'IA

Un agent SecurityReviewer scanne les problèmes OWASP Top 10, un agent QualityReviewer vérifie la lisibilité et les patterns, un agent ArchitectureReviewer vérifie la cohérence avec le reste du système. Les cas limites sont escaladés aux humains.

Documentation et CHANGELOG

Chaque changement de logique = bump de version + entrée dans le CHANGELOG.md au format Keep a Changelog. La documentation d'API (OpenAPI/Swagger) est générée automatiquement. CLAUDE.md est mis à jour après chaque session avec les nouveaux enseignements.

Déploiement avec Change Request

Le déploiement passe toujours par Git (JAMAIS de scp direct). D'abord l'environnement de test avec vérification Playwright, puis la production après approbation du CR. Le script de déploiement inclut un plan de rollback (<5 min) et des health checks.

Que gagne l'entreprise ?

Des milliers de tests automatisés

Chaque projet en production compte de plusieurs milliers à plusieurs dizaines de milliers de tests — unitaires, intégration, E2E, sécurité, performance. Les régressions sont détectées dans le CI avant d'atteindre les utilisateurs.

Audit trail complet

Chaque modification du code, de la base de données ou de la configuration est enregistrée : Git, journal d'audit en base de données, CHANGELOG, Change Request. Conforme aux exigences ISO 27001, EU AI Act et RGPD.

Scalabilité de l'équipe

Deux ou trois personnes avec des agents IA délivrent la valeur d'une équipe de 8 à 10 personnes. Sans burn-out, avec une qualité supérieure et des délais plus courts.

Escalade vers des modèles plus puissants

Le routage LLM choisit le bon modèle pour chaque tâche : modifications mineures — Ollama local (coût nul), architecture complexe — Claude Opus. Optimisation du coût et de la qualité en un seul geste.

Reproductibilité et standards

Chaque projet suit les mêmes standards : feature branch workflow, squash merge, Conventional Commits, CHANGELOG, EU AI Act, RGPD. Un nouveau développeur comprend la structure dès le premier jour.

Sécurité par défaut

Gitleaks en pre-commit + CI, secrets dans HashiCorp Vault, dépôts privés, SSO Keycloak, VPN Tailscale pour les services internes. Aucun compromis sur la vitesse.

Tests multicouches — le fondement de la qualité

Chaque modification du code de production passe par un pipeline de tests complet. Aucune exception — même la correction d'une faute de frappe dans un commentaire déclenche le CI, car le pipeline de tests est imposé par un Git hook, pas par la décision politique d'un développeur.

Tests unitaires : pytest, Jest, vitest. Couvrent les fonctions et classes individuelles. Couverture >80% sur le code critique.
Tests d'intégration : testcontainers avec de vraies instances de PostgreSQL, Redis, Vault. Les mocks ne sont utilisés que pour les API tierces externes.
Tests end-to-end (E2E) : Playwright sur Firefox (par défaut), Chrome (optionnel). Simulent les parcours utilisateurs complets : login → action → vérification.
Tests UI (snapshot, accessibilité) : Playwright + axe-core. WCAG 2.0 AA comme baseline, Lighthouse 100/100/100/100 comme objectif.
Tests de sécurité : OWASP Top 10 (semgrep, bandit, eslint-plugin-security), gitleaks (scan de secrets en pre-commit et CI), trivy (scan d'images Docker).
Tests de performance : k6 ou locust pour les tests de charge, vérification des temps de réponse p95/p99 sous stress.
Tests de régression : la suite complète s'exécute avant chaque déploiement en production. Chaque bug signalé devient un test de régression.
Tests smoke : un ensemble minimal de 5 à 10 tests exécutés après le déploiement en production (l'application est-elle bien démarrée).
Tests d'acceptation : tests métier (Cucumber/Gherkin) confirmant que l'exigence a été satisfaite.

Un test en échec = merge bloqué. Aucune exception. Si un test est « flaky » (instable), un agent de diagnostic analyse la cause racine et corrige le test ou le code, mais ne supprime jamais le test sans décision humaine.

Cas d'usage typiques

Les patterns que nous appliquons le plus souvent. Chacun s'accompagne de son propre ensemble d'agents, d'outils et de modèles. Time-to-value mesuré en semaines, pas en mois.

Modernisation d'un système legacy

•Ancienne application monolithique (PHP/.NET, sans tests, difficile à maintenir)
•Les agents décomposent le monolithe en microservices (de manière incrémentale, sans interruption)
•Génération de tests de caractérisation (capturant le comportement actuel) avant refactoring
•Migration de données avec audit trail complet et plan de rollback

Nouveau microservice enterprise

•Spécification en entrée (ticket Jira, document PRD, transcription de réunion)
•Architecture → code → tests → revue → déploiement en 2 à 3 semaines
•Intégration avec le SSO existant (Keycloak), le journal d'audit, le monitoring
•Conformité complète à l'EU AI Act et au RGPD dès la première ligne de code

Intégration de systèmes

•Connexion de l'ERP, CRM, KRS, Microsoft Graph, IBM, Cisco, partenaires externes
•Les agents écrivent les adaptateurs, les mappings, le retry/backoff, l'idempotence
•Tests d'intégration sur de vrais endpoints (API sandbox)
•Monitoring (Prometheus + Grafana) et alertes (Sentry) câblés automatiquement

Plateformes multi-tenant

•SaaS multi-clients avec isolation complète des données (schéma par tenant ou row-level security)
•Onboarding client automatisé (provisioning Keycloak, base de données, rôles)
•Facturation basée sur le SDK SSO Billing (suivi de l'usage des tokens, fail-open)
•Conformité : RGPD, ISO 27001, EU AI Act prête pour l'audit

Comparaison : équipe classique vs. processus avec IA

Aspect	Équipe classique (8-10 personnes)	Équipe avec agents IA (2-3 personnes)
Time-to-market (fonctionnalité moyenne)	2-4 semaines	3-7 jours
Couverture de tests	40-60% (si l'équipe a le temps)	>80% par défaut (tests générés avec le code)
Revue de code	1 personne, 30-60 min en moyenne	3 agents (sécurité, qualité, architecture) + humain pour les changements complexes
Documentation	Souvent incomplète, « ajoutée après »	Générée avec le code (OpenAPI, README, CHANGELOG)
Audit trail	Historique Git	Git + journal d'audit en base + CHANGELOG + Change Request
Scaling	Linéaire (plus de personnes = coût de communication plus élevé)	Non-linéaire (plus d'agents = même nombre de personnes en supervision)
Conformité (EU AI Act, RGPD, ISO 27001)	Souvent audit externe a posteriori	Intégrée au processus dès le premier jour

Questions fréquentes

Qu'est-ce que le développement logiciel automatisé avec l'IA ?

C'est un processus dans lequel des agents IA spécialisés participent à chaque étape du cycle de développement logiciel : de l'analyse des besoins, à la conception d'architecture, au codage, aux tests automatisés (unitaires, intégration, E2E, sécurité, performance, régression), jusqu'à la revue de code et au déploiement en production. Les humains continuent à superviser le processus et à prendre les décisions clés, mais les tâches routinières (écriture de code, génération de tests, refactoring, documentation) sont exécutées par les agents IA tout en préservant les standards de qualité convenus.

En quoi cela diffère-t-il de la programmation classique avec Copilot ?

Copilot est de l'autocomplétion — il aide à écrire des lignes de code individuelles. Le développement logiciel avec l'IA est une orchestration complète : un agent planifie l'architecture, un autre écrit le code, un troisième écrit les tests, un quatrième fait la revue de code, un cinquième déploie. Chacun a sa propre spécialisation, sa mémoire épisodique (il apprend des projets précédents), ses outils et son contexte. Résultat : une échelle d'automatisation beaucoup plus grande qu'avec un seul Copilot, tout en conservant les standards enterprise (tests, sécurité, audit trail).

Quels types de tests ce processus exécute-t-il ?

Tous les types de tests utilisés par les équipes de développement matures : tests unitaires, intégration, end-to-end (E2E), UI (Playwright), sécurité (OWASP Top 10, gitleaks), performance (charge), régression, smoke et acceptation. Les tests sont écrits avant ou en parallèle du code (TDD), et chaque modification doit passer le pipeline complet.

L'IA déploie-t-elle le code en production de manière autonome ?

Non — pas automatiquement. Les déploiements en production exigent un Change Request (CR) approuvé et une décision humaine. Les agents IA préparent la documentation des changements, exécutent les tests de régression, génèrent les scripts de déploiement avec les plans de rollback, mais la mise en production finale nécessite l'approbation d'un opérateur. Cette règle est délibérée — elle minimise le risque de conséquences imprévues et préserve un audit trail complet.

Ce processus fonctionne-t-il pour les projets enterprise ?

Oui. Nous l'utilisons sur nos propres produits, notamment la plateforme multi-agents HybridCrew, la plateforme de conseil avec SSO, des microservices backés par PostgreSQL, des intégrations avec des systèmes externes (KRS, MS Graph, IBM, Keycloak). Chaque projet a son propre pipeline CI/CD, ses environnements dev/test/prod, son monitoring et son journal d'audit. Le processus passe à l'échelle d'un seul microservice à une plateforme multi-conteneurs.

Combien de temps faut-il pour déployer ce processus dans notre entreprise ?

Cela dépend du contexte. Pour une petite équipe (1-3 développeurs), l'intégration avec le dépôt et le pipeline CI/CD existants prend typiquement 2 à 4 semaines : audit, configuration des agents, alignement avec les standards de codage, formation. Pour les organisations plus grandes, les projets pilotes (une équipe, un microservice) prennent 6 à 8 semaines, suivis d'une extension graduelle à d'autres équipes.

Et la sécurité du code source ?

Les dépôts clients ne sortent jamais vers des services externes sans accord explicite. Par défaut, tout le processus (agents IA, modèles LLM, base vectorielle, journal d'audit) s'exécute dans l'infrastructure du client ou dans le cloud privé ESKOM AI avec une isolation complète. Les secrets sont gérés via HashiCorp Vault, le code est scanné par gitleaks avant chaque commit, et tous les dépôts sont privés par défaut.

Allez-vous remplacer notre équipe de développement ?

Non. Les développeurs expérimentés sont essentiels — ils conçoivent l'architecture, prennent les décisions, examinent les changements complexes, résolvent les problèmes inhabituels. Les agents IA prennent en charge les tâches répétitives qui se prêtent à l'automatisation : écriture de boilerplate, génération de tests, documentation, refactoring, revue de code de premier niveau. L'objectif : deux ou trois personnes avec l'IA délivrent la valeur d'une équipe de 8 à 10 personnes — sans burn-out, avec une qualité supérieure et un audit trail complet.

Combien coûte le développement logiciel avec l'IA ?

La tarification est toujours spécifique au projet et dépend de l'échelle, du modèle de facturation (abonnement à la plateforme vs. projet dédié), des intégrations requises, et du fait que les agents s'exécutent sur des modèles LLM locaux (Ollama sur le GPU du client — coût d'exploitation plus faible) ou dans le cloud (Anthropic, OpenAI — flexibilité supérieure). Dans les pilotes, nous visons un retour sur investissement au cours du premier trimestre suivant le lancement complet.

Quels sont les signaux typiques qu'une entreprise est prête pour ce processus ?

Les meilleurs résultats viennent des équipes qui disposent déjà : d'un dépôt sous contrôle de version (Git), de standards de codage définis, d'un pipeline CI/CD de base, d'exigences clairement documentées (Jira/Linear/votre propre outil) et d'une culture de revue de code. L'absence de l'un de ces éléments ne bloque pas le déploiement — nous commençons par un audit et un travail de fondation. Les organisations les moins matures sont celles sans contrôle de version ou avec du code de production que personne ne teste.

Prêts pour un pilote ?

Nous commençons par un audit du processus existant et un pilote sur un microservice sélectionné. Premiers résultats visibles en 2 à 4 semaines. Aucun engagement à long terme requis.

Réserver un échange Voir nos produits