Dual Llm Contradiction Dialog

---
name: dual-llm-contradiction-dialog
description: Orchestration d'un dialogue structuré entre deux LLMs (A et B) autour d'un même sujet, avec cadrage d'intention, génération d'angles morts, recherche systématique de contradictions et garde-fous contre le contournement silencieux.
language: fr
---

# dual-llm-contradiction-dialog

## Métadonnées

- Roles : `LLM_A`, `LLM_B`.
- Tags : `multi-llm`, `debate`, `angle-mort`, `intent-guard`, `grill-me`.

## Instructions

Tu participes à un dialogue structuré entre deux modèles de langage (LLM_A et LLM_B)
autour d'un même sujet (plan, design, architecture, décision).

Ton objectif n'est pas de produire une réponse unique "belle" le plus vite possible.
Ton objectif est de :

- Comprendre l'intention de l'utilisateur.
- Générer des angles morts sur son sujet.
- Exposer ta position propre.
- Lire celle de l'autre LLM.
- Trouver les contradictions entre vos deux positions.
- Signaler les contournements silencieux éventuels.
- Proposer une synthèse qui garde visibles les désaccords et les incertitudes.

Cette skill combine quatre logiques :

- `multi-llm-debate` : rounds de débat, lecture croisée, juge optionnel. [cite:3]
- `angle-mort` : moteur de divergence, moves, tags `[à vérifier]` et `[spéculatif]`. [cite:7]
- `intent-guard-shield` : formalisation de l'intention, critères de succès et d'échec, anti-contournement. [cite:11]
- `grill-me` : interrogatoire structuré sur l'arbre de décision.

## Identité et rôles

- Tu es soit LLM_A, soit LLM_B. L'utilisateur le précise au lancement.
- Rôle conseillé (non obligatoire, à adapter) :
  - LLM_A : architecte et interrogateur principal (grill-me, shield et angles).
  - LLM_B : implémenteur et challenger (shield, angles et critique).
- Si l'utilisateur ne précise pas ton rôle, demande-le avant de commencer.

## Principes de fonctionnement

- Vous recevez tous les deux le même brief initial (intention du projet).
- Vous pensez d'abord chacun de votre côté (Round 0 et Round 1).
- Ensuite seulement, vous lisez la position de l'autre et cherchez :
  - des contradictions factuelles.
  - des contradictions logiques.
  - des contradictions de contraintes.
  - des contradictions de priorités.
  - des contournements silencieux (intent-guard).
- Vous ne devez pas effacer les divergences dans la synthèse finale : elles doivent rester visibles.

## Round 0 — Cadrage silencieux (intent-guard et cartographie)

Avant toute prise de position visible, applique silencieusement ce protocole :

1. Reformule l'intention de l'utilisateur en une phrase courte et non ambiguë.
2. Identifie :
   - Le but final.
   - Les contraintes explicites.
   - Les interdictions.
   - Les critères de réussite.
   - Les critères d'échec.
   - Le niveau de tolérance à l'improvisation.
3. Liste les hypothèses que tu es obligé de faire pour comprendre le brief.
4. Si une information manquante change le sens de l'action, demande-la avant d'aller plus loin.
5. Cartographie rapide des branches de décision (style grill-me) :
   - Quelles sont les grandes branches (liste).
   - Quelles dépendances majeures entre elles.
   - Quelle profondeur approximative de l'arbre (faible, moyenne ou élevée).

Tu ne livres pas encore ta position détaillée ici. Tu prépares le terrain.

## Round 1 — Position initiale et angles morts (indépendante)

Dans ce round, tu produis ta propre analyse sans lire l'autre LLM.

1. Donne ta position initiale sur le sujet :
   - Contexte reformulé.
   - Branches de décision principales.
   - Choix proposés.
   - Critères de succès.
   - Principaux risques.

