Que fait Ingénierie de l'Architecture Logicielle ?
Objectif
Maintenir la cohérence de l'architecture pendant que le logiciel est modifié, y compris les modifications écrites par des agents IA. Il s'agit d'une compétence opérationnelle, pas d'un ordre de reconcevoir chaque projet. Ses principes réutilisables proviennent de Fundamentals of Software Architecture, 2e éd. (Richards et Ford, 2025) ; les workflows continus d'agents et les artefacts sont des extensions originales. Aucun modèle, langage de programmation, hébergeur de dépôt, outil CI ou framework spécifique n'est requis.
Appliquer trois lois en permanence :
- Tout est un compromis. Évaluer les coûts ainsi que les bénéfices, pondérés par le contexte réel ; réévaluer lorsque les conditions changent.
- Le pourquoi importe plus que le comment. Préserver la justification, les options rejetées, les risques et les propriétaires des décisions, pas seulement les diagrammes et le code.
- Les décisions se situent sur un spectre. Rejeter les binaires fallacieux, les règles absolues sur les microservices et les modes architecturales.
Choisir l'effort en fonction de l'impact
| Mode | Déclencheur typique | Action et résultat attendu |
|---|---|---|
| Léger | Bogue isolé, formatage, implémentation locale sans effet sur les contrats/limites | Inspecter le code et les contraintes pertinents ; apporter une modification minimale ; exécuter les vérifications appropriées ; ne signaler que les problèmes matériels. Pas d'ADR obligatoire. |
| Standard | Fonctionnalité transverse aux modules, nouvelle intégration, modification d'API/schéma, refactorisation conséquente | Établir le contexte du projet ; inspecter les dépendances ; comparer des options réalistes ; implémenter par incréments ; vérifier les limites et les contrats ; enregistrer les décisions significatives. |
| Approfondi | Nouvelle plateforme, découpage de service, migration majeure, modification à haut risque (données/sécurité/fiabilité), revue d'architecture | Analyse complète du contexte et de l'architecture, alternatives, modes explicites de données/défaillance, migration et rollback, fonctions de fitness mesurables, ADR(s), risque et limites d'approbation. |
Escalader lorsqu'une modification supposée mineure franchit des limites de propriété, modifie des contrats publics, altère la persistance, introduit de nouveaux composants d'exécution/déploiement, élargit l'impact des défaillances ou révèle une dérive architecturale. Déscalader si l'investigation ne montre aucun impact architectural significatif. Les instructions de l'utilisateur/du projet/de la sécurité prévalent. Ne jamais imposer de rapports lourds pour des tâches triviales.
Boucle requise pour l'agent de codage
Pour un travail dans un dépôt existant, exécuter cette boucle. Voir gouvernance d'implémentation des agents pour la procédure précise, la gestion des erreurs et les règles pour les agents parallèles.
0. Découvrir le système actuel—ne pas l'inventer
- Inspecter le code, les tests, les fichiers de package/build, l'infrastructure, la configuration, la documentation, les ADR, la structure des répertoires et les chemins de dépendances réels lorsqu'ils sont accessibles.
- Localiser tout contrat d'architecture du projet, par ex.
docs/architecture/CONTRACT.md, et les ADR acceptés ; les traiter comme des contraintes du projet, pas comme des vérités immuables. - Enregistrer observé / fourni / supposé / inconnu séparément. S'il n'existe aucun accès au code/outil, indiquer que le résultat est une proposition, pas une analyse de dépôt vérifiée.
- Ne pas remplacer silencieusement l'architecture déjà en place par un style préféré.
1. Évaluer l'impact avant de modifier
- Définir le périmètre du changement, les capacités métier affectées, les modules propriétaires, les API/contrats, les responsabilités en matière de données, les dépendances, les limites de sécurité, les unités de déploiement et les chemins de défaillance.
- Classer la tâche Léger / Standard / Approfondi et choisir la plus petite révision adéquate.
- Pour les décisions matérielles, dériver quelques caractéristiques architecturales priorisées (par ex. sécurité, latence, disponibilité, évolutivité, élasticité, maintenabilité, testabilité, déployabilité, récupérabilité, coût) avec périmètre, cible et mesure. Séparer les exigences explicites des besoins implicites non confirmés.
- Choisir des valeurs par défaut minimales et réversibles pour les inconnues à faible risque ; ne pas agir sur des hypothèses à haut risque non étayées comme si elles étaient confirmées.
2. Préserver les limites et comparer les alternatives le cas échéant
- Favoriser une forte cohésion et un faible couplage. Rendre explicite la responsabilité métier, la direction des dépendances, le couplage temporel et la propriété des données. Distinguer les modules logiques des services déployés indépendamment.
- Vérifier les implications pour l'architecture opérationnelle et des données, pas seulement la structure des répertoires. Une base de données partagée, une limite de transaction ou un appel synchrone peuvent annuler une modularité apparente.
- Pour les changements conséquents, comparer au moins deux options réalisables en utilisant des compromis pondérés par le contexte. Les candidats peuvent inclure : monolithe en couches, monolithe modulaire, pipeline, micro-noyau, basé sur les services, événementiel, basé sur l'espace, SOA orientée orchestration, microservices ou hybrides. Aucun style d'architecture n'est le défaut universel.
- Les conceptions distribuées doivent traiter la latence/panne réseau, la disponibilité, la cohérence, les limites de transaction, les tentatives, l'idempotence, l'observabilité, la sécurité et le coût opérationnel selon le cas.
- Nommer les conditions qui inverseraient la décision. Utiliser styles, conception distribuée et fondations de manière sélective.
3. Planifier l'implémentation par incréments sécurisés
- Identifier les modifications attendues de fichiers/modules, les contrats qui doivent rester stables, l'ordre de migration et la stratégie de rollback si nécessaire.
- Énoncer les invariants architecturaux (règles qui doivent rester vraies) : direction de dépendance autorisée, propriété des API internes, autorité d'écriture des données, limites de locataire/authentification, compatibilité ascendante, gestion des erreurs, etc.
- Choisir des vérifications objectives pour ces invariants avant d'implémenter. Le cas échéant, copier/adapter contrat d'architecture du projet et modèle d'impact de changement ; ne pas créer de fichiers projet sans autorisation ou périmètre de tâche clair.
- Demander ou différer les décisions irréversibles/à fort impact qui nécessitent une autorité humaine/métier. Ne pas contrefaire les approbations.
4. Implémenter sans dérive architecturale
- Apporter le plus petit changement cohérent compatible avec l'architecture actuelle. Ne pas découper des services, introduire des courtiers, des abstractions globales ou de nouveaux frameworks sans besoin démontré.
- Maintenir les interfaces et la propriété des données explicites. Ne pas créer de raccourcis à travers les internes d'un autre module, contourner l'auth/validation, modifier silencieusement les schémas d'événements, ou mélanger des modifications sans rapport.
- Si l'implémentation révèle un défaut matériel dans le plan, s'arrêter et réévaluer la décision affectée plutôt que de le masquer avec du code de contournement. Mettre à jour l'ADR/le contrat uniquement lorsque c'est justifié.
- En travail multi-agent, définir la propriété des composants/fichiers, les contrats stables et un propriétaire d'intégration. Les modifications parallèles ne remplacent pas les contraintes architecturales partagées.
5. Vérifier l'architecture, pas seulement la fonction
- Exécuter les tests unitaires/d'intégration/de contrat existants et les vérifications de construction lorsqu'ils sont disponibles et autorisés.
- Vérifier les fitness functions spécifiques à l'architecture : dépendances interdites, cycles, propriété des modules, compatibilité des API, migration de schéma, idempotence, budgets de performance, observabilité, résilience, sécurité, déploiement/rollback, selon le cas.
- Comparer la structure des dépendances avant/après et les invariants affectés. Un vérificateur de limites d'import optionnel de la bibliothèque standard avec un exemple de configuration peut appliquer certaines règles d'import Python/JS/TS ; il est intentionnellement limité et ne prouve pas l'exactitude architecturale complète.
- Étiqueter les preuves SUCCÈS / ÉCHEC / NON EXÉCUTÉ / NON APPLICABLE. Ne pas prétendre que des tests, l'évolutivité, l'état de préparation à la production, la sécurité ou les déploiements ont été vérifiés sans exécution/preuve effective.
- Si une porte obligatoire échoue, corriger/revenir en arrière, ou identifier explicitement le problème non résolu et le propriétaire de la décision. Ne jamais présenter une porte échouée comme un travail terminé.
6. Enregistrer et communiquer les décisions conséquentes
- Créer ou mettre à jour un ADR concis uniquement pour les changements architecturalement significatifs : titre, statut, contexte, solution choisie, pourquoi, alternatives, compromis, conséquences, application et déclencheur de révision. Utiliser modèle ADR.
- Préserver les décisions historiques lorsqu'elles sont remplacées. Traiter les diagrammes comme des aides à la communication, pas comme des preuves d'implémentation ou de validation.
- Dans le rapport final, indiquer : ce qui a changé ; l'impact architectural ; les vérifications réussies, échouées ou non exécutées ; les risques en suspens ; et toute décision humaine requise. Pour les changements Légers, un paragraphe concis suffit généralement.
Tâches de conception uniquement et d'audit
Lorsque vous ne modifiez pas un dépôt, appliquer les étapes 0 à 3 et 6 proportionnellement ; produire une conception, une analyse de compromis, un brief d'architecture ou une revue sans prétendre que quoi que ce soit a été implémenté ou testé. Pour un audit d'architecture complet, inventorier les composants, la propriété des données, les limites, le déploiement et les contraintes d'équipe/infrastructure ; classer les risques concrets avec preuves ; proposer des remédiations incrémentales et des fitness functions avant de recommander des réécritures complètes.
Garde-fous non négociables
- Aucun fait invérifiable : Pas d'inspections de dépôt, de résultats de tests, de niveaux de charge, de statut de conformité, de coûts, d'approbations de parties prenantes ou de mesures inventés.
- Pas d'universaux fallacieux : Ni les microservices, ni les monolithes, ni les systèmes événementiels ne sont intrinsèquement meilleurs. Ne pas découper les services par table/entité uniquement.
- Pas de confusion de périmètre : Les modules logiques, les unités déployées, la propriété des données et le périmètre des caractéristiques architecturales sont des concepts différents.
- Pas de couplage caché : Examiner les schémas partagés, les bibliothèques partagées, le couplage temporel, les appels interservices et les contrats d'événements ; la réutilisation d'une logique métier volatile peut augmenter le couplage.
- Pas d'effacement des risques : La cohérence distribuée, la gestion des transactions, les modifications de schéma, la récupération après panne et le rollback nécessitent une réflexion explicite lorsqu'ils sont pertinents.
- Pas de théâtre de processus : Une liste de contrôle remplie ou une auto-évaluation n'est pas une preuve. Prioriser les vérifications réelles et les preuves de code.
- Pas de modifications architecturales silencieuses : Signaler les écarts importants, documenter les raisons et garder la responsabilité avec le propriétaire humain/du projet de la décision.
- Pas de distribution de livre protégé par le droit d'auteur : Cette compétence est une synthèse originale. Ne pas copier le livre ou ses diagrammes dans les dépôts en aval.
Fichiers de référence à la demande
Lire uniquement les fichiers nécessaires à la tâche (chemins relatifs à ce répertoire de compétence) :
- Gouvernance du codage IA et de l'architecture continue — requis pour les modifications substantielles de dépôt, les revues de PR, les agents parallèles et le diagnostic de dérive architecturale.
- Fondations et caractéristiques architecturales — exigences, couplage, cohésion, composants, périmètre des caractéristiques.
- Styles d'architecture — neuf styles et conditions de sélection.
- Systèmes distribués et patrons — réalité réseau, événements, transactions, cohérence, orchestration, CQRS.
- Décisions, fonctions de fitness et risques — ADR, gouvernance, storming des risques, diagrammes.
- Personnes, données, infrastructure et IA — équipes et contraintes opérationnelles.
- Carte des sources — les 27 chapitres du livre et la distinction entre les idées du livre et les extensions spécifiques aux agents.
- Rubrique de vérification — critères de qualité pour les décisions de conception majeures et la revue d'implémentation.
Artefacts : brief d'architecture, contrat d'architecture, impact de changement, ADR, matrice de compromis, registre des risques, revue d'architecture, exemple de politique de limites. Scénario travaillé : Codage IA sans dérive de limites. Les autres instructions de modèle/d'exécution sont optionnelles ; voir portabilité.