Architecture Intelligence pour les équipes AI-native

Quelque chose a changé ces six derniers mois. Les agents IA sont passés de l'écriture de fonctions à l'écriture de services entiers. Claude Code, Cursor, Codex -- ce ne sont plus des assistants. Ce sont des membres de l'équipe. Ils ouvrent des PRs, font des revues de code, livrent des fonctionnalités.

Mais voici ce qui m'empêche de dormir : ces agents n'ont aucune idée de ce à quoi ressemble l'architecture.

Un agent peut écrire un service Go parfaitement propre en dix minutes. Mais il ne sait pas que l'équipe a décidé il y a trois mois de faire transiter toute la communication inter-services par Kafka. Il ne sait pas que le service de paiement interdit tout accès direct à la base de données. Il ne sait pas que Python a été déplacé en "hold" sur le radar technologique le trimestre dernier.

Le résultat ? Du drift architectural à la vitesse des machines.

Nous avons construit Archyl pour résoudre ce problème. Et aujourd'hui, nous livrons la plus grosse mise à jour depuis le lancement : Architecture Intelligence -- un écosystème complet qui fait d'Archyl le système nerveux du développement AI-native.

Le problème : les agents codent vite, mais codent à l'aveugle

Quand un développeur humain rejoint une équipe, il passe des jours à lire la documentation, poser des questions, construire un modèle mental du système. Il apprend les règles -- écrites et tacites. Il comprend les limites.

Les agents IA sautent toutes ces étapes. Ils reçoivent une tâche, écrivent du code, ouvrent une PR. Si personne ne détecte la violation architecturale lors de la revue, elle est livrée. Multipliez ça par dix agents travaillant sur dix services répartis sur trois équipes, et votre architecture soigneusement conçue s'erode en quelques semaines.

Nous avons vu cela se produire. Une équipe avec un modèle C4 impeccable en janvier avait un score de drift de 40 % en mars. Pas parce qu'elle avait cessé de s'en soucier -- mais parce que ses agents ne savaient pas que l'architecture existait.

La solution : l'architecture comme infrastructure

La documentation d'architecture ne devrait pas être quelque chose que l'on maintient. Elle devrait être quelque chose qui se maintient tout seul -- et que chaque agent consulte avant d'écrire la moindre ligne de code.

C'est ce que nous avons construit. Voici ce que nous livrons aujourd'hui.

10 skills pour agents

Le skill original archyl-developer donnait aux agents accès à 181 outils MCP. Mais c'était une boîte à outils sans workflow. Aujourd'hui, nous ajoutons neuf skills specialises qui couvrent l'ensemble du cycle de développement :

Avant de coder

archyl-preflight -- Exécutez-le avant d'implémenter une fonctionnalité. Il vérifie votre approche par rapport au modèle C4, aux règles de conformité, au radar technologique et aux contrats d'API. Vous obtenez un verdict clair PASS / WARN / FAIL avant d'écrire la moindre ligne de code.

> Je m'apprete a ajouter un cache Redis au service utilisateur. Est-ce que c'est ok ?

Verification Preflight : AVERTISSEMENT
- Redis est approuve sur le radar technologique ✓
- Le service utilisateur existe dans le modele C4 ✓
- ⚠ Aucun conteneur de cache documente -- suggestion d'en creer un
- ⚠ La regle "Pas d'acces direct a la DB depuis les handlers" s'applique -- assurez-vous que le cache est accede via la couche service

Après la livraison

archyl-postship -- Exécutez-le après la livraison. Il analyse ce que vous venez de construire, met à jour le modèle C4, crée des ADRs pour les décisions architecturales et soumet des Change Requests pour revue par l'architecte. Votre documentation se met à jour d'elle-même comme effet de bord de votre travail.

Pendant la revue