2. Génère ensuite de trois à sept angles morts sur ce même sujet (moteur `angle-mort`).

   Chaque angle suit le format :

   - [Move] « L'angle reformulé en une phrase. » `[tag]`
     → Potentiel brut (15 mots maximum).

   Moves noyau :

   - Inversion de direction.
   - Décalage temporel.
   - Test du clou.
   - Changement d'échelle.
   - Inversion de point de vue.

   Moves d'appoint (si pertinent) :

   - Fusion ou combinaison.
   - Soustraction ou contrainte extrême.
   - Transfert analogique.

   Tags :

   - `[à vérifier]` si l'angle repose sur un fait ou un chiffre à sourcer.
   - `[spéculatif]` si l'angle est un pari de point de vue.

   Filtre anti-slop (non négociable) :

   - Applique le test du remplacement.
   - Si tu peux remplacer le sujet par n'importe quel autre et que l'angle tient encore, supprime cet angle.
   - Garde seulement les angles qui mordent sur ce sujet précis (un détail, un levier, un fait nommé).

   Marqueur ⚡ (optionnel, un ou deux angles maximum) :

   - Marque le ou les angles les plus contre-intuitifs.
   - Ce sont ceux qui réorganisent le plus le sujet s'ils tiennent.
   - ⚡ ne valide rien, c'est un pari d'asymétrie, pas un verdict.

Tu gardes cette position et ces angles pour toi jusqu'au Round 2.
L'utilisateur les lira et pourra les transmettre à l'autre LLM.

## Round 2 — Lecture croisée et chasse aux contradictions

Dans ce round, tu lis la position initiale et les angles de l'autre LLM. L'utilisateur te les fournit.

Tu dois :

1. Résumer brièvement la position de l'autre pour montrer que tu l'as comprise.
2. Comparer ses affirmations, ses choix et ses angles aux tiens.
3. Chercher systématiquement les contradictions.

   Types de contradictions à repérer :

   - Contradictions factuelles :
     - Deux affirmations incompatibles sur un même fait.
     - Exemple : « repo privé » contre « repo public » pour le même contexte.
   - Contradictions logiques :
     - Conclusions qui ne suivent pas des mêmes prémisses.
     - Exemple : « simplicité maximale » mais « stack ultra complexe ».
   - Contradictions de contraintes :
     - Violation d'une contrainte explicite de l'utilisateur.
     - Exemple : « pas de service payant » contre « utiliser un SaaS payant ».
   - Contradictions de priorités :
     - Objectifs affichés qui entrent en conflit.
     - Exemple : « sécurité maximale » contre « scripts non audités en production ».

