Add comprehensive DEMO_RESPONSES to seed data, detailing realistic responses across multiple dimensions, enhancing the evaluation framework with justifications and observed examples for improved clarity and usability.

prisma/seed.ts

@@ -115,6 +115,229 @@ const RUBRICS: Record<string, string> = {
     "1:Inconscient — pas de visibilité sur les coûts, usage sans limite;2:Aware — conscience des coûts, pas de suivi ni de budget;3:Suivi basique — métriques de consommation (tokens, API), pas d'alertes;4:Piloté — budgets par équipe/projet, alertes, arbitrage modèles/qualité;5:Optimisé — optimisation continue (contexte, batch, modèles), ROI coût documenté",
 };
 
+// Réponses réalistes par dimension et score (justification + exemples observés)
+const DEMO_RESPONSES: Record<
+  string,
+  Record<number, { justification: string; examplesObserved: string }>
+> = {
+  tools: {
+    2: {
+      justification: "Un outil principal (Cursor), choix fait sur recommandation. Pas de personnalisation.",
+      examplesObserved: "« J'utilise Cursor depuis 6 mois, un collègue me l'a conseillé. »",
+    },
+    3: {
+      justification: "Compare Cursor et Copilot, critères de coût et latence. Intégré au workflow quotidien.",
+      examplesObserved: "« J'ai testé les deux, Cursor me convient mieux pour le contexte. J'ai des règles basiques. »",
+    },
+    4: {
+      justification: "Rules et skills configurés, usage fluide. Connaît les agents mais les utilise peu.",
+      examplesObserved: "« J'ai des .cursorrules par projet, des skills pour les revues. Pas encore d'agents. »",
+    },
+  },
+  prompts: {
+    2: {
+      justification: "Instructions claires mais pas de format réutilisable. Résultats corrects sur tâches simples.",
+      examplesObserved: "« Je décris ce que je veux, parfois je précise le format. Ça marche la plupart du temps. »",
+    },
+    3: {
+      justification: "Format rôle-contexte-tâche utilisé. Teste manuellement. Pas de bibliothèque de prompts.",
+      examplesObserved: "« Je commence par le rôle, puis le contexte du fichier, puis la tâche. »",
+    },
+    4: {
+      justification: "Templates trouvés (ex. prompts de revue), réutilisés. Pas de few-shot systématique.",
+      examplesObserved: "« J'ai des prompts types pour la doc et les tests que je réutilise. »",
+    },
+  },
+  context: {
+    2: {
+      justification: "Quelques fichiers ouverts, @ parfois. Pas de stratégie de sélection.",
+      examplesObserved: "« J'ouvre les fichiers concernés, j'utilise @ pour le fichier courant. »",
+    },
+    3: {
+      justification: "Fichiers pertinents inclus, choix du modèle selon la tâche. Pas de rules pré-chargées.",
+      examplesObserved: "« Je @ le module et les tests. Pour les grosses tâches je prends un modèle plus capable. »",
+    },
+    4: {
+      justification: "Rules dans .cursorrules, stratégie de sélection. Gère la taille du contexte.",
+      examplesObserved: "« On a des rules projet pour l'archi. Je limite le contexte aux 10 fichiers les plus pertinents. »",
+    },
+  },
+  iteration: {
+    2: {
+      justification: "2-3 essais si ça échoue. Pas de décomposition systématique.",
+      examplesObserved: "« Si ça ne va pas je reformule ou je coupe en deux. »",
+    },
+    3: {
+      justification: "Retry systématique, reformulation. Décompose les grosses tâches.",
+      examplesObserved: "« Je décompose les features en sous-tâches, une par prompt. »",
+    },
+    4: {
+      justification: "Prompts en chaîne, décomposition claire. Utilise l'IA pour challenger.",
+      examplesObserved: "« Pour un refacto je fais : analyse → plan → implémentation. L'IA me pose des questions. »",
+    },
+  },
+  evaluation: {
+    2: {
+      justification: "Relecture rapide, pas de critères explicites. Accepte si ça compile.",
+      examplesObserved: "« Je relis le code, je lance les tests. Si ça passe je merge. »",
+    },
+    3: {
+      justification: "Tests manuels ou auto avant merge. Vérifie le comportement.",
+      examplesObserved: "« On a des tests, je les lance. Je vérifie les cas limites à la main. »",
+    },
+    4: {
+      justification: "Regard sur maintenabilité et alignement. Critères implicites.",
+      examplesObserved: "« Je vérifie que ça respecte nos patterns. Si c'est du copier-coller je refuse. »",
+    },
+  },
+  integration: {
+    2: {
+      justification: "Discussions informelles en équipe. Pas de formalisation.",
+      examplesObserved: "« On en parle à la pause, on se montre des trucs. »",
+    },
+    3: {
+      justification: "Démos, partage de REX. Pas de doc ni onboarding.",
+      examplesObserved: "« On a fait une démo Cursor au team meeting. Les gens posent des questions. »",
+    },
+    4: {
+      justification: "Pratiques documentées, onboarding des nouveaux.",
+      examplesObserved: "« On a une page Confluence avec les bonnes pratiques. Les juniors la lisent. »",
+    },
+  },
+  usecases: {
+    2: {
+      justification: "Snippets, complétion, fonctions simples. Pas de tests ni refacto assistés.",
+      examplesObserved: "« Surtout pour compléter du code, des petites fonctions. »",
+    },
+    3: {
+      justification: "Tests, refacto, doc. Debug occasionnel. Pas de discovery ni review.",
+      examplesObserved: "« Je génère des tests, je refactore avec l'IA. Parfois pour le debug. »",
+    },
+    4: {
+      justification: "Debug, optimisation, analyse. Commence à explorer discovery et review.",
+      examplesObserved: "« L'IA m'aide à trouver des bugs, à optimiser. J'ai essayé pour la revue de PR. »",
+    },
+  },
+  conception: {
+    2: {
+      justification: "Notes rapides ou réflexion mentale. Pas de doc ni schéma.",
+      examplesObserved: "« Je réfléchis avant, je note des idées. Pas de SDD formel. »",
+    },
+    3: {
+      justification: "IA pour esquisser des designs. Schémas ou doc légère.",
+      examplesObserved: "« Je demande à l'IA de proposer une archi, je valide avant de coder. »",
+    },
+    4: {
+      justification: "Mode plan structuré. IA pour explorer options et documenter.",
+      examplesObserved: "« On fait un petit SDD, l'IA propose des variantes. On documente les décisions. »",
+    },
+  },
+  exploration: {
+    2: {
+      justification: "Quelques essais ponctuels. Pas de veille structurée.",
+      examplesObserved: "« J'ai vu un truc sur X l'autre jour, j'ai testé. Bof. »",
+    },
+    3: {
+      justification: "Suit web/X, teste de temps en temps. Identifie des astuces.",
+      examplesObserved: "« Je suis des comptes dev sur X, je teste les astuces qui ont l'air bien. »",
+    },
+    4: {
+      justification: "Teste régulièrement. Identifie ce qui améliore contexte et pertinence.",
+      examplesObserved: "« J'ai trouvé une astuce pour le contexte qui a bien amélioré mes résultats. »",
+    },
+  },
+  impact: {
+    2: {
+      justification: "Gain de temps perçu, non quantifié.",
+      examplesObserved: "« Je sens que je vais plus vite. Je n'ai pas mesuré. »",
+    },
+    3: {
+      justification: "Vélocité accrue, moins de répétitif. Pas de métriques.",
+      examplesObserved: "« On livre plus vite. Les tâches répétitives prennent moins de temps. »",
+    },
+    4: {
+      justification: "Métriques documentées (temps, qualité).",
+      examplesObserved: "« On a mesuré : -30% sur les tâches de doc, +20% de vélocité sur les features. »",
+    },
+  },
+  alignment: {
+    2: {
+      justification: "Rework important souvent nécessaire. NFR pas dans le contexte.",
+      examplesObserved: "« Le code marche mais il faut souvent adapter pour nos standards. »",
+    },
+    3: {
+      justification: "Généralement aligné, quelques ajustements. NFR parfois oubliés.",
+      examplesObserved: "« Ça respecte nos patterns la plupart du temps. Parfois je dois ajouter les logs. »",
+    },
+    4: {
+      justification: "Prompts et rules pour standards, archi et NFR. Garde-fous en place.",
+      examplesObserved: "« On a des rules pour la perf et l'observabilité. L'IA les respecte bien. »",
+    },
+  },
+  quality_usage: {
+    2: {
+      justification: "Tests unitaires basiques générés. Peu de review assistée.",
+      examplesObserved: "« Je génère des tests parfois. Pour la review je préfère faire à la main. »",
+    },
+    3: {
+      justification: "Tests pertinents, refacto assistée. Couverture correcte.",
+      examplesObserved: "« L'IA génère des tests utiles. Je l'utilise pour identifier du code à refactorer. »",
+    },
+    4: {
+      justification: "IA dans la boucle qualité. Review, dette technique.",
+      examplesObserved: "« On utilise l'IA pour la review de PR et pour prioriser la dette technique. »",
+    },
+  },
+  learning: {
+    2: {
+      justification: "Utilise pour débloquer. Compréhension superficielle.",
+      examplesObserved: "« Quand je suis bloqué je demande à l'IA. Je comprends à peu près. »",
+    },
+    3: {
+      justification: "IA pour valider sa compréhension. Évite le copier-coller aveugle.",
+      examplesObserved: "« Je demande des explications, je vérifie que j'ai compris avant d'utiliser. »",
+    },
+    4: {
+      justification: "Apprend patterns et archi via l'IA. Montée en compétence structurée.",
+      examplesObserved: "« L'IA m'aide à comprendre des patterns qu'on utilise. Je pose des questions ciblées. »",
+    },
+  },
+  cost_control: {
+    2: {
+      justification: "Conscience des coûts, pas de suivi.",
+      examplesObserved: "« Je sais que ça coûte mais je ne regarde pas. »",
+    },
+    3: {
+      justification: "Métriques de consommation visibles. Pas d'alertes ni budgets.",
+      examplesObserved: "« On voit la conso dans le dashboard. Pas de limite par équipe. »",
+    },
+    4: {
+      justification: "Budgets par équipe, alertes. Arbitrage modèles/qualité.",
+      examplesObserved: "« On a des budgets, des alertes si on dépasse. On utilise des modèles plus légers pour le trivial. »",
+    },
+  },
+};
+
+function getDemoResponse(
+  slug: string,
+  score: number
+): { justification: string; examplesObserved: string } {
+  const dim = DEMO_RESPONSES[slug];
+  const exact = dim?.[score];
+  if (exact) return exact;
+  // Fallback: prendre le plus proche ou générique
+  const scores = dim ? Object.keys(dim).map(Number) : [];
+  const nearest = scores.length
+    ? scores.reduce((a, b) => (Math.abs(a - score) < Math.abs(b - score) ? a : b))
+    : 3;
+  return (
+    dim?.[nearest] ?? {
+      justification: `Niveau ${score} observé lors de l'entretien.`,
+      examplesObserved: `Éléments relevés pour cette dimension.`,
+    }
+  );
+}
+
 const TEMPLATES_DATA = [
   {
     id: "full-15",
@@ -288,23 +511,24 @@ async function main() {
           status: i === 0 ? "submitted" : "draft",
           findings:
             i === 0
-              ? "Bonne maîtrise des outils et des prompts. Axes d'amélioration : capitalisation et mesure."
+              ? "Bonne maîtrise des outils et des prompts. Conception et exploration à renforcer. Alignement NFR correct."
               : null,
           recommendations:
             i === 0
-              ? "Former sur la capitalisation des prompts et mettre en place des indicateurs."
+              ? "Encourager le mode plan avant implémentation. Veille sur les workflows IA."
               : null,
         },
       });
       for (const d of dims) {
         const score = 2 + Math.floor(Math.random() * 3);
+        const { justification, examplesObserved } = getDemoResponse(d.slug, score);
         await prisma.dimensionScore.create({
           data: {
             evaluationId: evaluation.id,
             dimensionId: d.id,
             score,
-            justification: `Justification pour ${d.title}`,
-            examplesObserved: `Observé : ${d.title} niveau ${score}`,
+            justification,
+            examplesObserved,
             confidence: ["low", "med", "high"][Math.floor(Math.random() * 3)],
           },
         });