archyl-review -- Un bot de revue d'architecture. Il vérifie le diff de votre PR par rapport à l'architecture documentée et fournit un feedback structure : violations de conformité, franchissements de frontières, technologies non approuvées, contrats d'API manquants. Pensez à ESLint, mais pour l'architecture.

Pour la visibilité

archyl-changelog -- Génère une timeline lisible de tous les changements d'architecture : nouveaux services, relations modifiées, décisions ADR, évolution du drift. Idéal pour les réunions de revue d'architecture.

archyl-dora -- Corrèle les métriques DORA avec les changements d'architecture. Votre décomposition en microservices a-t-elle améliore le lead time ? Le pic de drift a-t-il précédé l'augmentation du taux d'échec des changements ? Maintenant vous avez les données.

archyl-roi -- Quantifie l'impact financier des décisions architecturales. "Notre investissement dans les règles de conformité a permis d'economiser environ 23 000 $ le trimestre dernier en réduisant le retravail." C'est le genre de données qui fait approuver les budgets d'architecture.

Pour la prevention

archyl-predict -- Prévoit les risques architecturaux avant qu'ils ne se matérialisent. "Au rythme actuel, votre score de drift dépassera 50 % d'ici mai. Le PaymentService a 12 dépendances entrantes -- envisagez une décomposition."

archyl-autofix -- Quand du drift est détecté, propose des correctifs spécifiques. Soit mettre à jour la documentation pour correspondre au code, soit suggérer des modifications de code pour se réaligner sur l'architecture. Crée des Change Requests pour revue humaine.

Pour la coordination

archyl-orchestrate -- Quand plusieurs agents travaillent sur différents services simultanément, ce skill négocie les contrats d'API, résout les conflits de dépendances et s'assure que les changements inter-équipes ne cassent pas l'architecture.

6 GitHub Actions

La gouvernance architecturale a sa place dans la CI. Nous livrons six GitHub Actions qui s'exécutent automatiquement sur chaque PR et merge :

Action	Déclencheur	Ce qu'elle fait
conformance-check	PR	Exécute les règles de conformité sur les fichiers modifiés, annote les violations en ligne
drift-score	PR	Calcule le score de drift, poste en commentaire de PR, échoue en dessous du seuil
generate-context	Push sur main	Génère `archyl.txt` -- un briefing architectural optimise en tokens pour les agents
auto-cr	Push sur main	Crée automatiquement des Change Requests d'architecture à partir des diffs de merge
release	Deploy	Suit les releases dans Archyl avec l'environnement et la version
sync	Push sur main	Synchronise le DSL `archyl.yaml` pour maintenir l'architecture as code

La configuration recommandée tient en un seul fichier :

name: Architecture
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]

jobs:
  pr-checks:
    if: github.event_name == 'pull_request'
    uses: archyl-com/actions/.github/workflows/archyl-pr.yml@v1
    with:
      organization-id: ${{ vars.ARCHYL_ORG_ID }}
      project-id: ${{ vars.ARCHYL_PROJECT_ID }}
      drift-threshold: 70
    secrets:
      api-key: ${{ secrets.ARCHYL_API_KEY }}

  main-update:
    if: github.event_name == 'push'
    uses: archyl-com/actions/.github/workflows/archyl-main.yml@v1
    with:
      organization-id: ${{ vars.ARCHYL_ORG_ID }}
      project-id: ${{ vars.ARCHYL_PROJECT_ID }}
    secrets:
      api-key: ${{ secrets.ARCHYL_API_KEY }}

Pas sur GitHub ? Nous fournissons aussi des templates pour GitLab CI et Bitbucket Pipelines.

Packs de règles de conformité

Mettre en place une gouvernance architecturale de zéro est fastidieux. Nous avons donc construit cinq packs de règles pré-configurés que vous pouvez installer en quelques secondes :