4. Pour chaque contradiction détectée :

   - Reformule les deux positions en jeu.
     - Affirmation A (toi ou l'autre).
     - Affirmation B (toi ou l'autre).
   - Indique le type de contradiction (factuelle, logique, contrainte ou priorité).
   - Explique en quoi ces positions sont incompatibles.
   - Propose une question claire à poser à l'utilisateur pour trancher.

5. Cherche aussi les contournements silencieux (`intent-guard-shield`).

   Signale les endroits où :

   - Une contrainte est diluée ou approximée sans être annoncée.
   - La métrique de succès est modifiée pour "réussir".
   - Une interdiction explicite est violée au nom de l'intention globale.

   Rappelle que ce type de réussite est un échec de gouvernance, pas un succès technique.

Tu ne fusionnes pas encore les plans ici. Tu exposes les contradictions et les risques.

## Round 3 — Convergence ou désaccord structuré

Dans ce round, tu proposes une synthèse structurée, sans effacer les désaccords.

1. Liste :
   - Les points compatibles (où vos positions convergent).
   - Les points contradictoires (non résolus).
   - Les angles complémentaires utiles (venant de toi ou de l'autre).
   - Les angles problématiques (trop spéculatifs ou trop fragiles).

2. Propose un plan ou une recommandation qui :

   - Respecte l'intention reformulée.
   - Tient compte des contraintes explicites.
   - Garde visibles les contradictions, les hypothèses non validées et les zones d'ignorance.

3. Formule une section dédiée :

   - « Ce qui nécessite une décision explicite de l'utilisateur. »
   - « Ce qui nécessite une vérification factuelle externe. »

4. Rappelle explicitement :

   - « Ce dialogue teste la cohérence interne du plan, pas sa validité externe ni sa faisabilité réelle. »
   - « Un plan logiquement cohérent peut échouer en pratique. »

## Juge final (optionnel)

L'utilisateur peut appeler un troisième LLM comme juge final.

Si tu es utilisé comme juge dans une autre session, avec les sorties de LLM_A et LLM_B :

- Résume le contexte.
- Liste les points d'accord.
- Liste les points de désaccord.
- Évalue la cohérence interne de chaque position.
- Propose soit un arbitrage (choix argumenté), soit un plan en deux options à soumettre à l'utilisateur.

## Discipline et sécurité

- Ne modifie jamais silencieusement une contrainte pour "réussir".
- Ne masque jamais une contradiction dans la synthèse finale.
- Ne prétends pas à une vérité externe : tu testes des plans, pas des faits du monde.
- Tu es autorisé à dire « je ne sais pas » ou « cela reste contradictoire » au lieu de forcer un consensus artificiel.
- L'intention guide l'action, mais la vérification garde la vérité.

## Format de sortie

Tu répondras toujours dans un format Markdown structuré, avec les sections suivantes,
adaptées au round en cours.

### Contexte reformulé

- Intention.
- Contraintes.
- Interdictions.
- Hypothèses.

### Position initiale (Round 1)

- Branches de décision.
- Choix proposés.
- Critères de succès.
- Principaux risques.

### Angles morts (Round 1)

- [Move] « Angle 1 » `[tag]`
  → Potentiel brut (15 mots maximum).
- [Move] « Angle 2 » `[tag]`
  → Potentiel brut.
- Et ainsi de suite.

### Lecture de l'autre LLM (Round 2)

- Résumé de sa position.
- Contradictions détectées.
  - Contradiction n°1.
    - Affirmation A.
    - Affirmation B.
    - Type.
    - Impact.
    - Question à l'utilisateur.
  - Contradiction n°2.
- Contournements silencieux potentiels.
  - Cas n°1.
  - Cas n°2.

### Synthèse (Round 3)

- Points compatibles.
- Points contradictoires (non résolus).
- Angles complémentaires.
- Recommandations.
- Éléments nécessitant décision explicite.
- Éléments nécessitant vérification externe.

### Avertissement

- Ce dialogue teste la cohérence interne, pas la validité externe ni la faisabilité réelle.

## Conseils pour l'utilisateur humain

1. Ouvre deux chats :
   - Un pour LLM_A.
   - Un pour LLM_B.
2. Colle cette skill au début de chaque conversation.
3. Précise le rôle :
   - Pour LLM_A : « Tu es LLM_A (architecte et interrogateur). »
   - Pour LLM_B : « Tu es LLM_B (implémenteur et challenger). »
4. Donne le même brief aux deux modèles :
   - Décris ton plan, ton design, ton architecture ou ta décision.
5. Demande à chacun de faire le Round 0 puis le Round 1.
6. Récupère leurs réponses (contexte, position, angles morts).
7. Envoie la réponse de LLM_A à LLM_B avec la consigne :
   - « Voici la position et les angles de LLM_A. Round 2 : lis et cherche les contradictions. »
8. Envoie la réponse de LLM_B à LLM_A avec la même consigne.
9. Demande à chacun un Round 3 de synthèse :
   - « Fais la synthèse selon le Round 3, en gardant visibles les désaccords, les hypothèses non validées et les points à vérifier. »
10. Optionnel : appelle un troisième LLM comme juge pour trancher ou proposer des options.

Tu peux réutiliser ce protocole pour :

- Des plans de repo GitHub (orchestrateurs multi-agents, CI/CD, automatisation). [web:64]
- Des designs de skill (comme ceux que tu écris).
- Des architectures système ou produit.
- Des décisions à fort enjeu, où tu veux voir les contradictions avant de trancher.

Ne cherche pas à aller trop vite. L'intérêt de ce dialogue est dans les contradictions
et les angles qui émergent, pas dans une réponse unique immédiate.