Communitygithub.com

replay-to-replica

Transformer l'observation autorisée d'une application, d'un site web, d'un flux de travail ou d'une démonstration utilisateur en un cahier des charges comportemental lié aux preuves, un dossier de transfert d'implémentation indépendant, des scénarios d'acceptation exécutables et un rapport de parité.

Qu'est-ce que replay-to-replica ?

Cette compétence permet de capturer le comportement observable d'un produit existant (site, app, flux de travail) à partir d'une observation autorisée, puis de formaliser ce comportement dans un contrat indépendant qui peut être implémenté sans copier le code source, les marques ou les actifs protégés. Elle est utile pour les ingénieurs et les équipes produit qui ont besoin de reproduire un comportement fonctionnel sans violer les droits de propriété intellectuelle ou les conditions d'utilisation. La compétence prend en charge les flux de travail automatisés via des scripts Python (init_replica_pack.py, compare_traces.py) et peut être utilisée avec n'importe quel agent d'IA ou plateforme de développement. Son fonctionnement se déroule en six phases : définition du périmètre et autorisation, observation utilisateur, normalisation en contrat comportemental, transfert d'implémentation, implémentation indépendante, rejeu et comparaison. Elle produit des livrables comme un cahier des comportements, un modèle d'état, des scénarios d'acceptation et un rapport de parité, avec une classification claire de chaque scénario (correspondance, différence acceptable, non-concordance, non vérifié).

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/wangjunyu86/replay-to-replica/tree/HEAD

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Replay to Replica

Traduire le comportement observé d'un produit en un contrat implémentable et exprimé de manière indépendante, puis vérifier la nouvelle implémentation en rejouant les mêmes tâches utilisateur. Optimiser pour la clarté comportementale, non pour l'imitation visuelle ou de code.

Périmètre

Cette compétence prend en charge l'observation "boîte noire" autorisée et le transfert de type "salle blanche". Elle n'établit pas elle-même la conformité légale. Respectez les licences, conditions, brevets, vie privée et restrictions contractuelles. Ne pas :

  • contourner l'authentification, le paiement, les limites de débit, le chiffrement ou les contrôles techniques ;
  • accéder à des données ou fonctionnalités que l'utilisateur n'est pas autorisé à consulter ;
  • copier le code source, le code décompilé, les actifs propriétaires, les marques, les textes commerciaux, les identifiants cachés ou les données confidentielles dans le dossier d'implémentation ;
  • revendiquer une séparation stricte de type "salle blanche" lorsque la même personne ou le même agent a vu des détails d'implémentation protégés.

Si une séparation stricte est nécessaire, divisez le travail : un rôle d'observation produit un dossier de comportement normalisé, et un rôle d'implémentation séparé reçoit uniquement ce dossier.

Choisir le résultat demandé

Précisez le résultat souhaité :

  • Dossier de comportement uniquement — spécifications et scénarios d'acceptation.
  • Transfert d'implémentation — dossier de comportement plus tâches et interfaces prêtes pour la construction.
  • Réplique vérifiée — implémentation indépendante plus tests de parité rejoués.

N'étendez pas "analyser ce produit" en construisant un clone sauf si l'utilisateur a demandé une implémentation.

Initialisez un dossier de travail avec :

python3 scripts/init_replica_pack.py <répertoire-de-sortie> --product "<produit observé>" --replica "<nouveau produit>"

Phase 1 : Définir le périmètre et l'autorisation

Enregistrez :

  • la cible autorisée et la méthode d'accès ;
  • le produit indépendant prévu et son utilisateur ;
  • les comportements à conserver ;
  • les comportements, marques, données et actifs à exclure ;
  • la plateforme et l'environnement de test pris en charge ;
  • si l'interaction en temps réel ou les actions sur le compte nécessitent un nouveau consentement ;
  • le seuil de parité : contrat exact, fonctionnellement équivalent, ou modifié intentionnellement.

Créez un périmètre basé sur des tâches plutôt que "copier toute l'application". Commencez par les parcours les plus petits et les plus importants.

Phase 2 : Observer en tant qu'utilisateur

Pour chaque parcours, capturez :

  1. l'état de départ et les prérequis ;
  2. l'action utilisateur ;
  3. la réponse immédiatement observable ;
  4. l'état résultant et les données persistées ;
  5. les erreurs, délais, limites et chemins de récupération ;
  6. le chemin de preuve et l'environnement ;
  7. l'étiquette épistémique : observed, derived ou inferred.

