Capsules et Agents IA dans le Développement de Produits

Capsules en action : Intégration d'agents IA pour l'automatisation du développement

Les agents IA dans le développement de produits nécessitent une structure de contexte stricte. Les capsules fournissent des connaissances expertes dans un format minimaliste avec des outils prêts à l'emploi, garantissant une génération prévisible de code et d'artefacts architecturaux. Cela élimine l'évolution chaotique de l'architecture lors de tâches séquentielles.

Modes des agents et rôle de la structure

Les agents sont utilisés dans le prototypage et le développement de produits. En prototypage, l'accent est mis sur des résultats rapides sans contraintes. Dans les produits, les exigences non fonctionnelles sont obligatoires : maintenabilité, lisibilité, évolutivité.

Sans structure, un agent fait des choix arbitraires, perdant l'uniformité du service. Une capsule résout ce problème grâce à trois composants :

• Connaissances expertes : Expérience emballée sans suppositions.
• Minimalisme : L'essentiel sans informations superflues pour la fenêtre de contexte.
• Outil prêt à l'emploi : Méthodes, compétences, interfaces pour les agents.

Le contexte supplémentaire du projet est stocké dans AGENTS.md et CLAUDE.md — guides de style, formats de commit.

Transfert de connaissances via serveur MCP

Les connaissances expertes sont transférées à l'agent via un serveur MCP avec deux outils :

• Documentation du framework : Principes, structure de service, modèles BaseMethod, conteneur d'injection de dépendances, événements.
• Documentation archland.json : Format, règles de remplissage, génération de diagrammes C4.

La séparation économise des tokens : l'agent demande l'outil pertinent. Les documents sont orientés agent — style impératif, règles, algorithmes.

Exemple tiré de la documentation du framework nsc-toolkit :

# Framework nsc-toolkit : Guide de génération de code

Ce document est structuré comme un ensemble de règles et de modèles
pour la génération automatique de code correct.

## Cœur du framework : Classe de méthode (BaseMethod)

Règles d'implémentation :
- Déclarer une propriété settings statique,
  copiée depuis service.schema.json.
- La logique principale est implémentée dans la méthode handler.
- Injecter les dépendances via le constructeur avec le décorateur @inject.
- Utiliser this.logger pour la journalisation.
- Utiliser this.emitter pour la génération d'événements.

RÈGLE : Créer une méthode pour chaque appel RPC de service.schema.json.
RÈGLE : Seules les dépendances actuelles et utilisées doivent être liées au conteneur.

Algorithme pour archland.json :

Algorithme de génération pour chaque service :

Étape 1. Informations de base :
  - Lire service.schema.json → nom, description
  - Écrire les chemins : describePath, folderPath

Étape 2. Analyse du conteneur d'injection de dépendances :
  - Lire service.ts
  - Pour chaque container.bind() créer un objet Dependency
  - Analyser les tags pour type et externe

Étape 3. Analyse des méthodes :
  - Pour chaque classe dans methods/ :
    lire service.schema.json pour la description
    analyser le code pour les appels de dépendances et la génération d'événements

Étape 4. Analyse des abonnements :
  - Pour chaque classe dans processing/ :
    déterminer la clé d'injection de dépendances depuis inversion.types.ts
    analyser la méthode start() pour déterminer le service source

Étape 5. Collecter toutes les données dans un seul objet archland.json

Pratique : Ajout d'une méthode ListOrders

Scénario : Une méthode pour lister les commandes utilisateur dans le service @services/order avec exposition à l'API HTTP.

Le développeur décrit le format de données. L'agent génère le schéma dans service.schema.json :

"ListOrders": {
  "action": "ListOrders",
  "description": "Récupération d'une liste de commandes utilisateur",
  "request": {
    "type": "object",
    "properties": {
      "credentials": {
        "type": "object",
        "properties": {
          "user_id":  { "type": "string" },
          "space_id": { "type": "string" }
        },
        "required": ["user_id", "space_id"]
      }
    },
    "required": ["credentials"]
  },
  "response": {
    "type": "object",
    "properties": {
      "result": {
        "type": "object",
        "properties": {
          "items": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "order_id":   { "type": "string" },
                "product_id": { "type": "string" },
                "quantity":   { "type": "number" },
                "created_at": { "type": "string" }
              },
              "required": ["order_id", "product_id", "quantity", "created_at"]
            }
          }
        }
      }
    },
    "required": ["result"]
  }
}

Invite à l'agent :

Créez une nouvelle méthode ListOrders dans le service @services/order.
La méthode accepte : user_id depuis credentials.
Retourne : une liste de commandes, chacune avec les champs order_id, product_id, quantity, created_at.
Exposez la méthode dans @services/gate dans l'ensemble de points de terminaison @services/gate/routes/orders.ts.

Séquence des actions de l'agent :

• Lit CLAUDE.md → demande la documentation MCP.
• Ajoute le schéma à service.schema.json.
• Exécute la génération de code à l'aide de modèles.
• Implémente la logique métier avec @inject, ports.
• Ajoute un point de terminaison HTTP suivant le modèle.
• Forme un commit selon les règles.

Temps : 10 minutes. Le modèle est reproductible pour des tâches similaires.

Génération d'un album architectural

Invite : Générez archland.json et l'album architectural du projet.

L'agent récupère la documentation du MCP, parcourt les services, analyse les schémas, l'injection de dépendances, les méthodes, les abonnements. Collecte les données dans archland.json avec des diagrammes C4 des zones problématiques. Le processus est déterministe basé sur l'algorithme de la documentation.

Points clés à retenir

• Les capsules fournissent une structure pour les agents dans le développement de produits.
• Le serveur MCP transfère les connaissances expertes via des outils minimalistes.
• La documentation est impérative : règles, algorithmes, modèles pour les agents.
• Automatisation des tâches : génération de code, points de terminaison HTTP, albums architecturaux en 10 min.
• Prévisibilité : architecture uniforme sans changements chaotiques.

— Editorial Team