Programmation
Améliorer un outil de test par mutation à partir du code et des tests actuels
Pour modifier un outil de test par mutation. Vérifie d’abord le code et les tests actuels, garde l’ordre de traitement et l’évaluation différée, ajoute des mutateurs sans mutants invalides, écrit des tests qui les détectent et suit des étapes sûres de revue, CI et publication.
Ajouter des fonctionnalités à une application de bureau en couches et tester chaque configuration
À utiliser quand une IA modifie une application de bureau divisée en noyau, hôte de bureau et interface Web. Elle garde les règles dans le noyau, limite les commandes et dossiers des outils, sépare les options selon les vraies dépendances et teste chaque configuration avant de conclure.
Trouver les vrais bugs dans les patchs de systèmes bas niveau, sans chicaner sur le style
À utiliser pour revoir des patchs système bas niveau, comme des pilotes ou des bibliothèques réseau. Suit la mémoire, les verrous et les chemins d'erreur, vérifie entiers, threads, crypto et changements d'API, et ne signale que des défauts corrigeables ; le style, seulement si très sûr.
Ajouter des fonctionnalités à un service Go extensible avec des tests qui résistent aux surcharges de configuration
Pour modifier un service Go que d’autres builds renomment ou personnalisent. Garde le contexte de trace dans les logs, enregistre les nouveaux outils dans le bon groupe, teste le comportement public avec une configuration surchargée et met à jour la doc générée.
Reproduire le comportement d’un autre framework web avec une couche de compatibilité
Pour réimplémenter un autre framework web sur plusieurs environnements. L’IA porte d’abord ses tests, respecte l’ordre des requêtes et les limites entre environnements, normalise les chemins de fichiers et ne fusionne que par des pull requests qui passent tous les contrôles.
Modifier une couche d’encapsulation managée et sa bibliothèque native sans casser l’ABI
Pour éditer une surcouche managée multiplateforme sur une bibliothèque C native. Suit chaque changement couche par couche, compile les binaires natifs depuis la source sans téléchargements périmés, garde l’ABI stable, gère la propriété des pointeurs et les threads et ne saute aucun échec.
Ajouter et tester des noyaux dans une bibliothèque de noyaux GPU compilés en JIT
Pour une IA qui travaille sur une bibliothèque de noyaux GPU compilés à l’usage (JIT). Elle ajoute les noyaux couche par couche, écrit les fichiers générés hors des dossiers installés, teste par type de GPU et vérifie les résultats avant de mesurer la vitesse.
Modifier et réviser une passerelle d'intégration multiprotocole sans casser les contrôles d'accès
À utiliser quand une IA modifie ou révise une passerelle reliant plusieurs protocoles. Elle passe les contrôles du projet, garde les permissions strictes, isole les écritures de traces et d'audit, soigne les migrations et demande l'accord avant un push.
Créer des services Rust asynchrones qui résistent aux annulations et aux pannes
Pour les services Rust asynchrones : l’IA termine le vrai code sans simulations, gère les erreurs et les annulations sans risque, teste via la vraie interface du service et passe toutes les vérifications avant d’annoncer la fin.
Modifier une bibliothèque de données multilangage sans casser ses formats de fichier ni ses API
À utiliser quand une IA modifie une bibliothèque de données rapide, à noyau natif et liaisons légères. Elle garde compatibles les formats de fichier stables et les API publiques, suit les commandes documentées et ajoute tests et documentation.
Écrire du code de réplication de données (ETL) sans altérer les valeurs en silence ni laisser fuir de données
Pour écrire ou modifier du code qui copie des données entre bases. L’IA garde les changements petits, bloque les arrondis et autres changements silencieux, renvoie des erreurs claires sur une entrée invalide, n’écrit ni secrets ni lignes dans les logs et vérifie que les tests ont tourné.
Modifier un outil d'automatisation d'appareils et le vérifier sur de vrais appareils
Quand une IA modifie un outil multiplateforme d'automatisation d'appareils. Garde les changements petits, centralise les commandes dans un registre, choisit les tests selon le changement et vérifie avec des builds récents sur de vrais appareils ou des simulateurs avant de rendre compte.
Modifier un grand monorepo typé sans casser les autres paquets
À utiliser quand une IA modifie du code à plusieurs paquets. Elle trouve le paquet concerné, réutilise les utilitaires communs, suit les règles de construction et de typage, ne teste que les paquets touchés et ne signale que les vérifications réellement faites.
Modifier un moteur de stockage de base de données sans perdre en vitesse ni en compatibilité
À utiliser quand une IA modifie un moteur de stockage de base de données. Gère bien les erreurs et la concurrence, n’accélère le code le plus exécuté qu’avec des mesures, garde compatibles API, formats et compilations, et exige des tests reproductibles avant toute approbation.
Développer une CLI multiplateforme dans un arbre de travail partagé sans abîmer le travail des autres
Pour créer une CLI dans un arbre de travail partagé avec d'autres sessions. Elle reste dans l'arbre actuel, garde les modifications des autres, sépare les données des messages pour les gens, teste sur tous les systèmes et tient à jour snapshots et documentation.
Créer un outil de conteneur sans root, avec verrous et téléchargements d’images vérifiés
Pour créer un outil de conteneur sans root. L’IA verrouille les conteneurs lors des changements, vérifie chaque couche d’image téléchargée, ne copie pas l’environnement de l’hôte, arrête tout l’arbre de processus et refuse les chemins dangereux à la restauration.
Créer un outil qui relit et corrige le code avec l’IA sans perdre le code de l’utilisateur
À utiliser sur un outil qui fait relire et corriger du code par l’IA en arrière-plan. Lit d’abord le build et la doc des responsables, empêche les branches non fiables de lancer des commandes, protège les jobs actifs et bloque les push ou releases risqués.
Écrire des compétences pour agents d’IA et tester qu’elles aident vraiment
Pour ajouter ou mettre à jour des compétences dans une bibliothèque de compétences pour agents d’IA. Couvre noms et versions, descriptions qui se déclenchent au bon moment, droits d’outils minimaux, tests avec et sans la compétence et vérifications avant publication.
Apporter de petites modifications testées au monorepo d’un framework
Quand une IA modifie le code du monorepo d’un framework. Elle cherche d’abord les fichiers de consignes principaux, limite chaque modification à un comportement, écrit un test qui échoue avant la correction et vérifie la sécurité, la compilation et les notes de publication.
Modifier un grand monodépôt Python de flux de travail sans le casser
Quand une IA modifie un grand monodépôt Python de flux de travail. Elle sépare les rôles de l’ordonnanceur, des processus d’exécution et de la base de données, place chaque dépendance dans le bon paquet, teste d’abord le changement et relit tout le diff avant la demande d’intégration.
Modifier ensemble les versions synchrone et asynchrone d'une bibliothèque cliente sans casser l'API
Pour une IA qui modifie une bibliothèque cliente synchrone et asynchrone. Elle garde les API publiques et les erreurs, applique le même changement des deux côtés, ne ralentit pas les chemins critiques et teste du cas en échec à la matrice complète.
Créer un service de mémoire pour agents IA sans mélanger les souvenirs des utilisateurs
Pour créer ou étendre la mémoire à long terme d'agents IA. Garde chaque banque de mémoire séparée, distingue ingestion, récupération et raisonnement, et couvre migrations de base de données, clients d'API, tests jugés par un autre modèle et réglages par locataire ou banque.
Modifier le monorepo d'une plateforme de travaux distribués et le tester avec de vrais services
À utiliser quand une IA modifie un monorepo de travaux distribués. Elle choisit la bonne vérification par paquet, teste avec de vraies bases de données et files d'attente, consigne les changements publiés, exécute en local une tâche complète et indique ce qui a été vérifié ou omis.
Créer des modules .NET pilotés par le domaine (DDD) sans casser les couches ni les API publiques
À utiliser quand une IA modifie une application .NET modulaire pilotée par le domaine. Elle suit les modèles existants, garde les couches à sens unique, place agrégats, dépôts et DTO dans la bonne couche et teste sur toutes les bases de données sans perturber les utilisateurs actuels.
Modifier une extension multi-navigateur sans divulguer de secrets ni casser les données enregistrées
Pour modifier une extension publiée sur plusieurs navigateurs. L’IA garde les secrets en local, régénère les politiques des dépendances, ajoute des mises à niveau numérotées pour les données enregistrées, teste dans la bonne couche et n’utilise Git que sur demande.
Modifier du code distribué d’entraînement et d’inférence en apprentissage automatique sans le casser
Pour modifier du code qui entraîne ou exécute des modèles sur de nombreux processus ou accélérateurs. Consulte avant les changements risqués, aligne les versions de poids et l’ordre des opérations collectives sur chaque rang, garde la configuration compatible et signale les tests ignorés.
Développer une application web qui affiche en direct les journaux et mesures de conteneurs
Pour modifier une application qui diffuse en direct les journaux et mesures de conteneurs. L’IA respecte les couches, les limites de flux et les modes de connexion et de déploiement, ajoute les fonctions partout, lance les tests et rédige des revues brèves.
Modifier un paquet serveur public que d’autres étendent sans casser leur code
Pour modifier un paquet serveur publié que d’autres étendent par des hooks. L’IA garde les secrets hors du paquet, préserve callbacks, hooks et ordre des middlewares, ajoute de nouvelles migrations au lieu de modifier les anciennes et lance les vrais tests et le lint.
Modifier un projet C portable et ancien sans casser la compatibilité
Quand une IA modifie un code C mature qui doit compiler avec d'anciens compilateurs, sur maintes plateformes et avec des options. Elle compile et teste le code touché, suit les règles de style, mémoire, commit, doc et publication, et garde chaque correctif petit et valide à lui seul.
Modifier un dépôt multimodule backend et frontend sans casser la compilation
À utiliser quand une IA modifie un dépôt réunissant API, backend et frontend. Elle lit les règles de chaque module, garde les deux côtés alignés, régénère le client de l’API au lieu de le retoucher à la main, lance les bons tests et demande avant une migration ou une nouvelle dépendance.
Modifier un grand monorepo de plateforme de données multilingue et préparer les pull requests
Quand une IA modifie une grande plateforme de données en plusieurs langages, elle choisit la bonne branche Git, ne retouche pas les fichiers générés, prend la base de test minimale, teste seulement ce qui a changé, examine chaque échec de CI et demande avant tout push ou pull request.
Écrire et relire une automatisation d'infrastructure Ansible sans affaiblir la sécurité
À utiliser quand une IA écrit ou modifie une automatisation d'infrastructure Ansible. Elle passe les lint et contrôles de sécurité sans avertissement, garde les secrets hors du dépôt, teste le réseau de bas en haut, prouve que les tests trouvent le bug et ne signale que les tests lancés.
Modifier un grand système de données Python sans casser l'exécution différée
À utiliser quand une IA modifie un grand système Python de données ou de calcul parallèle. Elle repère d'abord les couches, ne lance aucun calcul en construisant les graphes, teste du plus proche au plus large et ne publie rien sans autorisation.
Écrire d'abord la spécification, puis développer par petites étapes en commençant par les tests
À utiliser quand une IA code à partir de demandes floues dans un dépôt avec spécifications et plans. Note les questions et attend, révise spécification et plan, écrit d'abord des tests en échec, vérifie les fichiers modifiés, protège la base de données et laisse une passation claire.
Écrire des règles de vérification d'accessibilité qui renvoient réussite, échec ou incomplet
Pour une IA qui ajoute ou modifie des règles d'un vérificateur d'accessibilité web. Elle sépare les couches DOM et dépendances, lit les données HTML et ARIA à un seul endroit, teste sur des pages réalistes avec Shadow DOM, synchronise les traductions et évite les changements incompatibles.
Générer des schémas de commandes pour agents IA à partir des vraies commandes et options
Pour créer les schémas qui indiquent aux agents IA quelles commandes existent et comment les appeler. L’IA les génère dans un seul sens à partir d’une liste vérifiée et des vraies commandes, et contrôle la couverture, les exemples, la sécurité et la confirmation.
Apporter des changements petits et compatibles dans un projet Java découpé en modules
Quand une IA modifie un projet Java découpé en modules. Vérifie d’abord les règles de build et de CI, garde fonctionnelles les anciennes versions de Java et les dépendances entre modules, teste au bon niveau et demande avant tout changement large ou risqué.
Ajouter des fonctions à une bibliothèque multilingue d’infrastructure en tant que code sans casser les utilisateurs actuels
Pour modifier une bibliothèque IaC typée qui génère des liaisons vers d’autres langages. Place chaque fonction dans la bonne couche, évite la syntaxe non prise en charge, protège les changements par des indicateurs de fonctionnalité, limite les permissions et ajoute doc et tests.
Ajoutez des modules à un serveur Go sans affaiblir la sécurité
Pour créer ou examiner des fonctions d’un serveur Go extensible. L’IA écrit chaque module dans l’ordre, de la création au nettoyage, lit strictement la configuration, passe tests, lint et compilation sous Linux, macOS et Windows avant fusion, et laisse les pull requests à une personne.
Créez une app TypeScript native et web en suivant les règles du dépôt
À utiliser pour créer ou modifier une app TypeScript qui tourne en natif et sur le web. L’IA suit les scripts et l’organisation des dossiers du dépôt, réutilise les composants partagés, rend les textes affichés traduisibles et teste chaque plateforme concernée avant de terminer.
Modifier un dépôt sur toute la pile sans casser la compatibilité
À utiliser quand une IA modifie un dépôt sur toute la pile applicative. Elle lit d’abord les consignes, garde compatibles les clés de base de données, les migrations et les champs d’API, réutilise les composants partagés et les traductions, et ne signale que ce qu’elle a exécuté.
Corrigez les tests E2E en échec en observant le vrai navigateur
Quand un test E2E échoue. Fixe l’état de réussite visible, lance le test dans un vrai navigateur, recueille captures d’écran et erreurs de console, classe la cause en test, code ou environnement, applique la plus petite correction et relance jusqu’à réussite ou arrêt.
Créer un service d'agents de programmation qui reçoit des demandes du chat et du suivi des tickets
Pour un service d'agents de codage qui reçoit du travail de l'hébergement de code, des tickets et du chat. Sépare les rôles principal, relecteur et analyseur, garde un environnement isolé par fil, fixe l'ordre des intergiciels et rend activable la réparation automatique de CI.
Modifier une API Go et une SPA React en changeant d'abord la spécification OpenAPI
Pour un dépôt où un backend Go et une SPA React partagent une spécification OpenAPI. Modifie la spécification puis régénère le code sans retoucher le généré, suit des règles pour réglages, erreurs, sessions, téléchargements et mises à jour, et teste avant de rendre compte.
Créer ou modifier des composants dans une bibliothèque de composants d'UI à thèmes
À utiliser quand une IA ajoute ou modifie un composant dans une bibliothèque d'UI réutilisable. Elle repère les fichiers touchés, préserve les valeurs par défaut du thème, l'accessibilité et la mise en page de droite à gauche, et ajoute tests et documentation.
Transformer une idée logicielle en système multi-agents testé
Pour créer un système où plusieurs agents d’IA et outils travaillent ensemble. Pose une question à la fois, fait approuver la conception des rôles et des échanges, construit dans l’ordre des dépendances et rejoue 5 scénarios utilisateur jusqu’à ce qu’ils passent.
Modifiez un monorepo TypeScript full-stack et testez ses fonctionnalités LLM selon le sens
Pour une IA qui modifie un monorepo TypeScript avec fonctionnalités LLM. Elle lance les vérifications par paquet de la CI, teste le comportement, écarte les données personnelles des logs larges et juge les réponses du LLM sur le sens, pas les mots.
Créez une application TypeScript full-stack avec des schémas d’API partagés par le serveur et le client
Pour créer ou modifier une application TypeScript full-stack. L’IA définit une seule fois chaque requête et réponse d’API pour les routes et les hooks client, vérifie l’authentification avant de lire les entrées, garde cohérents dépendances, cache et styles, et écrit des tests rapides.
Modifiez un monorepo full-stack sans casser les paquets partagés
Pour une IA qui modifie un monorepo d’apps et de paquets partagés. Elle place chaque modification dans le bon module, recompile les bundles générés, sépare les données de chaque organisation et livre une pull request avec résultats de tests.
Modifier le code d’une base de données hautes performances sans perdre en vitesse ni en compatibilité
À utiliser quand une IA modifie une base de données rapide qui couvre Java, SQL, Rust, le code natif et la CI. Fixe des règles de style, de NULL, de libération mémoire, de tests de requêtes, d’échecs, de pull requests et de build, puis vérifie tout avant de déclarer le travail terminé.
Modifier une application de formation à la sécurité aux failles voulues sans casser ses défis
Pour modifier une application de formation dont les failles servent de leçons. L’IA distingue défis voulus et failles accidentelles, garde des changements courts, retire le superflu généré par IA, lance les tests requis et le filet de sécurité, et synchronise les fichiers de correction.
Modifier un moteur de bases de données analytiques en C++ et réussir ses tests
Pour modifier un moteur de bases de données analytiques en C++. L’IA suit le changement de l’analyse SQL à l’exécution, modifie les fichiers générés depuis leurs sources, respecte les règles C++ et d’erreurs, et ne termine qu’après les tests de logique SQL et les compilations nécessaires.
Corriger une anomalie en la reproduisant d’abord avec un test qui échoue
Pour une anomalie signalée. L’IA détermine quelle partie est en cause, reproduit ce que voit l’utilisateur dans un test qui échoue, trouve la vraie cause, applique le plus petit correctif, garde le test contre les régressions et refait le parcours de l’utilisateur pour vérifier.
Créer une bibliothèque qui lit et écrit des fichiers d'image en couches sans perte de données
Sert à créer une bibliothèque d'images en calques au format binaire. Elle sépare la lecture binaire de l'API utilisateur, lit les sections dans l'ordre, garde les données inconnues, refait les groupes de calques, teste en lisant, écrivant et relisant, et automatise la publication.
Rédiger et réviser une documentation de sécurité pour les développeurs
À utiliser pour rédiger ou réviser une documentation de sécurité pour les développeurs dans un dépôt partagé. Cite seulement des sources réellement lues, dit ce que chaque mesure empêche ou non, garde les changements petits, lance les vérifications du dépôt et déclare l’aide de l’IA.
Faire de petites modifications testées dans un grand monorepo TypeScript
À utiliser quand une IA modifie un espace de travail TypeScript à plusieurs paquets. Elle étudie d'abord le dépôt et ses outils, lance seulement les compilations et les tests concernés, ne change pas les fichiers générés sans raison et vérifie que tout fonctionne sous Unix et Windows.
Modifier un monodépôt à plusieurs implémentations sans qu’elles divergent
Pour un grand monodépôt multilingue où un produit a plusieurs implémentations. L’IA lit les règles locales, reporte partout les changements visibles, reconstruit ce qu’utilisent les tests, teste ce qui change, ajoute l’entrée de publication et actualise la demande de modification.
Modifier par petites touches une bibliothèque d'interface avec état sans casser ses utilisateurs
Quand une IA modifie une bibliothèque d'interface de navigateur avec état. Elle trouve le propriétaire de l'état, garde compatibles les API publiques et les données enregistrées, écrit d'abord un test qui échoue, choisit le type de test et relit les différences et la note de publication.
Créer un émulateur cloud local qui fonctionne avec les SDK et CLI officiels
Pour ajouter des services ou des opérations à un émulateur qui imite le cloud sur votre machine. Identifie d’abord le vrai protocole, garde requêtes et réponses comme dans le vrai cloud, met à jour ensemble stockage et configuration, et teste avec les SDK officiels avant la publication.
Créer un émulateur qui reproduit le bus et la temporisation du vrai matériel
À utiliser pour créer ou corriger un émulateur. Découpe le code par pièce du matériel, reproduit fidèlement bus, temporisation et DMA, teste avec des programmes validés sur machine réelle et garde stables les états sauvegardés et l’API publique.
Faire de petites modifications du code validées par des tests locaux et une revue
À utiliser quand une IA modifie votre code. Elle fixe d’abord ce qui va changer et comment le prouver, lance des tests locaux avant et après, fait relire les modifications actuelles, ne corrige que les vrais problèmes et termine par un rapport de transmission.
Modifier un monorepo d’automatisation multilingue sans casser la compatibilité
Quand une IA modifie un grand monorepo d’automatisation avec des liaisons en plusieurs langages. Elle garde les API publiques compatibles, compile et teste seulement la plus petite cible touchée, la compare avec une autre liaison et demande avant de toucher aux zones partagées risquées.
Garder le backend et le frontend d’une app de génération synchronisés via OpenAPI
Pour éditer une app où l’on extrait des éléments, les valide sur une page de préparation et génère dans un espace de génération. Régénère les types OpenAPI à chaque changement d’API, sépare les rôles des écrans et les types d’état, et tient à jour la documentation et les notes de version.
Modifier et tester du code dans un grand monorepo à nombreux paquets
Pour une IA qui travaille dans un grand dépôt de framework à plusieurs paquets. Elle repère la structure avant de modifier, garde la compilation à jour, teste selon le mode de CI, corrige d'abord les échecs de CI, garde les secrets hors des journaux et vérifie chaque modification.
Apporter de petites modifications à une bibliothèque de bas niveau sans casser son API publique
Quand une IA corrige ou modifie une bibliothèque système de bas niveau. Elle garde les changements petits, ne touche pas l’API ni l’ABI publiques sans demande, compile et teste le sous-système concerné, échoue proprement en cas d’erreur mémoire et ne pousse jamais.
Modifier une base de code à plusieurs paquets sans casser ce qui marche déjà
Pour une IA qui modifie un dépôt à plusieurs paquets. Elle identifie le paquet responsable et ses règles, garde le comportement et les noms publics, ajoute tests et documentation, demande l'approbation pour toute nouvelle dépendance et indique ce qui a été vérifié et les risques restants.
Écrire des règles d’analyse statique avec des corrections automatiques qui ne changent pas l’exécution du code
À utiliser pour créer une règle d’analyse statique (lint). Vise les cas courants, réutilise les helpers existants, ne propose une correction automatique que si elle est sûre, teste la syntaxe délicate et régénère la documentation au lieu de la retoucher.
Développer un framework de flux de données en Rust pour la robotique et l'IA en choisissant les tests selon le changement
À utiliser quand une IA travaille sur un framework de flux de données en Rust pour la robotique et l'IA. Elle garde les règles de messages claires, passe les contrôles avant chaque commit, choisit les tests poussés selon le risque et dit quels tests ont tourné.
Protéger le code serveur des attaques par fichiers envoyés et saisies utilisateur
À utiliser quand une IA modifie du code serveur qui traite des fichiers envoyés, des archives ou des données de requête. Elle suit les données externes, les valide avant usage, corrige les chemins de code similaires et termine par une checklist de sécurité, le lint et des tests réussis.
Développer une plateforme d’automatisation multilocataire sans mélanger locataires ni éditions
Pour coder une plateforme d’automatisation multilocataire avec éditions communautaire, entreprise et hébergée. Limite chaque requête à son projet, passe le HTTP sortant par le client sûr contre les SSRF, déclare chaque dépendance là où elle sert et teste chaque édition.
Créer et modifier des machines à états pilotées par les événements sans casser leur comportement
Pour une bibliothèque de machines à états, l’IA termine chaque événement avant le suivant, gère les erreurs sans sauter le nettoyage, protège threads et machines enfants, écrit d’abord des tests pour moteurs synchrones et asynchrones et aligne code, doc et schémas.
Modifier le code d’un grand dépôt à plusieurs langages en ne compilant et testant que le nécessaire
Pour modifier le code d’un grand dépôt qui mêle plusieurs langages. L’IA étudie du code similaire, vérifie les outils et le matériel disponibles, ne lance que les builds et tests concernés, rétablit la CI complète avant la fusion et signale ce qui n’a pas été vérifié.
Modifier une CLI de développement web faite de JavaScript et de code natif dans la bonne couche
À utiliser pour modifier une CLI de développement web qui mêle JavaScript et code natif. Trouve la couche responsable du comportement, vérifie les chemins de commande global et local, et choisit les tests selon le type de modification.
Construire un système qui lit les documents envoyés et permet aux agents d’IA d’y chercher
Pour créer un service qui reçoit des PDF et autres fichiers pour la recherche par IA. Envoie chaque fichier vers un analyseur adapté, garde titres et tableaux, enregistre les fragments dans un format fixe et cherche dans un budget donné, avec des preuves citées.
Développer un logiciel de récupération hors ligne qui divise un secret en fragments
Pour un logiciel qui répartit un secret entre des personnes de confiance et le récupère hors ligne. Il suit chaque modification, partage le chiffrement entre CLI et navigateur, garde les paquets hors ligne, teste d'abord et écrit des textes calmes et clairs pour des gens sous pression.
Développer un framework qui offre une seule API dans plusieurs langages de programmation
Pour un framework qui génère des paquets pour plusieurs langages à partir d’un seul code. Fixe les règles du protocole JSON entre processus, des types exportables, de la génération de code et des tests qui vérifient le même comportement dans chaque langage.
Créer un agent IA qui enquête avec des outils et vérifier qu’il ne devine pas
Pour un agent IA qui enquête via des outils. Les outils sont en lecture seule par défaut, renvoient des données limitées et expliquent leurs échecs ; les anciens noms de configuration restent valides et les tests exigent des faits qu’on ne trouve qu’en interrogeant.
Préparer des contributions de code qu'une personne relit et soumet
À utiliser quand une IA travaille sur un dépôt de code partagé. Elle suit les règles du projet, attend l'accord des responsables, garde les secrets hors des commits et des tests, et rédige les demandes de fusion en brouillon pour qu'une personne les envoie.
Ajouter des fournisseurs d’IA et des bases vectorielles à un framework d’IA modulaire en Rust
Pour étendre un framework Rust compatible avec de nombreux fournisseurs d’IA. L’IA suit les traits et builders existants, garde le support WebAssembly, fait agir les hooks pareil avec ou sans streaming et vérifie que les cassettes n’ont pas de clés d’API.
Ajouter un outil CLI à un téléchargeur multiplateforme et vérifier chaque binaire
À utiliser pour ajouter ou examiner un outil CLI dans un installateur qui télécharge des binaires publiés. Il relève les fichiers par système et architecture, associe les URL, teste avec une version fixe, inspecte chaque binaire et met à jour le catalogue et la PR.
Modifier une boîte à outils d’UI en console selon sa doc actuelle et vérifier l’écran réel
Pour une boîte à outils d’UI en console après une grosse réécriture : l’IA suit la doc actuelle du dépôt plutôt que de vieilles habitudes, place bien les tests et enregistre le terminal en marche pour vérifier les changements d’UI.
Modifier une grande base de code .NET en la gardant rapide et compatible
Pour éditer un grand dépôt .NET exigeant en performances, tel un moteur de compilation. Évite les allocations en trop dans les chemins critiques, traite tout nouvel avertissement comme incompatible, compile d’abord le plus petit projet et liste les compilations, tests et exemples lancés.
Modifiez un espace de travail Rust de bibliothèques et de CLI en le comparant à l’outil de référence
Pour une IA qui modifie un espace de travail Rust de bibliothèques et d’outils CLI. Elle commence par un test qui échoue, compare les résultats à l’outil de référence, évite unwrap() et teste chaque combinaison de fonctionnalités.
Développer un cadre d’automatisation mobile et corriger les bugs dans le produit, pas en CI
Pour développer avec une IA un cadre d’automatisation d’interfaces mobiles. Place chaque changement dans son module, choisit le niveau de test le moins coûteux, sépare les suites à réussir de celles à échouer et corrige les bugs dans le produit, pas dans la CI.
Créer un outil local de graphe de code que les agents IA peuvent interroger
Pour un outil qui transforme une base de code en graphe local pour agents IA. Couvre l’extraction des symboles et des liens de l’arbre syntaxique, l’installation et la désinstallation dans plusieurs clients, des réponses utiles aux agents, les tests sur de vrais dépôts et la publication.
Développer un gestionnaire de chaîne d’outils multiplateforme et contrôler les ajouts à son registre
Pour un agent IA qui travaille sur un gestionnaire de versions d’outils de développement. Il suit les tâches et les modules du dépôt, exige des preuves de popularité avant d’ajouter un outil au registre, laisse l’ordre des versions à chaque backend et lance des tests ciblés par plateforme.
Modifier un dépôt multimodule avec du code généré sans dépasser ce qui est autorisé
Quand une IA travaille dans un dépôt multimodule avec du code généré. Lit d’abord les règles locales, modifie la spécification plutôt que les fichiers générés, fait de petits changements compatibles testés par module et laisse versions et pipelines aux personnes autorisées.
Modifier et tester un grand dépôt TypeScript qui évalue des modèles d'IA
Quand un agent IA travaille dans un grand dépôt TypeScript avec CLI, web et évaluation de modèles d'IA. Il lit les règles locales, teste dans la vraie CLI ou le navigateur, débogue sans vider caches ni données, intègre par branches et CI, et examine d'abord la sécurité.
Modifier un monorepo typé sans le casser et garder son wiki à jour
À utiliser quand une IA travaille dans un grand monorepo typé doté d’un wiki de projet. Elle suit les commandes du dépôt, évite les anciens fichiers de build et les problèmes de snapshots de démarrage, lance les bons tests et met à jour le wiki en citant les fichiers sources.
Modifiez un proxy inverse Rust sans casser la boucle d’événements ni la sécurité
Quand une IA modifie, teste ou publie un proxy Rust multiprocessus. Fixe des règles pour la compilation et les feature flags, erreurs et journaux, boucle d’événements et protocole, tests et fuzzing, code sensible pour la sécurité, pull requests et publication.
Modifiez un grand monorepo de plateforme en gardant tous les clients concernés synchronisés
Pour une IA qui modifie un monorepo avec CLI, bibliothèques clientes et docs. Elle lit d’abord les règles de chaque zone, régénère les fichiers depuis leurs sources, demande avant tout changement incompatible et indique les vérifications lancées.
Envoyer des demandes de fusion écrites par l’IA à un framework open source avec relecture humaine
À utiliser quand une IA contribue à un framework Java open source. Signale le travail de l’IA, lit l’historique avant de corriger, retire les délais fixes des tests, suit le modèle de confiance du projet et ne fusionne qu’après accord humain.
Ajouter des fournisseurs et des modèles d’IA à un catalogue validé par schémas
Quand une IA complète ou relit un catalogue de fournisseurs et de modèles d’IA. Elle lance le validateur du référentiel, hérite des données communes au lieu de les copier, n’inscrit que des réglages de raisonnement et des prix vérifiés et garde les sources après synchronisation.
Modifier un grand dépôt de code natif aux compilations lentes sans casser les appels entre langages
À utiliser pour modifier un grand dépôt mêlant langages natifs, liaisons générées et compilations lentes. Adapte la démarche à la taille du changement, commence par le plus petit test, enregistre une fois les longs journaux et protège les appels entre langages.
Créer un extracteur du contenu principal des pages web et retrouver le contenu perdu
Pour créer ou corriger un extracteur du texte principal des pages web en navigateur, serveur, CLI ou edge. L’IA respecte l’ordre du nettoyage, journalise chaque suppression, bloque l’injection de scripts et prouve chaque correction par un test qui échoue d’abord.
Modifier une bibliothèque Go publique sans casser le code de ses utilisateurs
Pour modifier une bibliothèque Go publique. L’IA vérifie d’abord les versions de Go prises en charge et les branches, teste avec les outils du projet, suit les modèles d’API existants et rédige une demande de fusion avec les résultats des tests et l’impact sur la compatibilité.
Créer une CLI locale qui cherche vos documents par mot-clé et par sens
Pour créer ou maintenir un outil en ligne de commande qui cherche des documents sur votre ordinateur. Couvre collections et notes de contexte, recherche par mot-clé et vectorielle, limites de résultats, mode service, tests et publication ; les changements d’index restent à l’utilisateur.
Créer des compétences d’agent à partir de la documentation d’un projet et les tenir à jour
Pour tirer des compétences d’agent IA de la documentation d’un projet ou de celles de l’amont. Sépare les compétences générées, synchronisées et écrites à la main, rédige un index court et des références d’un seul sujet, et ne met à jour que ce qui a changé depuis la révision notée.
Créer une bibliothèque de données aux API faciles à trouver, testée sur des valeurs réelles
Pour créer ou modifier une bibliothèque qui transforme des données complexes en objets simples. L’IA lit d’abord le code, suit le travail en tickets et exige pour chaque nouvelle fonction un test sur des valeurs réelles, un exemple documenté exécutable et des erreurs claires.
Modifier le code d'un dépôt à plusieurs paquets et n'ouvrir de PR que depuis son fork
À utiliser quand une IA modifie un dépôt multipaquet à upstream en lecture seule. Suit les consignes par dossier, ne pousse que vers votre fork, garde vos changements non commités, marque l'auteur des tests Python et rend compte à partir de contrôles réellement exécutés.
Créer une mémoire à long terme pour agents d’IA avec recherche par graphe et par vecteurs
À utiliser pour que les agents d’IA gardent leurs connaissances entre sessions. Transforme fichiers, URL et texte en graphes et vecteurs consultables, sépare les données de chaque utilisateur par l’authentification et permet de changer de stockage ou de modèle sans toucher au code central.
Modifier un service d’autorisation fondé sur des graphes en écrivant d’abord les tests
À utiliser pour modifier un service d’autorisation fondé sur des graphes. Suit le trajet de chaque requête, utilise les cibles de build et les règles de lint du dépôt, écrit d’abord un test qui échoue et ne retouche pas les fichiers générés.
Modifier un framework web à typage sûr et séparer le code de base de données en trois couches
À utiliser pour modifier un framework web à typage sûr en plusieurs paquets. Travaille dans l’environnement figé, teste vite puis en entier, garde les modules publics réduits, sépare en couches l’accès à la base de données et ne fait jamais de force-push.
Garder les documents de compétences d’IA en un seul endroit et les écrire pour que l’IA les consulte
Pour maintenir des documents de compétences d’IA. Garde un seul fichier source et en régénère les copies, met les tables de décision en tête et les détails en références, teste le comportement avant et après les changements et laisse la version à la publication automatique.
Étendre un compilateur SQL multidialecte sans changer le sens des requêtes
Pour modifier un compilateur SQL qui transforme le SQL en AST puis le régénère pour d'autres bases. Il trouve d'abord la bonne couche, garde le sens entre dialectes, construit le SQL avec les outils de l'AST plutôt qu'avec des chaînes et teste l'exécution réelle et la vitesse.
Écrire et publier des compétences d’agent qui se déclenchent bien et passent la validation
Pour un dépôt de compétences d’agent : l’IA limite les descriptions à ce que fait la compétence et quand l’utiliser, garde le fichier principal court avec des fichiers de référence ciblés, synchronise versions et documentation et lance les validateurs avant de publier.
Lancer un outil CLI complexe depuis des scripts et vérifier la réussite dans son rapport JSON
À utiliser quand un script ou un agent de code lance une CLI complexe. Vérifie d’abord tâches et classes, s’arrête sans licence pour une tâche qui l’exige, fixe entrées et périphérique, et juge la réussite au code de sortie et au rapport JSON, pas à la progression.
Ajouter des extensions de fichier ou de nouveaux langages à un dépôt de détection des langages
Pour ajouter avec une IA des extensions ou des langages à un détecteur de langages. L'IA ajoute de vrais échantillons et des règles testées pour les extensions partagées, génère les fichiers par les scripts du dépôt et vérifie l'usage et les licences avant l'envoi.
Modifier un générateur de documents à agents IA sans confondre sa pile actuelle et l’ancienne
À utiliser quand une IA modifie une app multi-agents qui crée des documents et garde une ancienne pile. Elle trouve la vraie commande de démarrage, croit le code, pas la doc périmée, garde les noms de réglages, suit les changements entre Python et Node et lance des tests minimaux utiles.
Ajouter des modules à un service réseau modulaire sans briser ses frontières
À utiliser quand une IA modifie ou étend un service réseau fait de modules. Elle relie les modules par des interfaces partagées, compile et teste avec les outils du dépôt, renvoie des erreurs sûres pour le client et ne partage aucun état entre requêtes.
Modifier un monorepo auto-hébergé d’automatisation des certificats sans exposer de secrets
À utiliser quand une IA modifie un outil qui demande, renouvelle et déploie des certificats via ACME. Elle vise le bon paquet ou plugin, écrit les tests d’abord, ajoute des migrations SQL, suit les modèles d’UI et garde certificats et clés hors du code et des journaux.
Corriger et tester un générateur d’adaptateurs de bibliothèques natives pour de nombreux langages
À utiliser pour modifier un outil qui génère des adaptateurs de bibliothèques natives pour de nombreux langages. Remonte à l’étape où naît le bug, lance des tests à la bonne échelle, ajoute des tests de régression et met à jour le journal des modifications.
Créer un dépôt de compétences d’agents d’IA qui évaluent la qualité des sites web
Pour ajouter ou modifier des compétences qui évaluent vitesse, accessibilité et SEO des sites. Fixe le format et les noms de SKILL.md, des fichiers courts, des exemples avant/après, des scripts shell qui s’arrêtent sur erreur et un classement des problèmes par impact sur l’utilisateur.
Modifier un dépôt full-stack avec ses propres commandes et tests
À utiliser quand une IA modifie un dépôt avec frontend, API, SDK, CLI et base de données. Elle suit les commandes et versions figées du dépôt, sépare le rôle de chaque couche, teste dans la bonne couche, vérifie les pages modifiées et les API avec connexion et cite les preuves.
Développez des fonctionnalités à partir de spécifications approuvées avant de coder
Quand une IA code par étapes à partir de spécifications. Sépare les consignes du projet de chaque spécification, rédige exigences, conception et tâches dans l’ordre avec accord humain, demande une revue indépendante et confirme la fin avec des preuves récentes.
Écrire des règles dans un dépôt de règles frontend et les vérifier avant publication
Pour une IA qui modifie un dépôt de règles frontend (accessibilité, performance, SEO, sécurité). Fixe les métadonnées des règles, l’ordre des sections et des seuils mesurables, garde l’interface partagée dans le design system et lance toutes les vérifications avant de publier.
Amener un agent de codage IA à livrer du code sans avertissement et des comptes rendus honnêtes dans un dépôt au build strict
À utiliser quand un agent de codage IA travaille dans un dépôt aux contrôles de build stricts. Il compile et valide avant chaque push, suit les règles de commit, écrit du code sûr et vérifie chaque affirmation dans le code.
Corriger la cause profonde dans une grande base de code et garder l’API publique compatible
À utiliser quand une IA modifie une grande base de code en couches. Garde les journaux de build courts, remonte chaque bug jusqu’à sa cause en amont, relit son diff pour repérer les helpers qui masquent un problème et rédige une pull request claire.
Garder une grande base de code modulaire lisible et modifiable sans rien casser
À utiliser quand une IA travaille sur une grande base de code à nombreux composants. Donne des règles sur le style de code, la taille des fichiers et des changements, la revue de code, les tests, les noms d'API et les builds, pour des changements petits, lisibles et sans casse ailleurs.
Limiter une IA au code nécessaire et lui faire demander avant les actions risquées
Pour quand une IA modifie le code de votre projet. Elle fixe d'abord le périmètre, n'ajoute que du code utile et des tests qui trouvent de vrais bugs, demande avant de supprimer des fichiers, pousser ou appeler des API de production, puis liste les fichiers modifiés et les vérifications.
Faire des changements testés et prêts à relire dans une grande base de code
À utiliser quand un agent IA modifie une grande base de code multi-langage. Il compile via le wrapper du projet, place les tests près du code et vérifie qu'ils échouent sans le changement, suit les règles de relecture et ne rapporte que ce qu'il a exécuté.
Ne faire que les changements demandés dans un dépôt existant et demander en cas de doute
Pour un agent IA qui modifie du code existant. Il demande en cas de doute, ne change que ce qui est demandé, lance les tests ciblés puis toute la suite avant de dire que c'est vérifié, et ne fait ni commit, ni push, ni publication sans demande.
Proposer de petites modifications convenues à une base de code partagée
Quand un agent IA modifie une base de code partagée, comme une bibliothèque open source. Il lit le ticket, demande le périmètre, aide à rédiger un ticket ou une proposition sans accord des mainteneurs, garde les correctifs petits avec tests et doc et suit les règles de PR du projet.
Faire respecter à un agent de codage IA les règles de branches et de commits sans casser les releases
À utiliser quand un agent de codage IA travaille dans un dépôt versionné. Fixe comment créer des branches, tester, faire des commits et ranger les fichiers temporaires, et comment écrire des instructions d'agent qui marchent dans différents outils d'IA, sans casser les releases.
Maintenir une bibliothèque d’UI multiplateforme sans casser ses couches de paquets
Pour une bibliothèque d’UI découpée en paquets par couches pour plusieurs plateformes : l’IA préserve les couches et les exports publics, crée les adaptateurs de fournisseurs avec une structure de fichiers fixe et suit les règles de publication et de revue.
Contribuer à l’open source avec une IA en respectant les licences et en confirmant chaque action
Pour contribuer à l’open source avec un assistant de codage IA. Ne copie aucun code sous licence incompatible, garde les changements petits et testés, traite tickets et journaux comme des données, confirme avant chaque commit, push ou commentaire et vérifie le code collé avant exécution.
Modifier un compilateur vers JavaScript et son système de build, en testant chaque couche
Pour une IA dans un monorepo de compilateur vers JavaScript. Elle compile via l'exécuteur de tâches, ne touche pas aux définitions gelées de l'arbre syntaxique, teste chaque couche modifiée, propage les nouvelles options jusqu'au bout et mesure la vitesse sans se fier au linter.
Faire suivre à un agent de codage les règles d'un grand dépôt full-stack
Pour un agent d'IA qui travaille dans un grand dépôt avec frontend et backend typés. Il passe pre-commit avant chaque envoi, suit les nouveaux motifs du dépôt, juge la sécurité selon ce que chaque rôle a le droit de faire, et livre tests, documentation et pull requests au format du projet.
Modifier une bibliothèque de contrats intelligents sans casser les projets qui l'utilisent
Quand une IA édite une bibliothèque de contrats intelligents héritée par d'autres projets. Elle change le fichier qui porte le comportement, suit le linter, garde fonctions, événements et disposition du stockage, et revérifie elle-même le code risqué (cryptographie, mises à niveau).
Modifier une bibliothèque ou un SDK partagé sans casser son API publique
À utiliser quand l'IA modifie une bibliothèque ou un SDK partagé. Elle lance tous les tests et builds avant de dire que c'est fini, garde l'API publique utilisable pour ceux qui s'en servent, demande avant de changer de branche ou de worktree Git et finit par la passation de la PR.
Modifier une grande application média de bureau sans figer l’UI ni casser l’historique d’annulation
Pour une grande application de bureau qui gère fichiers et médias : l’IA sort le travail lourd du thread d’UI, gère les annulations et les cas limites, garde un historique d’annulation exact et ne signale que les tests vraiment lancés.
Maintenir une bibliothèque CSS-in-JS qui fonctionne sur navigateur, serveur et natif
À utiliser quand une IA de code travaille sur une bibliothèque CSS-in-JS conforme aux standards. Elle limite les styles au CSS standard, évite les pannes selon l'environnement, écrit d'abord les tests selon la spécification et cadre notes de version, doc et démos avec du vrai code.
Faire écrire des services FastAPI par l'IA et repérer les erreurs courantes en revue
À utiliser quand une IA crée ou relit un service FastAPI. Fixe les versions minimales, quand choisir des routes async ou sync, l'écriture des modèles Pydantic et des dépendances, la base de données et les tests, et donne un tableau des erreurs courantes dans un diff avec leur correction.
Travailler dans un monorepo frontend TypeScript sans franchir les limites entre paquets
Pour une IA qui modifie un frontend TypeScript modulaire. Couvre les limites entre paquets et un cœur sans framework, l'état modifié seulement via son action propriétaire, où ranger fichiers et tests, les contrôles avant commit, l'ordre de release et les couches d'UI.
Faire lire le code à l'IA avant de modifier un grand dépôt et ne livrer qu'après revue
Pour une IA qui travaille dans un grand dépôt à nombreux paquets. Elle lit le code, les dépendances et les tests avant de juger une correction, garde une seule façon de faire, n'exécute jamais de code non fiable en local et ne modifie le code partagé qu'après revue et votre accord.
Fixer des règles de travail communes pour les agents IA qui étudient et améliorent un dépôt
Pour des agents IA qui étudient et améliorent un dépôt par eux-mêmes. Fixe ce qu'il faut garder dans la mémoire partagée, quand proposer un plan avant d'agir, comment gérer les push et les secrets exposés, et comment tester changements et automatisation avant de les déclarer terminés.
Modifier un pipeline de données à plugins sur deux runtimes sans le casser
Pour un agent de codage dans un backend à plugins sur deux runtimes. Il garde les versions dans un fichier, applique les filtres de test à la bonne tâche, suit les règles de plugins, de concurrence et de couches de service, et vérifie que chaque nouveau test échoue sans sa modification.
Modifier un débogueur bas niveau en écrivant d'abord les tests, sans casser les autres plateformes
Quand une IA modifie un débogueur de langage compilé qui tourne sur plusieurs systèmes et backends. Elle écrit d'abord un test qui échoue, isole le code propre à chaque OS, vérifie tous les backends en changeant une interface partagée et commence les commits par le sous-système.
Faire écrire du code système avec soin par l’IA, jusqu’aux types et à la gestion des erreurs
Quand une IA aide sur du code système exigeant. Elle relit son code au moins trois fois plus longtemps que l’écriture, couvre tous les cas d’erreur, met les règles dans les types, garde compatibles anciens et nouveaux formats et fait de petits commits qui compilent.
Créer des compétences et plugins d’agent qui se chargent et se déclenchent correctement
À utiliser pour créer une compétence ou un plugin pour un agent d’IA et le soumettre à la revue. Couvre une source de métadonnées unique, l’arborescence, des noms et descriptions qui se déclenchent bien, des hooks rapides et la liste de contrôle.
Vérifier qu'une modification est vraiment utile avant d'ouvrir une pull request sur un projet partagé
Pour un agent IA qui veut envoyer une pull request à un projet maintenu par d'autres. Il vérifie que le problème a vraiment eu lieu, que la modification a sa place dans le cœur du projet et qu'une personne a validé le diff complet avant l'envoi.
Garder un agent de codage IA dans les limites de la demande dans un dépôt d'application en couches
À utiliser quand une IA code dans un dépôt avec frontend, backend et empaquetage bureau. Classe chaque demande (réponse, modification, build, publication), choisit les tests selon la partie modifiée et fait demander l'accord avant commit, push, release ou données réelles.
Modifier une base de code fonctionnelle strictement typée sans masquer les erreurs
À utiliser quand un agent IA travaille dans du code fonctionnel strictement typé. Fixe les règles de style, d'erreurs, de services, de schémas, de journaux et de composants d'UI, et exige que la vérification des types, les tests et le build passent avant de dire que c'est fini.
Créer un outil en ligne de commande qui ne perd pas de données et n’exécute pas de code non approuvé
Quand une IA crée ou modifie un CLI qui a déjà des utilisateurs. Elle garde options et configuration compatibles, s’arrête plutôt que de détruire du travail, n’exécute les hooks du projet qu’après approbation, trace chaque sous-processus et affiche les résultats locaux avant le réseau.
Modifier une grande base de code de runtime multi-langage sans casser le comportement existant
Pour un grand runtime natif et de scripts aux dépendances embarquées et patchées. L'IA lit d'abord le guide le plus proche, utilise les raccourcis de build et de test, suit ses types et ses interdits, et place les changements derrière des indicateurs de compatibilité.
Développer une extension d'index de base de données qui passe les tests et résiste aux crashs
À utiliser quand une IA crée ou modifie une extension d'index de base de données. Elle traite chaque échec de test comme réel, suit un ordre fixe avant le commit et journalise chaque changement de page pour que la reprise et les instances de secours fonctionnent.
Maintenir un SDK de protocole bidirectionnel dans un monorepo TypeScript sans casser son API publique
Pour modifier un SDK typé, publié en plusieurs paquets, où client et serveur envoient des requêtes. Choisit avec soin ce qui est exporté, ajoute les opérations des deux côtés avec contrôle des capacités, consigne les changements incompatibles et exécute les exemples comme tests.
Faire tourner en bac à sable un pipeline d'IA qui trouve et corrige des failles de sécurité
À utiliser pour piloter un pipeline autonome qui exécute du code non fiable afin de trouver de vrais plantages. Il isole chaque exécution dans des conteneurs, signale les résultats dès qu'ils arrivent et laisse chaque correctif à la revue humaine.
Ajouter du code backend et les bons tests à une application multiservices
Pour un agent IA qui modifie une application à plusieurs services avec des travailleurs d'arrière-plan. Il vérifie l'environnement et les services, range le code de base de données et de tâches, définit tâches et erreurs selon le projet, choisit un type de test et planifie avant de coder.
Ajouter des plugins de fournisseurs et de générateurs à un dépôt multi-module
À utiliser quand une IA travaille dans un dépôt multi-module étendu par des fournisseurs et générateurs de secrets. Elle passe par le lanceur de tâches, ajoute les extensions de la façon prévue et s'arrête avant tout push ou publication.
Modifier une application de bureau de design IA à priorité locale en respectant ses règles fixes
Pour un agent IA qui code une app de bureau de design par IA, en espaces de travail locaux. Précise quel fichier d'instructions prime, les règles fixes, l'organisation des sessions, du stockage et des outils, les quatre niveaux de permission et ce qu'il faut éviter.
Faire respecter à l'IA le style et les règles de modules d'un grand backend Java
Pour une IA dans un grand serveur Java de modules et de fournisseurs. Elle lit d'abord les points d'entrée, suit le style vérifié à la compilation et la version minimale de Java, déclare chaque module utilisé, vérifie dans le code avant d'affirmer et teste en local avant de pousser.
Créer une appli qui rassemble des événements d'activité de nombreuses sources et les affiche sur plusieurs surfaces
Pour une appli qui rassemble les événements de nombreux outils et les affiche dans une extension d'éditeur et un serveur autonome. Garde les couches dans un seul sens, ramène chaque source à un type d'événement, ajoute des sources sans rien toucher d'autre et enregistre l'état sans risque.