Réinitialisez la cible entre les exécutions lorsque l'état pourrait affecter le comportement. Répétez le comportement variable ou sensible au timing suffisamment de fois pour identifier des plages plutôt que de traiter un échantillon comme une règle.

Les preuves d'observation peuvent inclure des enregistrements, des captures d'écran, des arbres d'accessibilité, le comportement réseau public, les fichiers exportés, les journaux visibles par l'utilisateur et les API documentées. Utilisez les outils d'inspection disponibles uniquement dans le cadre de l'autorisation. Les détails d'implémentation interne ne sont pas nécessaires pour un contrat comportemental.

Lisez references/observation-and-spec.md lors de la rédaction du dossier de comportement.

Phase 3 : Normaliser en un contrat comportemental

Décrivez le comportement indépendamment de l'interface et du libellé d'origine. Le contrat doit définir :

  • les acteurs et autorisations ;
  • les entités, identifiants et relations ;
  • les états et transitions valides ;
  • les actions, entrées, sorties, effets de bord et invariants ;
  • la validation et le comportement en cas d'échec ;
  • les règles de persistance, ordonnancement, timing et concurrence là où elles sont visibles ;
  • les limites d'intégration externes ;
  • les attentes en matière d'accessibilité et de plateforme ;
  • les différences intentionnelles.

Chaque règle non triviale nécessite une référence de preuve ou une étiquette d'inférence explicite. Les observations contradictoires restent non résolues jusqu'à ce qu'elles soient testées ; ne choisissez pas silencieusement l'interprétation la plus commode.

Phase 4 : Produire un dossier de transfert d'implémentation propre

Le dossier de transfert d'implémentation peut inclure :

behavior-spec.yaml
state-model.md
data-contracts.md
acceptance-scenarios.md
implementation-handoff.md
source-observations.csv

Réécrivez les noms, le texte, l'identité visuelle et les exemples de domaine pour le nouveau produit. Excluez les actifs d'origine et les identifiants internes. Spécifiez les interfaces et les résultats, non l'architecture source présumée.

Lisez references/clean-room-handoff.md avant de remettre le dossier à un agent d'implémentation.

Phase 5 : Implémenter indépendamment

Choisissez la technologie à partir des contraintes du nouveau produit, pas à partir de suppositions sur la pile d'origine. Préservez les contrats comportementaux tout en permettant une architecture, des algorithmes, une conception visuelle et des structures de données différents.

Tenez un journal des décisions d'implémentation pour les différences intentionnelles. Ne modifiez pas la spécification comportementale simplement pour faire passer une implémentation défaillante comme conforme ; mettez à jour la spécification uniquement lorsqu'une nouvelle observation la contredit ou que l'utilisateur approuve une modification du produit.

Phase 6 : Rejouer et comparer

Transformez les scénarios d'acceptation en tests exécutables dans la mesure du possible. Exécutez les mêmes actions normalisées contre l'original et la réplique, puis comparez les résultats observables par l'utilisateur.

Classez chaque scénario :

  • match — toutes les observables requises concordent dans la tolérance déclarée ;
  • acceptable-difference — diffère intentionnellement et est approuvé/documenté ;
  • mismatch — contredit le contrat comportemental ;
  • unverified — un côté n'a pas pu être exercé ou les preuves sont insuffisantes.

Pour les traces d'événements structurées, utilisez :

python3 scripts/compare_traces.py original.json replica.json --output parity-report.md

Lisez references/parity-testing.md lors de la conception de la normalisation, des tolérances ou des portes de mise en production.

Porte d'achèvement

Ne considérez pas la réplique comme achevée à moins que :

  • chaque scénario bloquant pour la mise en production soit match ou une acceptable-difference approuvée ;
  • les règles inférées non résolues soient divulguées ;
  • le nouveau produit ne contienne aucun actif protégé ni identité copiés ;
  • un utilisateur puisse exécuter le parcours principal dans l'environnement prévu ;
  • le rapport de parité fasse référence à des preuves consultables.

Un rapport final doit indiquer le périmètre, la frontière d'autorisation, la couverture observée, les inférences, les différences intentionnelles, les non-concordances, les zones non vérifiées et l'artefact d'implémentation exact testé.

Skills associés