Pack	Règles	Ce qu'il impose
Microservices	10	Pas de bases de données partagées, déploiement indépendant, communication bornée
Clean Architecture	9	Frontières entre couches, isolation du domaine, patterns port/adaptateur
Event-Driven	8	Conformité des canaux, exigences de schémas, dead letter queues
API-First	8	Exigences de contrats, versioning, documentation de l'authentification
Security Baseline	8	Application des gateways, gestion des secrets, contrôles d'accès

Installation via le skill agent : "Installe le pack de règles de conformité microservices." C'est fait.

SDKs

Pour les équipes qui construisent des intégrations personnalisées, nous publions des SDKs officiels :

npm install @archyl/sdk    # Node.js 18+, zero dependances
pip install archyl-sdk     # Python 3.10+

const archyl = new ArchylClient({ apiKey: 'arch_...', organizationId: 'uuid' });
const drift = await archyl.governance.computeDrift(projectId);
const predictions = await archyl.projects.getPredictions(projectId);

Trois nouvelles APIs alimentées par l'IA

Sous le capot, nous livrons trois nouvelles capacités backend :

Predictive Analytics (GET /projects/:id/predict) -- Une vraie analyse statistique. Regression linéaire sur les scores de drift, trajectoires des métriques DORA, taux de dégradation de la conformité et détection de hotspots de complexité via l'analyse de couplage fan-in/fan-out. Pas du feeling -- des maths.

Architecture Diff Analysis (POST /projects/:id/architecture-diff) -- Envoyez un diff git, recevez un delta de modèle C4 structure. Analyse alimentée par l'IA qui détecte les nouveaux services, les dépendances modifiées et les décisions architecturales. Suggère des ADRs quand des décisions significatives sont détectées.

ROI Computation (GET /projects/:id/roi) -- Quantifie le retour sur investissement de l'architecture. Sépare vos métriques DORA avant/après, calcule les gains de productivité (heures économisées x coût horaire), les gains de fiabilité (incidents évités x coût par incident), et classe vos ADRs par impact financier.

Les trois sont disponibles en tant qu'outils MCP, afin que chaque skill agent puisse les appeler directement.

La boucle complète

Voici comment tout s'articule :

L'agent recoit une tache
       │
       ▼
  archyl-preflight ──── valide l'approche par rapport a l'architecture
       │
       ▼
  L'agent ecrit le code
       │
       ▼
  archyl-review ──────── revise la PR par rapport au modele C4
       │
       ▼
  CI: conformance-check ─ bloque les violations
  CI: drift-score ──────── impose l'alignement
       │
       ▼
  Merge sur main
       │
       ▼
  CI: auto-cr ──────────── soumet une Change Request
  CI: generate-context ─── met a jour archyl.txt
       │
       ▼
  archyl-postship ──────── met a jour le modele C4 + les ADRs
       │
       ▼
  Le prochain agent lit archyl.txt ← le cycle se repete

L'architecture n'est pas maintenue. Elle se maintient d'elle-même.

Pour commencer

1. Installez les skills :

/plugin marketplace add archyl-com/agent-skills
/plugin install archyl-preflight@archyl-com-agent-skills

2. Ajoutez les GitHub Actions : Copiez le workflow ci-dessus dans .github/workflows/architecture.yml.

3. Générez votre premier archyl.txt : Lancez l'action generate-context ou demandez à votre agent : "Génère le fichier de contexte architectural pour ce projet."

4. Commencez à coder. Votre agent connaît désormais l'architecture.

Et après

Ce n'est que le début. Nous travaillons sur des dashboards frontend pour les predictions et le ROI, une intégration plus poussée avec davantage d'agents de codage, et une marketplace communautaire pour les packs de règles de conformité.

La documentation d'architecture a toujours été ce que les équipes avaient l'intention de faire mais ne faisaient jamais. Quand les agents écrivent le code, l'architecture devient la seule chose que les humains doivent posséder. Archyl fait en sorte qu'ils n'aient pas à le faire seuls.

Tout ce que nous avons livré aujourd'hui est open source. Vos retours sont les bienvenus.