ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity

Merge branch 'main' into docs/ko-kr-translation

This commit is contained in:
yeomin4242 2026-06-07 16:05:31 +09:00 committed by GitHub
parent 49e9c2dd3a 072d0a7458
commit 2e930e67f9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
81 changed files with 5220 additions and 3613 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/explanation/party-mode.md
View File

@ -9,7 +9,7 @@ Get all your AI agents in one conversation.
## What is Party Mode?
Run `bmad-party-mode` and you've got your whole AI team in one room - PM, Architect, Dev, UX Designer, whoever you need. BMad Master orchestrates, picking relevant agents per message. Agents respond in character, agree, disagree, and build on each other's ideas.
Run `bmad-party-mode` and you've got your whole AI team in one room - PM, Architect, Dev, UX Designer, whoever you need. Party Mode orchestrates the discussion, picking relevant installed agents per message. Agents respond in character, agree, disagree, and build on each other's ideas.
The conversation continues as long as you want. Ask follow-ups, push back on answers, redirect the discussion - it's a real back-and-forth with your agents until you're done.

4
docs/fr/404.md
View File

@ -3,6 +3,6 @@ title: Page introuvable
template: splash
---
La page que vous recherchez n'existe pas ou a été déplacée.
La page que vous recherchez n’existe pas ou a été déplacée.
[Retour à l'accueil](/fr/index.md)
[Retour à l’accueil](/fr/index.md)

143
docs/fr/_STYLE_GUIDE.md
View File

@ -7,17 +7,17 @@ Ce projet suit le [Guide de style de documentation pour développeurs Google](ht
## Règles spécifiques au projet
| Règle | Spécification |
| --------------------------------------- | ------------------------------------------------------ |
| Pas de règles horizontales (`---`) | Perturbe le flux de lecture des fragments |
| Pas de titres `####` | Utiliser du texte en gras ou des admonitions |
| Pas de sections « Related » ou « Next: » | La barre latérale gère la navigation |
| Pas de listes profondément imbriquées | Diviser en sections à la place |
| Pas de blocs de code pour non-code | Utiliser des admonitions pour les exemples de dialogue |
| Pas de paragraphes en gras pour les appels | Utiliser des admonitions à la place |
| 1-2 admonitions max par section | Les tutoriels permettent 3-4 par section majeure |
| Cellules de tableau / éléments de liste | 1-2 phrases maximum |
| Budget de titres | 8-12 `##` par doc ; 2-3 `###` par section |
| Règle | Spécification |
|--------------------------------------------|--------------------------------------------------------|
| Pas de règles horizontales (`---`) | Perturbe le flux de lecture des fragments |
| Pas de titres `####` | Utiliser du texte en gras ou des admonitions |
| Pas de sections « Related » ou « Next » | La barre latérale gère la navigation |
| Pas de listes profondément imbriquées | Diviser en sections à la place |
| Pas de blocs de code pour non-code | Utiliser des admonitions pour les exemples de dialogue |
| Pas de paragraphes en gras pour les appels | Utiliser des admonitions à la place |
| 1-2 admonitions max par section | Les tutoriels permettent 3-4 par section majeure |
| Cellules de tableau / éléments de liste | 1-2 phrases maximum |
| Budget de titres | 8-12 `##` par doc ; 2-3 `###` par section |
## Admonitions (Syntaxe Starlight)
@ -41,36 +41,36 @@ Avertissements critiques uniquement — perte de données, problèmes de sécuri
### Utilisations standards
| Admonition | Usage |
| -------------------------- | ---------------------------------------- |
| `:::note[Pré-requis]` | Dépendances avant de commencer |
| `:::tip[Chemin rapide]` | Résumé TL;DR en haut du document |
| `:::caution[Important]` | Mises en garde critiques |
| `:::note[Exemple]` | Exemples de commandes/réponses |
| Admonition | Usage |
|-------------------------|----------------------------------|
| `:::note[Pré-requis]` | Dépendances avant de commencer |
| `:::tip[Chemin rapide]` | Résumé TL;DR en haut du document |
| `:::caution[Important]` | Mises en garde critiques |
| `:::note[Exemple]` | Exemples de commandes/réponses |
## Formats de tableau standards
**Phases :**
**Phases :**
```md
| Phase | Nom | Ce qui se passe |
| ----- | ---------- | --------------------------------------------------- |
| 1 | Analyse | Brainstorm, recherche *(optionnel)* |
| 2 | Planification | Exigences — PRD ou spécification technique *(requis)* |
| Phase | Nom | Ce qui se passe |
|-------|---------------|-------------------------------------------------------|
| 1 | Analyse | Brainstorm, recherche *(optionnel)* |
| 2 | Planification | Exigences — PRD ou spécification technique *(requis)* |
```
**Skills :**
**Skills :**
```md
| Skill | Agent | Objectif |
| ------------------- | ------- | ----------------------------------------------- |
| `bmad-brainstorming` | Analyste | Brainstorming pour un nouveau projet |
| `bmad-create-prd` | PM | Créer un document d'exigences produit |
| Skill | Agent | Objectif |
|----------------------|----------|---------------------------------------|
| `bmad-brainstorming` | Analyste | Brainstorming pour un nouveau projet |
| `bmad-prd` | PM | Créer un document d'exigences produit |
```
## Blocs de structure de dossiers
À afficher dans les sections "Ce que vous avez accompli" :
À afficher dans les sections « Ce que vous avez accompli » :
````md
```
@ -78,9 +78,9 @@ votre-projet/
├── _bmad/ # Configuration BMad
├── _bmad-output/
│ ├── planning-artifacts/
│ │ └── PRD.md # Votre document d'exigences
│ │ └── PRD.md # Votre document d’exigences
│ ├── implementation-artifacts/
│ └── project-context.md # Règles d'implémentation (optionnel)
│ └── project-context.md # Règles d’implémentation (optionnel)
└── ...
```
````
@ -107,21 +107,21 @@ votre-projet/
### Liste de vérification des tutoriels
- [ ] L'accroche décrit le résultat en 1-2 phrases
- [ ] Section "Ce que vous allez apprendre" présente
- [ ] L’accroche décrit le résultat en 1-2 phrases
- [ ] Section « Ce que vous allez apprendre » présente
- [ ] Prérequis dans une admonition
- [ ] Admonition TL;DR de chemin rapide en haut
- [ ] Tableaux pour phases, skills, agents
- [ ] Section "Ce que vous avez accompli" présente
- [ ] Section « Ce que vous avez accompli » présente
- [ ] Tableau de référence rapide présent
- [ ] Section questions courantes présente
- [ ] Section obtenir de l'aide présente
- [ ] Section obtenir de l’aide présente
- [ ] Admonition points clés à retenir à la fin
## Structure des guides pratiques (How-To)
```text
1. Titre + Accroche (une phrase : « Utilisez le workflow `X` pour... »)
1. Titre + Accroche (une phrase : « Utilisez le workflow `X` pour... »)
2. Quand utiliser ce guide (liste à puces de scénarios)
3. Quand éviter ce guide (optionnel)
4. Prérequis (admonition note)
@ -134,23 +134,23 @@ votre-projet/
### Liste de vérification des guides pratiques
- [ ] L'accroche commence par « Utilisez le workflow `X` pour... »
- [ ] "Quand utiliser ce guide" contient 3-5 points
- [ ] L’accroche commence par « Utilisez le workflow `X` pour... »
- [ ] « Quand utiliser ce guide » contient 3-5 points
- [ ] Prérequis listés
- [ ] Les étapes sont des sous-sections `###` numérotées avec des verbes d'action
- [ ] "Ce que vous obtenez" décrit les artefacts produits
- [ ] Les étapes sont des sous-sections `###` numérotées avec des verbes d’action
- [ ] « Ce que vous obtenez » décrit les artefacts produits
## Structure des explications
### Types
| Type | Exemple |
| ----------------------- | ------------------------------------ |
| **Index/Page d'accueil** | `core-concepts/index.md` |
| **Concept** | `what-are-agents.md` |
| **Fonctionnalité** | `quick-dev.md` |
| **Philosophie** | `why-solutioning-matters.md` |
| **FAQ** | `established-projects-faq.md` |
| Type | Exemple |
|--------------------------|-------------------------------|
| **Index/Page d’accueil** | `core-concepts/index.md` |
| **Concept** | `what-are-agents.md` |
| **Fonctionnalité** | `quick-dev.md` |
| **Philosophie** | `why-solutioning-matters.md` |
| **FAQ** | `established-projects-faq.md` |
### Modèle général
@ -164,7 +164,7 @@ votre-projet/
7. Prochaines étapes (optionnel)
```
### Pages d'index/d'accueil
### Pages d’index/d’accueil
```text
1. Titre + Accroche (une phrase)
@ -209,7 +209,7 @@ votre-projet/
### Liste de vérification des explications
- [ ] L'accroche énonce ce que le document explique
- [ ] L’accroche énonce ce que le document explique
- [ ] Contenu dans des sections `##` parcourables
- [ ] Tableaux comparatifs pour 3+ options
- [ ] Les diagrammes ont des étiquettes claires
@ -220,16 +220,16 @@ votre-projet/
### Types
| Type | Exemple |
| ----------------------- | --------------------- |
| **Index/Page d'accueil** | `workflows/index.md` |
| **Catalogue** | `agents/index.md` |
| **Approfondissement** | `document-project.md` |
| **Configuration** | `core-tasks.md` |
| **Glossaire** | `glossary/index.md` |
| **Complet** | `bmgd-workflows.md` |
| Type | Exemple |
|--------------------------|-----------------------|
| **Index/Page d’accueil** | `workflows/index.md` |
| **Catalogue** | `agents/index.md` |
| **Approfondissement** | `document-project.md` |
| **Configuration** | `core-tasks.md` |
| **Glossaire** | `glossary/index.md` |
| **Complet** | `bmgd-workflows.md` |
### Pages d'index de référence
### Pages d’index de référence
```text
1. Titre + Accroche (une phrase)
@ -243,11 +243,11 @@ votre-projet/
1. Titre + Accroche
2. Éléments (## pour chaque élément)
- Brève description (une phrase)
- **Skills :** ou **Infos clés :** sous forme de liste simple
- **Skills :** ou **Infos clés :** sous forme de liste simple
3. Universel/Partagé (## section) (optionnel)
```
### Référence d'approfondissement d'élément
### Référence d’approfondissement d’élément
```text
1. Titre + Accroche (objectif en une phrase)
@ -286,16 +286,16 @@ votre-projet/
### Liste de vérification des références
- [ ] L'accroche énonce ce que le document référence
- [ ] L’accroche énonce ce que le document référence
- [ ] La structure correspond au type de référence
- [ ] Les éléments utilisent une structure cohérente
- [ ] Tableaux pour les données structurées/comparatives
- [ ] Liens vers les documents d'explication pour la profondeur conceptuelle
- [ ] Liens vers les documents d’explication pour la profondeur conceptuelle
- [ ] 1-2 admonitions max
## Structure du glossaire
Starlight génère la navigation "Sur cette page" à droite à partir des titres :
Starlight génère la navigation « Sur cette page » à droite à partir des titres :
- Catégories en tant que titres `##` — apparaissent dans la navigation à droite
- Termes dans des tableaux — lignes compactes, pas de titres individuels
@ -303,22 +303,23 @@ Starlight génère la navigation "Sur cette page" à droite à partir des titres
### Format de tableau
```md
## Nom de catégorie
| Terme | Définition |
| ------------ | --------------------------------------------------------------------------------------------- |
| **Agent** | Personnalité IA spécialisée avec une expertise spécifique qui guide les utilisateurs dans les workflows. |
| Terme | Définition |
|--------------|------------------------------------------------------------------------------------------------------------|
| **Agent** | Personnalité IA spécialisée avec une expertise spécifique qui guide les utilisateurs dans les workflows. |
| **Workflow** | Processus guidé en plusieurs étapes qui orchestre les activités des agents IA pour produire des livrables. |
```
### Règles de définition
| À faire | À ne pas faire |
| --------------------------------- | --------------------------------------------- |
| Commencer par ce que c'est ou ce que cela fait | Commencer par « C'est... » ou « Un [terme] est... » |
| Se limiter à 1-2 phrases | Écrire des explications de plusieurs paragraphes |
| Mettre le nom du terme en gras dans la cellule | Utiliser du texte simple pour les termes |
| À faire | À ne pas faire |
|------------------------------------------------|-----------------------------------------------------|
| Commencer par ce que c’est ou ce que cela fait | Commencer par « C’est... » ou « Un [terme] est... » |
| Se limiter à 1-2 phrases | Écrire des explications de plusieurs paragraphes |
| Mettre le nom du terme en gras dans la cellule | Utiliser du texte simple pour les termes |
### Marqueurs de contexte
@ -337,7 +338,7 @@ Ajouter un contexte en italique au début de la définition pour les termes à p
- [ ] Définitions de 1-2 phrases
- [ ] Marqueurs de contexte en italique
- [ ] Noms des termes en gras dans les cellules
- [ ] Pas de définitions « Un [terme] est... »
- [ ] Pas de définitions « Un [terme] est... »
## Sections FAQ

28
docs/fr/explanation/advanced-elicitation.md
View File

@ -2,25 +2,25 @@
title: "Élicitation Avancée"
description: Pousser le LLM à repenser son travail en utilisant des méthodes de raisonnement structurées
sidebar:
order: 3
order: 4
---
Faites repenser au LLM ce qu'il vient de générer. Vous choisissez une méthode de raisonnement, il l'applique à sa propre sortie, et vous décidez de conserver ou non les améliorations.
Faites repenser au LLM ce qu’il vient de générer. Vous choisissez une méthode de raisonnement, il l’applique à sa propre sortie, et vous décidez de conserver ou non les améliorations.
## Qu'est-ce que l’Élicitation Avancée ?
## Qu’est-ce que l’Élicitation Avancée ?
Un second passage structuré. Au lieu de demander à l'IA de "réessayer" ou de "faire mieux", vous sélectionnez une méthode de raisonnement spécifique et l'IA réexamine sa propre sortie à travers ce prisme.
Un second passage structuré. Au lieu de demander à l’IA de « réessayer » ou de « faire mieux », vous sélectionnez une méthode de raisonnement spécifique et l’IA réexamine sa propre sortie à travers ce prisme.
La différence est importante. Les demandes vagues produisent des révisions vagues. Une méthode nommée impose un angle d'attaque particulier, mettant en lumière des perspectives qu'un simple réajustement générique aurait manquées.
La différence est importante. Les demandes vagues produisent des révisions vagues. Une méthode nommée impose un angle d’attaque particulier, mettant en lumière des perspectives qu’un simple réajustement générique aurait manquées.
## Quand l'utiliser
## Quand l’utiliser
- Après qu'un workflow a généré du contenu et vous souhaitez des alternatives
- Lorsque la sortie semble correcte mais que vous soupçonnez qu'il y a davantage de profondeur
- Après qu’un workflow a généré du contenu et vous souhaitez des alternatives
- Lorsque la sortie semble correcte mais que vous soupçonnez qu’il y a davantage de profondeur
- Pour tester les hypothèses ou trouver des faiblesses
- Pour du contenu à enjeux élevés où la réflexion approfondie aide
Les workflows offrent l'élicitation aux points de décision - après que le LLM ait généré quelque chose, on vous demandera si vous souhaitez l'exécuter.
Les workflows offrent l’élicitation aux points de décision - après que le LLM ait généré quelque chose, on vous demandera si vous souhaitez l’exécuter.
## Comment ça fonctionne
@ -35,15 +35,15 @@ Des dizaines de méthodes de raisonnement sont disponibles. Quelques exemples :
- **Analyse Pré-mortem** - Suppose que le projet a déjà échoué, revient en arrière pour trouver pourquoi
- **Pensée de Premier Principe** - Élimine les hypothèses, reconstruit à partir de la vérité de terrain
- **Inversion** - Demande comment garantir l'échec, puis les évite
- **Inversion** - Demande comment garantir l’échec, puis les évite
- **Équipe Rouge vs Équipe Bleue** - Attaque votre propre travail, puis le défend
- **Questionnement Socratique** - Conteste chaque affirmation avec "pourquoi ?" et "comment le savez-vous ?"
- **Questionnement Socratique** - Conteste chaque affirmation avec « pourquoi ? » et « comment le savez-vous ? »
- **Suppression des Contraintes** - Abandonne toutes les contraintes, voit ce qui change, les réajoute sélectivement
- **Cartographie des Parties Prenantes** - Réévalue depuis la perspective de chaque partie prenante
- **Raisonnement Analogique** - Trouve des parallèles dans d'autres domaines et applique leurs leçons
- **Raisonnement Analogique** - Trouve des parallèles dans d’autres domaines et applique leurs leçons
Et bien d'autres. L'IA choisit les options les plus pertinentes pour votre contenu - vous choisissez lesquelles exécuter.
Et bien d’autres. L’IA choisit les options les plus pertinentes pour votre contenu - vous choisissez lesquelles exécuter.
:::tip[Commencez Ici]
L'Analyse Pré-mortem est un bon premier choix pour toute spécification ou tout plan. Elle trouve systématiquement des lacunes qu'une révision standard manque.
L’Analyse Pré-mortem est un bon premier choix pour toute spécification ou tout plan. Elle trouve systématiquement des lacunes qu’une révision standard manque.
:::

38
docs/fr/explanation/adversarial-review.md
View File

@ -1,58 +1,58 @@
---
title: "Revue Contradictoire"
description: Technique de raisonnement forcée qui empêche les revues paresseuses du style "ça à l'air bon"
description: Technique de raisonnement forcée qui empêche les revues paresseuses du style « ça à l’air bon »
sidebar:
order: 8
order: 9
---
Forcez une analyse plus approfondie en exigeant que des problèmes soient trouvés.
## Qu'est-ce que la Revue Contradictoire ?
## Qu’est-ce que la Revue Contradictoire ?
Une technique de revue où le réviseur *doit* trouver des problèmes. Pas de "ça a l'air bon" autorisé. Le réviseur adopte une posture cynique - suppose que des problèmes existent et les trouve.
Une technique de revue où le réviseur *doit* trouver des problèmes. Pas de « ça a l’air bon » autorisé. Le réviseur adopte une posture cynique - suppose que des problèmes existent et les trouve.
Il ne s'agit pas d'être négatif. Il s'agit de forcer une analyse authentique au lieu d'un coup d'œil superficiel qui valide automatiquement ce qui a été soumis.
Il ne s’agit pas d’être négatif. Il s’agit de forcer une analyse authentique au lieu d’un coup d’œil superficiel qui valide automatiquement ce qui a été soumis.
**La règle fondamentale :** Il doit trouver des problèmes. Zéro constatation déclenche un arrêt - réanalyse ou explique pourquoi.
**La règle fondamentale :** Il doit trouver des problèmes. Zéro constatation déclenche un arrêt - réanalyse ou explique pourquoi.
## Pourquoi Cela Fonctionne
Les revues normales souffrent du biais de confirmation[^1]. Il parcourt le travail rapidement, rien ne lui saute aux yeux, il l'approuve. L'obligation de "trouver des problèmes" brise ce schéma :
Les revues normales souffrent du biais de confirmation[^1]. Il parcourt le travail rapidement, rien ne lui saute aux yeux, il l’approuve. L’obligation de « trouver des problèmes » brise ce schéma :
- **Force la rigueur** - Impossible d'approuver tant qu’il n'a pas examiné suffisamment en profondeur pour trouver des problèmes
- **Détecte les oublis** - "Qu'est-ce qui manque ici ?" devient une question naturelle
- **Force la rigueur** - Impossible d’approuver tant qu’il n’a pas examiné suffisamment en profondeur pour trouver des problèmes
- **Détecte les oublis** - « Qu’est-ce qui manque ici ? » devient une question naturelle
- **Améliore la qualité du signal** - Les constatations sont spécifiques et actionnables, pas des préoccupations vagues
- **Asymétrie d'information**[^2] - Effectue les revues avec un contexte frais (sans accès au raisonnement original) pour évaluer l'artefact, pas l'intention
- **Asymétrie d’information**[^2] - Effectue les revues avec un contexte frais (sans accès au raisonnement original) pour évaluer l’artefact, pas l’intention
## Où Elle Est Utilisée
La revue contradictoire apparaît dans tous les workflows BMad - revue de code, vérifications de préparation à l'implémentation, validation de spécifications, et d'autres. Parfois c'est une étape obligatoire, parfois optionnelle (comme l'élicitation avancée ou le mode party). Le pattern s'adapte à n'importe quel artefact nécessitant un examen.
La revue contradictoire apparaît dans tous les workflows BMad - revue de code, vérifications de préparation à l’implémentation, validation de spécifications, et d’autres. Parfois c’est une étape obligatoire, parfois optionnelle (comme l’élicitation avancée ou le mode party). Le pattern s’adapte à n’importe quel artefact nécessitant un examen.
## Filtrage Humain Requis
Parce que l'IA est *instruite* de trouver des problèmes, elle trouvera des problèmes - même lorsqu'ils n'existent pas. Attendez-vous à des faux positifs : des détails présentés comme des problèmes, des malentendus sur l'intention, ou des préoccupations purement hallucinées[^3].
Parce que l’IA est *instruite* de trouver des problèmes, elle trouvera des problèmes - même lorsqu’ils n’existent pas. Attendez-vous à des faux positifs : des détails présentés comme des problèmes, des malentendus sur l’intention, ou des préoccupations purement hallucinées[^3].
**C'est vous qui décidez ce qui est réel.** Examinez chaque constatation, ignorez le bruit, corrigez ce qui compte.
**C’est vous qui décidez ce qui est réel.** Examinez chaque constatation, ignorez le bruit, corrigez ce qui compte.
## Exemple
Au lieu de :
> "L'implémentation de l'authentification semble raisonnable. Approuvé."
> « L’implémentation de l’authentification semble raisonnable. Approuvé. »
Une revue contradictoire produit :
> 1. **ÉLEVÉ** - `login.ts:47` - Pas de limitation de débit sur les tentatives échouées
> 2. **ÉLEVÉ** - Jeton de session stocké dans localStorage (vulnérable au XSS)
> 3. **MOYEN** - La validation du mot de passe se fait côté client uniquement
> 4. **MOYEN** - Pas de journalisation d'audit pour les tentatives de connexion échouées
> 4. **MOYEN** - Pas de journalisation d’audit pour les tentatives de connexion échouées
> 5. **FAIBLE** - Le nombre magique `3600` devrait être `SESSION_TIMEOUT_SECONDS`
La première revue pourrait manquer une vulnérabilité de sécurité. La seconde en a attrapé quatre.
## Itération et Rendements Décroissants
Après avoir traité les constatations, envisagez de relancer la revue. Une deuxième passe détecte généralement plus de problèmes. Une troisième n'est pas toujours inutile non plus. Mais chaque passe prend du temps, et vous finissez par atteindre des rendements décroissants[^4] - juste des détails et des faux problèmes.
Après avoir traité les constatations, envisagez de relancer la revue. Une deuxième passe détecte généralement plus de problèmes. Une troisième n’est pas toujours inutile non plus. Mais chaque passe prend du temps, et vous finissez par atteindre des rendements décroissants[^4] - juste des détails et des faux problèmes.
:::tip[Meilleures Revues]
Supposez que des problèmes existent. Cherchez ce qui manque, pas seulement ce qui ne va pas.
@ -61,6 +61,6 @@ Supposez que des problèmes existent. Cherchez ce qui manque, pas seulement ce q
## Glossaire
[^1]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui confirment nos croyances préexistantes, tout en ignorant ou minimisant celles qui les contredisent.
[^2]: **Asymétrie d'information** : situation où une partie dispose de plus ou de meilleures informations qu'une autre, conduisant potentiellement à des décisions ou jugements biaisés.
[^3]: **Hallucination (IA)** : phénomène où un modèle d'IA génère des informations plausibles mais factuellement incorrectes ou inventées, présentées avec confiance comme si elles étaient vraies.
[^4]: **Rendements décroissants** : principe selon lequel l'augmentation continue d'un investissement (temps, effort, ressources) finit par produire des bénéfices de plus en plus faibles proportionnellement.
[^2]: **Asymétrie d’information** : situation où une partie dispose de plus ou de meilleures informations qu’une autre, conduisant potentiellement à des décisions ou jugements biaisés.
[^3]: **Hallucination (IA)** : phénomène où un modèle d’IA génère des informations plausibles mais factuellement incorrectes ou inventées, présentées avec confiance comme si elles étaient vraies.
[^4]: **Rendements décroissants** : principe selon lequel l’augmentation continue d’un investissement (temps, effort, ressources) finit par produire des bénéfices de plus en plus faibles proportionnellement.

56
docs/fr/explanation/analysis-phase.md
View File

@ -1,74 +1,74 @@
---
title: "Phase d'analyse : de l'Idée aux Fondations"
title: "Phase d’analyse : de l’Idée aux Fondations"
description: Ce que sont le brainstorming, la recherche, les product briefs et les PRFAQs — et quand les utiliser
sidebar:
order: 1
order: 2
---
La phase d'Analyse (Phase 1) vous aide à penser clairement à votre produit avant de vous engager à le construire. Chaque outil de cette phase est optionnel, mais sauter l'analyse entièrement signifie que votre PRD sera construit sur des suppositions plutôt que sur des connaissances approfondies.
La phase d’Analyse (Phase 1) vous aide à penser clairement à votre produit avant de vous engager à le construire. Chaque outil de cette phase est optionnel, mais sauter l’analyse entièrement signifie que votre PRD sera construit sur des suppositions plutôt que sur des connaissances approfondies.
## Pourquoi Analyser avant de Planifier ?
## Pourquoi Analyser avant de Planifier ?
Un PRD répond à la question « que devons-nous construire et pourquoi ? » Si vous l'alimentez avec une réflexion vague, vous obtiendrez un PRD vague — et chaque document en aval héritera de cette imprécision. Une architecture bâtie sur un PRD faible prend de mauvaises décisions techniques. Les stories dérivées d'une architecture faible manquent de edge cases. Le coût s'accumule.
Un PRD répond à la question « que devons-nous construire et pourquoi ? » Si vous l’alimentez avec une réflexion vague, vous obtiendrez un PRD vague — et chaque document en aval héritera de cette imprécision. Une architecture bâtie sur un PRD faible prend de mauvaises décisions techniques. Les stories dérivées d’une architecture faible manquent de edge cases. Le coût s’accumule.
Les outils d'analyse existent pour rendre votre PRD précis. Ils attaquent le problème sous différents angles — exploration créative, réalité du marché, clarté client, faisabilité — pour qu'au moment de vous asseoir avec l'agent PM, vous sachiez ce que vous construisez et pour qui.
Les outils d’analyse existent pour rendre votre PRD précis. Ils attaquent le problème sous différents angles — exploration créative, réalité du marché, clarté client, faisabilité — pour qu’au moment de vous asseoir avec l’agent PM, vous sachiez ce que vous construisez et pour qui.
## Les Outils
### Brainstorming
**Quoi.** Une session créative facilitée utilisant des techniques d'idéation éprouvées. L'IA agit comme coach, extrayant vos idées à travers des exercices structurés — pas en les générant pour vous.
**Quoi.** Une session créative facilitée utilisant des techniques d’idéation éprouvées. L’IA agit comme coach, extrayant vos idées à travers des exercices structurés — pas en les générant pour vous.
**Pourquoi.** Les idées brutes ont besoin d'espace pour se développer avant d'être verrouillées dans des exigences. Le brainstorming crée cet espace. Il est particulièrement précieux quand vous avez un espace-problème mais pas de solution claire, ou quand vous voulez explorer plusieurs pistes avant de vous engager.
**Pourquoi.** Les idées brutes ont besoin d’espace pour se développer avant d’être verrouillées dans des exigences. Le brainstorming crée cet espace. Il est particulièrement précieux quand vous avez un espace-problème mais pas de solution claire, ou quand vous voulez explorer plusieurs pistes avant de vous engager.
**Quand.** Vous avez une vague idée de ce que vous voulez construire mais n'avez pas encore cristallisé le concept. Ou vous avez un concept mais voulez l'éprouver face à des alternatives.
**Quand.** Vous avez une vague idée de ce que vous voulez construire mais n’avez pas encore cristallisé le concept. Ou vous avez un concept mais voulez l’éprouver face à des alternatives.
Voir [Brainstorming](./brainstorming.md) pour un aperçu plus approfondi du fonctionnement des sessions.
### Recherche (Marché, Domaine, Technique)
**Quoi.** Trois workflows de recherche ciblés qui investiguent différentes dimensions de votre idée. La recherche marché examine les concurrents, les tendances et le sentiment utilisateur. La recherche domaine construit l'expertise métier et la terminologie. La recherche technique évalue la faisabilité, les options d'architecture et les approches d'implémentation.
**Quoi.** Trois workflows de recherche ciblés qui investiguent différentes dimensions de votre idée. La recherche marché examine les concurrents, les tendances et le sentiment utilisateur. La recherche domaine construit l’expertise métier et la terminologie. La recherche technique évalue la faisabilité, les options d’architecture et les approches d’implémentation.
**Pourquoi.** Construire sur des suppositions est le moyen le plus rapide de construire quelque chose dont personne n'a besoin. La recherche ancre votre concept dans la réalité — quels concurrents existent déjà, avec quoi les utilisateurs luttent réellement, ce qui est techniquement faisable, et quelles contraintes spécifiques à l'industrie vous affronterez.
**Pourquoi.** Construire sur des suppositions est le moyen le plus rapide de construire quelque chose dont personne n’a besoin. La recherche ancre votre concept dans la réalité — quels concurrents existent déjà, avec quoi les utilisateurs luttent réellement, ce qui est techniquement faisable, et quelles contraintes spécifiques à l’industrie vous affronterez.
**Quand.** Vous entrez dans un domaine inconnu, vous soupçonnez que des concurrents existent mais ne les avez pas cartographiés, ou votre concept dépend de capacités techniques que vous n'avez pas validées. Lancez-en un, deux ou les trois — chaque workflow de recherche fonctionne de manière autonome.
**Quand.** Vous entrez dans un domaine inconnu, vous soupçonnez que des concurrents existent mais ne les avez pas cartographiés, ou votre concept dépend de capacités techniques que vous n’avez pas validées. Lancez-en un, deux ou les trois — chaque workflow de recherche fonctionne de manière autonome.
### Product Brief[^1]
**Quoi.** Une session de découverte guidée qui produit un résumé exécutif de 1-2 pages de votre concept produit. L'IA agit comme un analyste commercial collaboratif, vous aidant à articuler la vision, le public cible, la proposition de valeur et le périmètre.
**Quoi.** Une session de découverte guidée qui produit un résumé exécutif de 1-2 pages de votre concept produit. L’IA agit comme un analyste commercial collaboratif, vous aidant à articuler la vision, le public cible, la proposition de valeur et le périmètre.
**Pourquoi.** Le product brief est le chemin le plus doux vers la planification. Il capture votre vision stratégique dans un format structuré qui alimente directement la création du PRD. Il fonctionne mieux quand vous avez déjà la conviction à propos de votre concept — vous connaissez le client, le problème et approximativement ce que vous voulez construire. Le brief organise et affine cette réflexion.
**Quand.** Votre concept est relativement clair et vous voulez le documenter efficacement avant de créer un PRD. Vous êtes confiant dans la direction et n'avez pas besoin que vos suppositions soient agressivement remises en question.
**Quand.** Votre concept est relativement clair et vous voulez le documenter efficacement avant de créer un PRD. Vous êtes confiant dans la direction et n’avez pas besoin que vos suppositions soient agressivement remises en question.
### PRFAQ (Working Backwards)
**Quoi.** La méthodologie Working Backwards d'Amazon adaptée en défi interactif. Vous rédigez le communiqué de presse annonçant votre produit fini avant qu'une seule ligne de code n'existe, puis répondez aux questions les plus difficiles que les clients et les parties prenantes poseraient. L'IA agit comme un coach produit implacable mais constructif.
**Quoi.** La méthodologie Working Backwards d’Amazon adaptée en défi interactif. Vous rédigez le communiqué de presse annonçant votre produit fini avant qu’une seule ligne de code n’existe, puis répondez aux questions les plus difficiles que les clients et les parties prenantes poseraient. L’IA agit comme un coach produit implacable mais constructif.
**Pourquoi.** Le PRFAQ est le chemin rigoureux vers la planification. Il force la clarté orientée client en vous obligeant à défendre chaque affirmation. Si vous ne pouvez pas rédiger un communiqué de presse convaincant, le produit n'est pas prêt. Si les réponses de la FAQ client révèlent des lacunes, ce sont des lacunes que vous découvrirez bien plus tard — et plus coûteusement — pendant l'implémentation. Le défi fait remonter les failles de réflexion tôt, quand c'est le moins cher de les corriger.
**Pourquoi.** Le PRFAQ est le chemin rigoureux vers la planification. Il force la clarté orientée client en vous obligeant à défendre chaque affirmation. Si vous ne pouvez pas rédiger un communiqué de presse convaincant, le produit n’est pas prêt. Si les réponses de la FAQ client révèlent des lacunes, ce sont des lacunes que vous découvrirez bien plus tard — et plus coûteusement — pendant l’implémentation. Le défi fait remonter les failles de réflexion tôt, quand c’est le moins cher de les corriger.
**Quand.** Vous voulez que votre concept soit éprouvé avant d'engager des ressources. Vous n'êtes pas sûr que les utilisateurs s'en soucieront réellement. Vous voulez valider que vous pouvez articuler une proposition de valeur claire et défendable. Ou vous voulez simplement la discipline du Working Backwards pour affiner votre réflexion.
**Quand.** Vous voulez que votre concept soit éprouvé avant d’engager des ressources. Vous n’êtes pas sûr que les utilisateurs s’en soucieront réellement. Vous voulez valider que vous pouvez articuler une proposition de valeur claire et défendable. Ou vous voulez simplement la discipline du Working Backwards pour affiner votre réflexion.
## Lequel utiliser ?
## Lequel utiliser ?
| Situation | Outil recommandé |
|-------------------------------------------------------------------------------|--------------------------------------------|
| « J'ai une idée vague, je ne sais pas par où commencer » | Brainstorming |
| « J'ai besoin de comprendre le marché avant de décider » | Recherche |
| « Je sais ce que je veux construire, j'ai juste besoin de le documenter » | Product Brief |
| « Je veux m'assurer que cette idée vaut vraiment la peine d'être construite » | PRFAQ |
| « Je veux explorer, puis valider, puis documenter » | Brainstorming → Recherche → PRFAQ ou Brief |
| « J’ai une idée vague, je ne sais pas par où commencer » | Brainstorming |
| « J’ai besoin de comprendre le marché avant de décider » | Recherche |
| « Je sais ce que je veux construire, j’ai juste besoin de le documenter » | Product Brief |
| « Je veux m’assurer que cette idée vaut vraiment la peine d’être construite » | PRFAQ |
| « Je veux explorer, puis valider, puis documenter » | Brainstorming → Recherche → PRFAQ ou Brief |
Le Product Brief et le PRFAQ produisent tous deux des entrées pour le PRD — choisissez-en un en fonction du niveau de défi que vous souhaitez. Le brief est une découverte collaborative. Le PRFAQ est un défi. Les deux vous mènent à la même destination ; le PRFAQ teste si votre concept mérite d'y arriver.
Le Product Brief et le PRFAQ produisent tous deux des entrées pour le PRD — choisissez-en un en fonction du niveau de défi que vous souhaitez. Le brief est une découverte collaborative. Le PRFAQ est un défi. Les deux vous mènent à la même destination ; le PRFAQ teste si votre concept mérite d’y arriver.
:::tip[Pas sûr ?]
:::tip[Pas sûr ?]
Exécutez `bmad-help` et décrivez votre situation. Il vous recommandera le bon point de départ en fonction de ce que vous avez déjà accompli et de ce que vous essayez de réaliser.
:::
## Que se passe-t-il après l'analyse ?
## Que se passe-t-il après l’analyse ?
Les résultats de l'analyse alimentent directement la Phase 2 (Planification). Le workflow PRD accepte les product briefs, les documents PRFAQ, les conclusions de recherche et les rapports de brainstorming en entrée — il synthétise tout ce que vous avez produit en exigences structurées. Plus vous faites d'analyse, plus votre PRD sera précis.
Les résultats de l’analyse alimentent directement la Phase 2 (Planification). Le workflow PRD accepte les product briefs, les documents PRFAQ, les conclusions de recherche et les rapports de brainstorming en entrée — il synthétise tout ce que vous avez produit en exigences structurées. Plus vous faites d’analyse, plus votre PRD sera précis.
## Glossaire
[^1]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d'un projet ou d'une demande, afin d'aligner rapidement les parties prenantes avant le travail détaillé.
[^1]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.

14
docs/fr/explanation/brainstorming.md
View File

@ -1,27 +1,27 @@
---
title: "Brainstorming"
description: Sessions interactives créatives utilisant plus de 60 techniques d'idéation éprouvées
description: Sessions interactives créatives utilisant plus de 60 techniques d’idéation éprouvées
sidebar:
order: 2
order: 3
---
Libérez votre créativité grâce à une exploration guidée.
## Qu'est-ce que le Brainstorming ?
## Qu’est-ce que le Brainstorming ?
Lancez `bmad-brainstorming` et vous obtenez un facilitateur créatif qui fait émerger vos idées - pas qui les génère pour vous. L'IA agit comme coach et guide, utilisant des techniques éprouvées pour créer les conditions où votre meilleure réflexion émerge.
Lancez `bmad-brainstorming` et vous obtenez un facilitateur créatif qui fait émerger vos idées - pas qui les génère pour vous. L’IA agit comme coach et guide, utilisant des techniques éprouvées pour créer les conditions où votre meilleure réflexion émerge.
**Idéal pour :**
**Idéal pour :**
- Surmonter les blocages créatifs
- Générer des idées de produits ou de fonctionnalités
- Explorer des problèmes sous de nouveaux angles
- Développer des concepts bruts en plans d'action
- Développer des concepts bruts en plans d’action
## Comment ça fonctionne
1. **Configuration** - Définir le sujet, les objectifs, les contraintes
2. **Choisir l'approche** - Choisir vous-même les techniques, obtenir des recommandations de l'IA, aller au hasard, ou suivre un flux progressif
2. **Choisir l’approche** - Choisir vous-même les techniques, obtenir des recommandations de l’IA, aller au hasard, ou suivre un flux progressif
3. **Facilitation** - Travailler à travers les techniques avec des questions approfondies et un coaching collaboratif
4. **Organiser** - Idées regroupées par thèmes et priorisées
5. **Action** - Les meilleures idées reçoivent des prochaines étapes et des indicateurs de succès

68
docs/fr/explanation/checkpoint-preview.md
View File

@ -2,91 +2,91 @@
title: "Checkpoint Preview"
description: Revue assistée par LLM, avec intervention humaine, qui vous guide à travers une modification, de son objectif jusqu’aux détails
sidebar:
order: 7
order: 8
---
`bmad-checkpoint-preview` est un workflow de revue interactif, assisté par LLM, avec intervention humaine. Il vous guide à travers une modification de code — de l'intention et du contexte jusqu'aux détails — afin que vous puissiez prendre une décision éclairée sur la mise en production, la refonte ou l'approfondissement.
`bmad-checkpoint-preview` est un workflow de revue interactif, assisté par LLM, avec intervention humaine. Il vous guide à travers une modification de code — de l’intention et du contexte jusqu’aux détails — afin que vous puissiez prendre une décision éclairée sur la mise en production, la refonte ou l’approfondissement.
![Diagramme du workflow Checkpoint Preview](/diagrams/checkpoint-preview-diagram-fr.webp)
## Le Flux Typique
Vous lancez `bmad-quick-dev`. Il clarifie votre intention, construit une spécification, implémente la modification, et une fois terminé, il ajoute un historique de revue au fichier de spécification et l'ouvre dans votre éditeur. Vous regardez la spec et constatez que la modification a touché 20 fichiers dans plusieurs modules.
Vous lancez `bmad-quick-dev`. Il clarifie votre intention, construit une spécification, implémente la modification, et une fois terminé, il ajoute un historique de revue au fichier de spécification et l’ouvre dans votre éditeur. Vous regardez la spec et constatez que la modification a touché 20 fichiers dans plusieurs modules.
Vous pourriez survoler le diff. Mais 20 fichiers, c'est le moment où le survol commence à échouer — on perd le fil, on rate un lien entre deux modifications éloignées, ou on approuve quelque chose qu'on n'a pas pleinement compris. Alors au lieu de cela, vous dites « checkpoint » et le LLM vous guide à travers la modification.
Vous pourriez survoler le diff. Mais 20 fichiers, c’est le moment où le survol commence à échouer — on perd le fil, on rate un lien entre deux modifications éloignées, ou on approuve quelque chose qu’on n’a pas pleinement compris. Alors au lieu de cela, vous dites « checkpoint » et le LLM vous guide à travers la modification.
Ce passage de relais — de l'implémentation autonome au jugement humain — est le cas d'usage principal. Quick-dev s'exécute longtemps avec une supervision minimale. Checkpoint Preview, c'est là où vous reprenez le volant.
Ce passage de relais — de l’implémentation autonome au jugement humain — est le cas d’usage principal. Quick-dev s’exécute longtemps avec une supervision minimale. Checkpoint Preview, c’est là où vous reprenez le volant.
## Pourquoi
La revue de code a deux modes d'échec. Dans le premier, le réviseur survole le diff, rien ne saute aux yeux, et il approuve. Dans le second, il lit méthodiquement chaque fichier mais perd le fil — il voit les arbres et rate la forêt. Les deux aboutissent au même résultat : la revue n'a pas repéré ce qui comptait.
La revue de code a deux modes d’échec. Dans le premier, le réviseur survole le diff, rien ne saute aux yeux, et il approuve. Dans le second, il lit méthodiquement chaque fichier mais perd le fil — il voit les arbres et rate la forêt. Les deux aboutissent au même résultat : la revue n’a pas repéré ce qui comptait.
Le problème sous-jacent est le séquençage. Un diff brut présente les modifications dans l'ordre des fichiers, ce qui est presque jamais l'ordre qui construit la compréhension. Vous voyez une fonction utilitaire avant de savoir pourquoi elle existe. Vous voyez une modification de schéma avant de comprendre quelle fonctionnalité elle supporte. Le réviseur doit reconstruire l'intention de l'auteur à partir d'indices dispersés, et c'est cette reconstruction qui fait défaut à l'attention.
Le problème sous-jacent est le séquençage. Un diff brut présente les modifications dans l’ordre des fichiers, ce qui est presque jamais l’ordre qui construit la compréhension. Vous voyez une fonction utilitaire avant de savoir pourquoi elle existe. Vous voyez une modification de schéma avant de comprendre quelle fonctionnalité elle supporte. Le réviseur doit reconstruire l’intention de l’auteur à partir d’indices dispersés, et c’est cette reconstruction qui fait défaut à l’attention.
Checkpoint Preview résout ce problème en confiant le travail de reconstruction au LLM. Il lit le diff, la spécification (si elle existe) et la base de code environnante, puis présente la modification dans un ordre conçu pour la compréhension — et non pour `git diff`.
## Comment ça fonctionne
Le workflow comporte cinq étapes. Chaque étape s'appuie sur la précédente, passant progressivement de « qu'est-ce que c'est ? » à « devons-nous publier ça ? »
Le workflow comporte cinq étapes. Chaque étape s’appuie sur la précédente, passant progressivement de « qu’est-ce que c’est ? » à « devons-nous publier ça ? »
### 1. Orientation
Le workflow identifie la modification (à partir d'une PR, d'un commit, d'une branche, d'un fichier de spécification ou de l'état git actuel) et produit un résumé d'intention en une ligne ainsi que des statistiques de surface : fichiers modifiés, modules touchés, lignes de logique, dépassements de boundaries et nouvelles interfaces publiques.
Le workflow identifie la modification (à partir d’une PR, d’un commit, d’une branche, d’un fichier de spécification ou de l’état git actuel) et produit un résumé d’intention en une ligne ainsi que des statistiques de surface : fichiers modifiés, modules touchés, lignes de logique, dépassements de boundaries et nouvelles interfaces publiques.
C'est le moment « est-ce bien ce que je crois ? ». Avant de lire le moindre code, le réviseur confirme qu'il regarde la bonne chose et calibre ses attentes quant à la portée.
C’est le moment « est-ce bien ce que je crois ? ». Avant de lire le moindre code, le réviseur confirme qu’il regarde la bonne chose et calibre ses attentes quant à la portée.
### 2. Visite guidée
La modification est organisée par **préoccupation** — des intentions de conception cohérentes comme « validation des entrées » ou « contrat d'API » — et non par fichier. Chaque préoccupation fait l'objet d'une courte explication du *pourquoi* de cette approche, suivie d'arrêts cliquables `chemin:ligne` que le réviseur peut suivre dans le code.
La modification est organisée par **préoccupation** — des intentions de conception cohérentes comme « validation des entrées » ou « contrat d’API » — et non par fichier. Chaque préoccupation fait l’objet d’une courte explication du *pourquoi* de cette approche, suivie d’arrêts cliquables `chemin:ligne` que le réviseur peut suivre dans le code.
C'est l'étape du jugement de conception. Le réviseur évalue si l'approche est adaptée au système, et non si le code est correct. Les préoccupations sont séquencées de haut en bas : l'intention de plus haut niveau en premier, puis l'implémentation de support. Le réviseur ne rencontre jamais une référence à quelque chose qu'il n'a pas encore vu.
C’est l’étape du jugement de conception. Le réviseur évalue si l’approche est adaptée au système, et non si le code est correct. Les préoccupations sont séquencées de haut en bas : l’intention de plus haut niveau en premier, puis l’implémentation de support. Le réviseur ne rencontre jamais une référence à quelque chose qu’il n’a pas encore vu.
### 3. Passage en revue des détails
Une fois que le réviseur comprend la conception, le workflow met en évidence 2 à 5 endroits où une erreur aurait l’impact le plus important. Ceux-ci sont étiquetés par catégorie de risque — `[auth]`, `[schéma]`, `[facturation]`, `[API publique]`, `[sécurité]`, et d'autres — et ordonnés selon l'impact en cas d'erreur.
Une fois que le réviseur comprend la conception, le workflow met en évidence 2 à 5 endroits où une erreur aurait l’impact le plus important. Ceux-ci sont étiquetés par catégorie de risque — `[auth]`, `[schéma]`, `[facturation]`, `[API publique]`, `[sécurité]`, et d’autres — et ordonnés selon l’impact en cas d’erreur.
Ce n'est pas une chasse aux bugs. Les tests automatisés et la CI gèrent la correction. Le passage en revue des détails active la conscience du risque : « voici les endroits où se tromper coûte le plus cher ». Si le réviseur veut approfondir un domaine spécifique, il peut dire « approfondis [domaine] » pour une re-revue ciblée axée sur la correction.
Ce n’est pas une chasse aux bugs. Les tests automatisés et la CI gèrent la correction. Le passage en revue des détails active la conscience du risque : « voici les endroits où se tromper coûte le plus cher ». Si le réviseur veut approfondir un domaine spécifique, il peut dire « approfondis [domaine] » pour une re-revue ciblée axée sur la correction.
Si la spécification a passé des boucles de revues contradictoires (machine hardening), ces résultats sont également présentés ici — pas les bugs qui ont été corrigés, mais les décisions que la boucle de revue a signalées et dont le réviseur devrait être conscient.
### 4. Tests
Propose 2 à 5 façons d'observer manuellement la modification en action. Pas des commandes de test automatisé — des observations manuelles qui renforcent la confiance au-delà de ce que toute suite de tests peut fournir. Une interaction UI à essayer, une commande CLI à lancer, une requête API à envoyer, avec les résultats attendus pour chacune.
Propose 2 à 5 façons d’observer manuellement la modification en action. Pas des commandes de test automatisé — des observations manuelles qui renforcent la confiance au-delà de ce que toute suite de tests peut fournir. Une interaction UI à essayer, une commande CLI à lancer, une requête API à envoyer, avec les résultats attendus pour chacune.
Si la modification n'a aucun comportement visible par l'utilisateur, il le dit. Pas de travail inventé.
Si la modification n’a aucun comportement visible par l’utilisateur, il le dit. Pas de travail inventé.
### 5. Conclusion
Le réviseur prend la décision : approuver, retravailler ou continuer la discussion. S'il approuve une PR, le workflow peut aider avec `gh pr review --approve`. S'il demande une refonte, il aide à diagnostiquer si le problème vient de l'approche, de la spécification ou de l'implémentation, et aide à rédiger un retour actionnable lié à des emplacements de code spécifiques.
Le réviseur prend la décision : approuver, retravailler ou continuer la discussion. S’il approuve une PR, le workflow peut aider avec `gh pr review --approve`. S’il demande une refonte, il aide à diagnostiquer si le problème vient de l’approche, de la spécification ou de l’implémentation, et aide à rédiger un retour actionnable lié à des emplacements de code spécifiques.
## C'est une conversation, pas un rapport
## C’est une conversation, pas un rapport
Le workflow présente chaque étape comme un point de départ, pas un mot final. Entre les étapes — ou au milieu d'une — vous pouvez parler au LLM, poser des questions, remettre en question son cadrage ou faire appel à d'autres skills pour obtenir une perspective différente :
Le workflow présente chaque étape comme un point de départ, pas un mot final. Entre les étapes — ou au milieu d’une — vous pouvez parler au LLM, poser des questions, remettre en question son cadrage ou faire appel à d’autres skills pour obtenir une perspective différente :
- **« lance l'élicitation avancée sur la gestion des erreurs »** — pousse le LLM à reconsidérer et affiner son analyse d'un domaine spécifique
- **« active le party mode sur la sécurité de cette migration de schéma »** — fait intervenir plusieurs perspectives agentiques dans un débat ciblé
- **« lance la revue de code »** — génère des résultats structurés avec analyse adversariale et cas limites
- **« lance l’élicitation avancée sur la gestion des erreurs »** — pousse le LLM à reconsidérer et affiner son analyse d’un domaine spécifique
- **« active le party mode sur la sécurité de cette migration de schéma »** — fait intervenir plusieurs perspectives agentiques dans un débat ciblé
- **« lance la revue de code »** — génère des résultats structurés avec analyse adversariale et cas limites
Le workflow checkpoint ne vous enferme pas dans un chemin linéaire. Il vous donne de la structure quand vous la souhaitez et s'efface quand vous voulez explorer. Les cinq étapes sont là pour s'assurer que vous voyez le tableau complet, mais la profondeur à laquelle vous allez à chaque étape — et les outils que vous y apportez — est entièrement entre vos mains.
Le workflow checkpoint ne vous enferme pas dans un chemin linéaire. Il vous donne de la structure quand vous la souhaitez et s’efface quand vous voulez explorer. Les cinq étapes sont là pour s’assurer que vous voyez le tableau complet, mais la profondeur à laquelle vous allez à chaque étape — et les outils que vous y apportez — est entièrement entre vos mains.
## L'historique de revue
## L’historique de revue
L'étape de visite guidée fonctionne mieux lorsqu'elle dispose d'un **ordre de revue suggéré** — une liste d'arrêts que l'auteur de la spécification a rédigée pour guider les réviseurs à travers la modification. Lorsqu'une spécification inclut cet ordre, le workflow l'utilise directement.
L’étape de visite guidée fonctionne mieux lorsqu’elle dispose d’un **ordre de revue suggéré** — une liste d’arrêts que l’auteur de la spécification a rédigée pour guider les réviseurs à travers la modification. Lorsqu’une spécification inclut cet ordre, le workflow l’utilise directement.
Lorsqu'aucun historique produit par l'auteur n'existe, le workflow en génère un à partir du diff et du contexte de la base de code. Un historique généré est de qualité inférieure à un historique produit par l'auteur, mais nettement supérieur à la lecture des modifications dans l'ordre des fichiers.
Lorsqu’aucun historique produit par l’auteur n’existe, le workflow en génère un à partir du diff et du contexte de la base de code. Un historique généré est de qualité inférieure à un historique produit par l’auteur, mais nettement supérieur à la lecture des modifications dans l’ordre des fichiers.
## Quand l'utiliser
## Quand l’utiliser
Le scénario principal est le passage de relais depuis `bmad-quick-dev` : l'implémentation est terminée, le fichier de spécification est ouvert dans votre éditeur avec un historique de revue ajouté, et vous devez décider si vous publiez. Dites « checkpoint » et c'est parti.
Le scénario principal est le passage de relais depuis `bmad-quick-dev` : l’implémentation est terminée, le fichier de spécification est ouvert dans votre éditeur avec un historique de revue ajouté, et vous devez décider si vous publiez. Dites « checkpoint » et c’est parti.
Il fonctionne aussi de manière autonome :
Il fonctionne aussi de manière autonome :
- **Revue d'une PR** — surtout celles avec plus de quelques fichiers ou des modifications transversales
- **Prise en main d'une modification** — quand vous devez comprendre ce qui s'est passé sur une branche que vous n'avez pas écrite
- **Revue d’une PR** — surtout celles avec plus de quelques fichiers ou des modifications transversales
- **Prise en main d’une modification** — quand vous devez comprendre ce qui s’est passé sur une branche que vous n’avez pas écrite
- **Revue de sprint** — le workflow peut récupérer les stories marquées `review` dans votre fichier de statut de sprint
Invoquez-le en disant « checkpoint » ou « guide-moi à travers cette modification ». Il fonctionne dans n'importe quel terminal, mais vous en tirerez plus de parti dans un IDE — VS Code, Cursor ou similaire — car le workflow produit des références `chemin:ligne` à chaque étape. Dans un terminal intégré à un IDE, celles-ci sont cliquables, ce qui vous permet de sauter de fichier en fichier en suivant l'historique de revue.
Invoquez-le en disant « checkpoint » ou « guide-moi à travers cette modification ». Il fonctionne dans n’importe quel terminal, mais vous en tirerez plus de parti dans un IDE — VS Code, Cursor ou similaire — car le workflow produit des références `chemin:ligne` à chaque étape. Dans un terminal intégré à un IDE, celles-ci sont cliquables, ce qui vous permet de sauter de fichier en fichier en suivant l’historique de revue.
## Ce que ce n'est pas
## Ce que ce n’est pas
Checkpoint Preview ne remplace pas la revue automatisée. Il ne lance pas de linters, de vérificateurs de types ou de suites de tests. Il n'attribue pas de scores de sévérité et ne produit pas de verdicts pass/échec. C'est un guide de lecture qui aide un humain à appliquer son jugement là où cela compte le plus.
Checkpoint Preview ne remplace pas la revue automatisée. Il ne lance pas de linters, de vérificateurs de types ou de suites de tests. Il n’attribue pas de scores de sévérité et ne produit pas de verdicts pass/échec. C’est un guide de lecture qui aide un humain à appliquer son jugement là où cela compte le plus.

32
docs/fr/explanation/established-projects-faq.md
View File

@ -1,35 +1,35 @@
---
title: "FAQ Projets Existants"
description: Questions courantes sur l'utilisation de la méthode BMad sur des projets existants
description: Questions courantes sur l’utilisation de la méthode BMad sur des projets existants
sidebar:
order: 12
order: 13
---
Réponses rapides aux questions courantes sur l'utilisation de la méthode BMad (BMM) sur des projets existants.
Réponses rapides aux questions courantes sur l’utilisation de la méthode BMad (BMM) sur des projets existants.
## Questions
- [Dois-je d'abord exécuter document-project ?](#dois-je-dabord-exécuter-document-project)
- [Que faire si j'oublie d'exécuter document-project ?](#que-faire-si-joublie-dexécuter-document-project)
- [Puis-je utiliser Quick Dev pour les projets existants ?](#puis-je-utiliser-quick-dev-pour-les-projets-existants)
- [Que faire si mon code existant ne suit pas les bonnes pratiques ?](#que-faire-si-mon-code-existant-ne-suit-pas-les-bonnes-pratiques)
- [Dois-je d’abord exécuter document-project ?](#dois-je-dabord-exécuter-document-project)
- [Que faire si j’oublie d’exécuter document-project ?](#que-faire-si-joublie-dexécuter-document-project)
- [Puis-je utiliser Quick Dev pour les projets existants ?](#puis-je-utiliser-quick-dev-pour-les-projets-existants)
- [Que faire si mon code existant ne suit pas les bonnes pratiques ?](#que-faire-si-mon-code-existant-ne-suit-pas-les-bonnes-pratiques)
### Dois-je d'abord exécuter `document-project` ?
### Dois-je d’abord exécuter `document-project` ?
Hautement recommandé, surtout si :
Hautement recommandé, surtout si :
- Aucune documentation existante
- La documentation est obsolète
- Les agents IA ont besoin de contexte sur le code existant
Vous pouvez l'ignorer si vous disposez d'une documentation complète et à jour incluant `docs/index.md` ou si vous utiliserez d'autres outils ou techniques pour aider à la découverte afin que l'agent puisse construire sur un système existant.
Vous pouvez l’ignorer si vous disposez d’une documentation complète et à jour incluant `docs/index.md` ou si vous utiliserez d’autres outils ou techniques pour aider à la découverte afin que l’agent puisse construire sur un système existant.
### Que faire si j'oublie d'exécuter `document-project` ?
### Que faire si j’oublie d’exécuter `document-project` ?
Ne vous inquiétez pas — vous pouvez le faire à tout moment. Vous pouvez même le faire pendant ou après un projet pour aider à maintenir la documentation à jour.
### Puis-je utiliser Quick Dev pour les projets existants ?
### Puis-je utiliser Quick Dev pour les projets existants ?
Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
- Détecter automatiquement votre pile technologique existante
- Analyser les patterns de code existants
@ -38,13 +38,13 @@ Oui ! Quick Dev fonctionne très bien pour les projets existants. Il va :
Parfait pour les corrections de bugs et les petites fonctionnalités dans des bases de code existantes.
### Que faire si mon code existant ne suit pas les bonnes pratiques ?
### Que faire si mon code existant ne suit pas les bonnes pratiques ?
Quick Dev détecte vos conventions et demande : « Dois-je suivre ces conventions existantes ? » Vous décidez :
Quick Dev détecte vos conventions et demande : « Dois-je suivre ces conventions existantes ? » Vous décidez :
- **Oui** → Maintenir la cohérence avec la base de code actuelle
- **Non** → Établir de nouvelles normes (documenter pourquoi dans la spécification technique)
BMM respecte votre choix — il ne forcera pas la modernisation, mais la proposera.
**Une question sans réponse ici ?** Veuillez [ouvrir un ticket](https://github.com/bmad-code-org/BMAD-METHOD/issues) ou poser votre question sur [Discord](https://discord.gg/gk8jAdXWmj) afin que nous puissions l'ajouter !
**Une question sans réponse ici ?** Veuillez [ouvrir un ticket](https://github.com/bmad-code-org/BMAD-METHOD/issues) ou poser votre question sur [Discord](https://discord.gg/gk8jAdXWmj) afin que nous puissions l’ajouter !

185
docs/fr/explanation/forensic-investigation.md
View File

@ -1,157 +1,156 @@
---
title: "Enquête de code"
description: Comment bmad-investigate traite chaque problème comme une scène d'enquête, classe les preuves et produit un dossier structuré sur lequel les ingénieurs peuvent agir
description: Comment bmad-investigate traite chaque problème comme une scène de crime, classe les preuves et produit un dossier structuré sur lequel les ingénieurs peuvent agir
sidebar:
order: 9
order: 10
---
Vous confiez à `bmad-investigate` un journal de plantage, une trace de pile, ou simplement un « ça marchait avant, plus
maintenant ». Le skill prend le relais avec la discipline d'enquête le temps de l'exécution. Il ne se met pas à
corriger. Il ouvre un dossier d'enquête.
Vous confiez à `bmad-investigate` un journal de plantage, une stack trace, ou simplement un « ça marchait avant, plus
maintenant ». Le skill prend le relais et applique la rigueur d’un enquêteur pendant toute son exécution. Il ne se lance pas dans
la correction. Il ouvre un dossier d’enquête.
Chaque constatation reçoit une note. Chaque hypothèse a un statut. Les fausses pistes sont conservées, pas effacées. Le
livrable est un document qu'un autre ingénieur peut reprendre à froid.
Chaque constatation est classée. Chaque hypothèse a un statut. Les fausses pistes sont conservées, pas effacées. Le
livrable est un document qu’un autre ingénieur peut reprendre à froid.
Cette page explique pourquoi l'enquête est une discipline à part entière, et ce que le skill apporte qu'un workflow de
développement classique n'apporte pas.
Cette page explique pourquoi l’enquête est une discipline à part entière, et ce que le skill apporte de plus qu’un flux de
développement classique.
## Le problème du « débogue, c'est tout »
## Le problème avec « il suffit de déboguer »
Le débogage classique mélange trois activités : examiner les preuves, raisonner sur la cause, et modifier le code pour
Le débogage classique mélange trois activités : examiner les preuves, raisonner sur la cause, et modifier le code pour
tester la théorie. Quand elles sont mélangées, deux modes de défaillance apparaissent.
Le premier est le **verrouillage narratif**[^1]. La première histoire plausible devient la théorie de travail, et chaque
observation est tordue pour la confirmer. Le bug reste non corrigé jusqu'à ce que quelqu'un abandonne et reparte de
zéro. Des heures plus tard.
Le premier est le **verrouillage narratif**[^1]. Le premier scénario plausible devient la théorie de travail, et chaque
observation est déformée pour s’y ajuster. Le bug persiste jusqu’à ce que quelqu’un abandonne et reparte de zéro. Des
heures plus tard.
Le second est l'**amnésie probatoire**. Vous avez tracé quelque chose, l'avez écarté, mais n'avez pas écrit pourquoi.
Deux jours plus tard, avec un regard frais, vous le retracez. Pire encore, un collègue reprend le bug et refait la même
impasse que vous aviez déjà éliminée.
Le second est l’**amnésie des preuves**. Vous avez suivi une piste, l’avez écartée, mais n’avez pas écrit pourquoi. Deux
jours plus tard, avec un regard frais, vous la suivez à nouveau. Pire encore, un collègue reprend le bug et suit
à nouveau la même fausse piste que vous aviez déjà écartée.
La conception du skill est une réponse directe à ces deux modes.
## Classement des preuves
Chaque constatation dans une enquête appartient à l'une de trois catégories.
Chaque constatation dans une enquête appartient à l’une de trois catégories.
- **Confirmé.** Directement observé dans les logs, le code ou les dumps ; cité avec une référence spécifique (un
`chemin:ligne`, un horodatage de log, un hash de commit). Si quelqu'un demande « comment le sais-tu ? », vous pointez
la citation.
- **Déduit.** Découle logiquement de preuves confirmées ; la chaîne de raisonnement est explicite. Si une étape de la
chaîne est fausse, la déduction est fausse, et on peut voir précisément quelle étape.
- **Hypothétique.** Plausible mais non confirmé. Énonce quelle preuve confirmerait ou réfuterait, et déclare d'avance ce
qui le clôturerait. Les hypothèses sont explicitement *non factuelles*.
- **Confirmé.** Directement observée dans les logs, le code ou les dumps ; citée avec une référence spécifique (un
`chemin:ligne`, un horodatage de log, un hash de commit). Si quelqu’un demande « comment le savez-vous ? », vous indiquez
la référence.
- **Déduit.** Découle logiquement de preuves confirmées ; la chaîne de raisonnement est explicite. Si une étape de la
chaîne est fausse, la déduction est fausse, et on peut voir précisément laquelle.
- **Hypothétique.** Plausible mais non confirmé. Précise quelle preuve la confirmerait ou la réfuterait, et indique à
l’avance ce qui permettrait de la clore. Les hypothèses sont explicitement *des suppositions, pas des faits*.
Le classement n'est pas une posture d'humilité. Il rend le dossier lisible. Un lecteur peut parcourir la section
Confirmé pour savoir ce qui est vrai, la section Déduit pour savoir ce qui en découle, et la section Hypothétique pour
savoir ce qui reste ouvert. Confondre les trois est la première raison pour laquelle les enquêtes dérapent.
Le classement n’est pas là par modestie. Il rend le dossier lisible. Un lecteur peut parcourir la section
**Confirmé** pour savoir ce qui est vrai, la section **Déduit** pour savoir ce qui en découle, et la section **Hypothétique** pour
savoir ce qui reste ouvert. Confondre les trois est la raison la plus fréquente pour laquelle les enquêtes dérapent.
## Tête de pont d'abord
## Point d’ancrage d’abord
L'enquête ne part jamais d'une théorie. Elle part d'une seule preuve confirmée et étend la zone à partir de là. Cette
preuve peut être un message d'erreur précis, une trame de pile, ou une entrée de log horodatée.
L’enquête ne part jamais d’une théorie. Elle part d’une seule preuve confirmée et s’étend à partir de là. Cette
preuve peut être un message d’erreur précis, une stack trace, ou une entrée de log horodatée.
C'est l'inverse de la manière dont les enquêtes se déroulent souvent : quelqu'un a une intuition, construit une théorie,
puis cherche les preuves qui la soutiennent. L'intuition peut être correcte ; la *méthode* est fragile parce qu'elle
fait du biais de confirmation[^2] le comportement par défaut.
C’est l’inverse du déroulement habituel des enquêtes : quelqu’un a une intuition, construit une théorie,
puis cherche les preuves qui la soutiennent. L’intuition peut être correcte ; la *méthode* est fragile parce qu’elle
transforme le biais de confirmation[^2] en comportement par défaut.
Une tête de pont est un fait sur lequel vous pouvez revenir quand le raisonnement devient flou. Si une déduction vous
emmène quelque part d'étrange, vous pouvez remonter jusqu'à la tête de pont et essayer une autre branche. Sans elle,
vous ne savez pas quelle étape annuler.
Un point d’ancrage est un fait sur lequel vous pouvez revenir quand le raisonnement devient flou. Si une déduction vous
mène à une conclusion inattendue, vous pouvez remonter au point d’ancrage et essayer une autre branche. Sans point
d’ancrage, vous ne savez pas quelle étape annuler.
Quand les preuves sont rares, le skill le dit et bascule en exploration guidée par hypothèses : formuler des hypothèses
Quand les preuves sont rares, le skill le signale et bascule en exploration guidée par hypothèses : formuler des hypothèses
à partir de ce qui est disponible, identifier ce qui testerait chacune, présenter une liste priorisée de données à
collecter. L'absence de preuve est elle-même une constatation.
collecter. L’absence de preuve est elle-même un constat.
## Discipline des hypothèses
Les hypothèses ne sont jamais supprimées du dossier. Quand une preuve en confirme ou en réfute une, son champ **Statut**
passe d'Ouvert à Confirmé ou Réfuté, et une **Résolution** explique quelle preuve a tranché.
passe d’Ouvert à Confirmé ou Réfuté, et une **Résolution** explique quelle preuve a tranché.
Cette règle a un coût réel : les dossiers grossissent. Le bénéfice est réel aussi. L'historique complet du raisonnement
Cette règle a un coût réel : les dossiers grossissent. Le bénéfice est tout aussi réel. L’historique complet du raisonnement
fait partie du livrable. Six mois plus tard, quand un bug similaire surgit, le prochain enquêteur peut lire le dossier
original et voir quelles pistes ont déjà été éliminées et pourquoi. Sans cet historique, chaque nouvel enquêteur refait
les mêmes impasses.
original et voir quelles pistes ont déjà été éliminées et pourquoi. Sans cet historique, chaque nouvel enquêteur reprend
les mêmes fausses pistes.
Cela discipline aussi l'enquêteur du présent. Si vous ne pouvez pas supprimer une hypothèse fausse, vous devez la
réfuter avec une preuve citée. L'abandonner discrètement quand elle devient gênante n'est plus une option.
Cela discipline aussi l’enquêteur sur le moment. Si vous ne pouvez pas supprimer une hypothèse fausse, vous devez la
réfuter avec une preuve citée. L’abandonner discrètement quand elle devient gênante n’est plus une option.
## Remettre en question la prémisse
La description du problème par l'utilisateur est une hypothèse, pas un fait. « Le cache est cassé » est quelque chose
que l'utilisateur *croit*. Avant que le skill ne construise une enquête autour, les affirmations techniques sont
vérifiées de manière indépendante. Si la preuve contredit la prémisse, le rapport le dit directement.
La description du problème par l’utilisateur est une hypothèse, pas un fait. « Le cache est cassé » est ce
que l’utilisateur *croit*. Avant que le skill ne construise une enquête autour de cette prémisse, les affirmations
techniques sont vérifiées de manière indépendante. Si la preuve contredit la prémisse, le rapport le signale sans détour.
C'est l'instinct de l'enquêteur : le récit du témoin est une donnée, pas la vérité. Parfois le bug rapporté est réel
mais mal étiqueté. Parfois le symptôme décrit est en aval d'une cause différente. Les enquêtes qui prennent la prémisse
pour argent comptant diagnostiquent le mauvais défaut, et le bug revient sous une forme légèrement différente.
C’est l’instinct de l’enquêteur : le récit du témoin est une donnée, pas la vérité. Parfois le bug rapporté est réel
mais mal étiqueté. Parfois le symptôme décrit est en aval d’une cause différente. Les enquêtes qui prennent la prémisse
pour argent comptant diagnostiquent le mauvais problème, et le bug revient sous une forme légèrement différente.
## Une marche calibrée
## Une approche calibrée
Le skill est une seule procédure, pas deux modes. Il calibre la part d'investigation de défaut versus la part
d'exploration de zone que l'entrée demande, sur une échelle continue.
Le skill est une seule procédure, pas deux modes. Il ajuste en continu l’équilibre entre la recherche du défaut et l’exploration du code
environnant, selon ce que le cas requiert.
Un cas piloté par symptôme (un ticket, un plantage, un message d'erreur, un « ça marchait avant ») penche vers le suivi
d'hypothèses, la reconstruction de la chronologie et une direction de correction. Un cas sans symptôme (comprendre un
Un cas orienté symptôme (un ticket, un plantage, un message d’erreur, un « ça marchait avant ») penche vers le suivi
d’hypothèses, la reconstruction de la chronologie et une piste de correction. Un cas sans symptôme (comprendre un
module avant de le toucher, évaluer la réutilisabilité, bâtir un modèle mental) penche vers la cartographie
entrées/sorties, le filtrage du flux de contrôle et un plan de vérification. La plupart des cas réels se situent quelque
part entre les deux, et le dossier reflète l'équilibre que les preuves ont exigé.
part entre les deux, et le dossier reflète l’équilibre que les preuves ont exigé.
La discipline est la même quel que soit l'endroit de l'échelle où se situe un cas : tête de pont d'abord, classement
des preuves, suivi des hypothèses, jamais effacer. La sortie est toujours
`{implementation_artifacts}/investigations/{slug}-investigation.md`, avec les sections qui ne s'appliquent pas à un cas
laissées vides ou omises.
La discipline est la même quel que soit le positionnement du cas sur l’échelle : point d’ancrage d’abord, classement
des preuves, suivi des hypothèses, rien n’est jamais effacé. La sortie est toujours
`{implementation_artifacts}/investigations/{slug}-investigation.md`, les sections non
pertinentes étant laissées vides ou omises.
Quand un bug profond exige de comprendre un sous-système plus large, la procédure intègre en ligne les techniques de
Quand un bug profond exige de comprendre un sous-système plus large, la procédure intègre directement les techniques de
cartographie entrées/sorties, de filtrage du flux de contrôle, de raisonnement à rebours depuis les sorties et de
traçage des frontières inter-composants[^3]. Le modèle de la zone atterrit dans le même dossier. Pas de changement de
traçage des frontières inter-composants[^3]. La modélisation de la zone explorée figure dans le même dossier. Pas de changement de
mode.
## La méthodologie vit dans le skill
## La méthodologie réside dans le skill
La discipline d'enquête est une propriété du skill lui-même. Quiconque invoque `bmad-investigate` adopte la méthodologie
et le style de communication pour l'exécution : précision clinique, langage centré sur la preuve, pas de prudence
inutile, présentation en dossier de cas. Quand le skill se termine, l'appelant retrouve sa voix d'avant. Pas de
changement de persona, juste un déplacement de ton issu des principes du skill.
La discipline d’enquête est une propriété du skill lui-même. Quiconque invoque `bmad-investigate` adopte la méthodologie
et le style de communication pendant l’exécution : précision clinique, langage centré sur la preuve, pas de prudence
inutile, structuration en dossier d’enquête. Quand le skill se termine, l’appelant retrouve sa voix habituelle. Pas de
changement de persona, juste un ajustement de ton dicté par les principes du skill.
Cela compte parce que l'enquête et l'implémentation récompensent des instincts différents. Les enquêteurs sont lents et
précis. Les implémenteurs sont rapides et confiants. Le même cerveau faisant les deux dans une seule session finit par
mal faire les deux. Le skill délimite la posture d'enquête en ligne, sans changement de contexte vers une identité
séparée.
C’est important car l’enquête et l’implémentation sollicitent des réflexes différents. Les enquêteurs sont lents et
précis. Les développeurs sont rapides et confiants. Essayer de faire les deux dans une même session finit
généralement par mal faire l’un et l’autre. Le skill délimite la posture d’enquête directement dans le flux de travail, sans basculer dans une
identité distincte.
## Ce que vous obtenez
Un fichier d'enquête achevé :
Un dossier d’enquête complet :
- Sépare les constatations Confirmées (avec citations) des Déductions et des Hypothèses
- Préserve toutes les hypothèses jamais formulées, avec leur Statut final et leur Résolution
- Sépare les constatations **Confirmées** (avec citations) des **Déductions** et des **Hypothèses**
- Préserve l’intégralité des hypothèses formulées, avec leur Statut final et leur Résolution
- Reconstruit une chronologie des événements à partir de plusieurs sources de preuves
- Identifie les lacunes de données et ce qu'elles résoudraient
- Fournit des conclusions actionnables ancrées dans les preuves
- Identifie les lacunes de données et ce qu’elles permettraient de résoudre
- Fournit des conclusions exploitables ancrées dans les preuves
- Inclut un plan de reproduction quand une cause racine est identifiée
- Maintient un backlog d'enquête de pistes encore à explorer
- Maintient un backlog des pistes restant à explorer
Donnez-le à un ingénieur qui n'était pas là, et il comprend ce qui s'est passé, ce qui est connu, et ce qui reste
incertain. C'est la barre.
Transmettez-le à un ingénieur qui n’était pas là, et il comprendra ce qui s’est passé, ce qui est connu, et ce qui reste
incertain. C’est le standard visé.
## L'idée plus large
## La vision d’ensemble
La plupart du « débogage par IA » d'aujourd'hui mélange preuves, raisonnement et changements de code en un seul flux de
texte plausible. Le signal est difficile à trouver, les impasses se répètent, et le dossier, s'il en existe un, est un
journal de chat que personne ne veut lire.
La plupart des approches de « débogage par IA » actuelles mêlent preuves, raisonnement et changements de code en un seul
flux de texte plausible. Le signal est difficile à trouver, les impasses se répètent, et le dossier, s’il en existe un, est
un historique de conversation que personne ne veut lire.
`bmad-investigate` traite l'enquête comme une discipline avec son propre livrable. La preuve a une note. Les hypothèses
ont un statut. Les fausses pistes sont documentées, pas effacées. Le dossier survit à la session.
`bmad-investigate` traite l’enquête comme une discipline avec son propre livrable. Chaque preuve est classée. Les
hypothèses ont un statut. Les fausses pistes sont documentées, pas effacées. Le dossier survit à la session.
Quand le prochain bug ressemblant à un que vous avez déjà vu apparaîtra, vous aurez un point de départ qui ne sera pas
une invite vide.
Quand un bug similaire réapparaîtra, vous aurez un point de départ concret, pas un prompt vide.
## Glossaire
[^1]: **Verrouillage narratif** : phénomène cognitif par lequel un raisonnement adopte la première explication plausible
et l'enrichit progressivement, devenant de plus en plus difficile à abandonner même face à des preuves contraires.
[^2]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui
[^1]: **Verrouillage narratif** : phénomène cognitif par lequel un raisonnement adopte la première explication plausible
et l’enrichit progressivement, devenant de plus en plus difficile à abandonner même face à des preuves contraires.
[^2]: **Biais de confirmation** : tendance cognitive à rechercher, interpréter et favoriser les informations qui
confirment des croyances préexistantes, tout en ignorant ou minimisant celles qui les contredisent.
[^3]: **Passage de frontière** : transition entre deux zones d'exécution distinctes (langage, processus, machine,
client/serveur, code/configuration). Les frontières concentrent les bugs car chaque côté suppose que l'autre s'est
[^3]: **Passage de frontière** : transition entre deux zones d’exécution distinctes (langage, processus, machine,
client/serveur, code/configuration). Les frontières concentrent les bugs car chaque côté suppose que l’autre s’est
comporté comme documenté.

94
docs/fr/explanation/named-agents.md Normal file
View File

@ -0,0 +1,94 @@
---
title: "Agents nommés"
description: Pourquoi les agents BMad ont des noms, des personas et des options de personnalisation — et ce que cela permet par rapport aux alternatives basées sur des menus ou des prompts
sidebar:
order: 1
---
Vous dites « Hey Mary, brainstormons » et Mary s’active. Elle vous salue par votre nom, dans la langue que vous avez configurée, avec son persona distinctif. Elle vous rappelle que `bmad-help` est toujours disponible. Puis elle saute le menu et se lance directement dans le brainstorming — parce que votre intention était claire.
Cette page explique ce qui se passe réellement et pourquoi BMad est conçu ainsi.
## Le tabouret à trois pieds
Le modèle d’agent de BMad repose sur trois primitives qui s’articulent :
| Primitive | Ce qu’elle apporte | Où elle se trouve |
|----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|
| **Skill** | Capacité — une chose distincte que l’assistant peut faire (brainstormer, rédiger un PRD, implémenter une story) | `.claude/skills/{skill-name}/SKILL.md` (ou l’équivalent de votre IDE) |
| **Agent nommé** | Continuité du persona — une identité reconnaissable qui englobe un menu de skills associés avec une voix, des principes et des repères visuels cohérents | Skills dont le répertoire commence par `bmad-agent-*` |
| **Personnalisation** | Rendre le système vôtre — des overrides qui remodèlent le comportement d’un agent, ajoutent des intégrations MCP, remplacent des templates, intègrent les conventions de l’organisation | `_bmad/custom/{skill-name}.toml` (overrides d’équipe, versionnés dans git) et `.user.toml` (personnel, ignoré par git) |
Retirez l’un des pieds et l’expérience s’effondre :
- Skills sans agents → des listes de capacités que l’utilisateur doit parcourir par nom ou par code
- Agents sans skills → des personas sans rien à faire
- Pas de personnalisation → chaque utilisateur reçoit le même comportement par défaut, obligeant à forker pour tout besoin spécifique à l’organisation
## Ce que les agents nommés vous apportent
BMad embarque six agents nommés, chacun ancré à une phase de la méthode BMad :
| Agent | Phase | Module |
|------------------------------------|----------------|-------------------------------------------------------------------------------------------------------------------------|
| 📊 **Mary**, Analyste d’affaires | Analyse | étude de marché, brainstorming, product briefs, PRFAQs |
| 📚 **Paige**, Rédactrice technique | Analyse | documentation de projet, diagrammes, validation de docs |
| 📋 **John**, Chef de produit | Planification | création de PRD, décomposition epic/story, vérification de la préparation à l’implémentation |
| 🎨 **Sally**, Designer UX | Planification | spécifications de design UX |
| 🏗️ **Winston**, Architecte système | Solutioning | architecture technique, vérifications d’alignement |
| 💻 **Amelia**, Ingénieure senior | Implémentation | exécution de stories, quick-dev, revue de code, planification de sprint, [enquête de code](./forensic-investigation.md) |
Chacun possède une identité codée en dur (nom, titre, domaine) et une couche personnalisable (rôle, principes, style de communication, icône, menu). Vous pouvez réécrire les principes de Mary ou ajouter des éléments de menu ; vous ne pouvez pas la renommer — c’est délibéré. La reconnaissance de marque persiste après personnalisation pour que « hey Mary » active toujours l’analyste, indépendamment de la façon dont une équipe a façonné son comportement.
## Le flux d’activation
Quand vous invoquez un agent nommé, huit étapes s’exécutent dans l’ordre :
1. **Résoudre le bloc agent** — fusionner le `customize.toml` livré avec les overrides d’équipe et personnels, via un résolveur Python utilisant `tomllib` de la bibliothèque standard
2. **Exécuter les étapes préliminaires** — tout comportement préalablement configuré par l’équipe
3. **Adopter le persona** — identité codée en dur ainsi que rôle personnalisé, style de communication, principes
4. **Charger les faits persistants** — règles d’organisation, notes de conformité, éventuellement des fichiers chargés via un préfixe `file:` (ex. `file:{project-root}/docs/project-context.md`)
5. **Charger la configuration** — nom d’utilisateur, langue de communication, langue de sortie, chemins des artefacts
6. **Saluer** — personnalisé, dans la langue configurée, avec le préfixe emoji de l’agent pour identifier d’un coup d’œil qui parle
7. **Exécuter les étapes de finalisation** — toute configuration post-salutation que l’équipe a définie
8. **Aiguiller ou présenter le menu** — si votre message d’ouverture correspond à un élément de menu, aller directement ; sinon afficher le menu et attendre une saisie
L’étape 8, c’est là que la magie opère. « Hey Mary, brainstormons » évite l’affichage du menu parce que `bmad-brainstorming` correspond évidemment à `BP` dans le menu de Mary. Si vous dites quelque chose d’ambigu, elle demande une fois, brièvement, sans en faire un rituel de confirmation. Si rien ne correspond, elle poursuit la conversation normalement.
## Pourquoi pas simplement un menu ?
Les menus obligent l’utilisateur à aller chercher l’outil. Vous devez retenir que le brainstorming se trouve sous le code `BP` chez l’agent analyste, pas chez l’agent PM, et savoir quel persona possède quelles capacités. C’est une charge cognitive que l’outil vous fait porter.
Les agents nommés inversent la logique. Vous dites ce que vous voulez, à qui, avec les mots qui vous semblent naturels. L’agent sait qui il est et ce qu’il fait. Quand votre intention est suffisamment claire, il agit simplement.
Le menu reste disponible comme solution de secours — affiché quand vous explorez, ignoré quand ce n’est pas le cas.
## Pourquoi pas simplement un prompt libre ?
Les prompts libres supposent que vous connaissez les mots magiques. « Aide-moi à brainstormer » pourrait fonctionner, mais « explorons mon idée de SaaS » pourrait ne pas fonctionner, et les résultats dépendent de la façon dont vous avez formulé la demande. Vous devenez responsable de l’ingénierie du prompt.
Les agents nommés ajoutent de la structure sans restreindre la liberté. Le persona reste cohérent, les capacités sont découvrables, et `bmad-help` est toujours à portée de commande. Vous n’avez pas à deviner ce que l’agent peut faire, et vous n’avez pas besoin d’un manuel pour l’utiliser non plus.
## La personnalisation comme principe fondamental
Le modèle de personnalisation est ce qui permet à tout cela de passer à l’échelle au-delà d’un seul développeur.
Chaque agent embarque un fichier `customize.toml` avec des valeurs par défaut judicieuses. Les équipes versionnent des overrides dans `_bmad/custom/bmad-agent-{role}.toml`. Les individus peuvent superposer des préférences personnelles dans `.user.toml` (ignoré par git). Le résolveur fusionne les trois couches à l’activation avec des règles structurelles prévisibles.
La plupart des utilisateurs ne rédigent jamais ces fichiers à la main. Le skill `bmad-customize` guide le choix de la cible, la sélection du périmètre agent vs workflow, la rédaction de l’override et la vérification de la fusion — pour que la surface de personnalisation reste accessible à quiconque comprend son intention, pas seulement à ceux qui maîtrisent le TOML.
Exemple concret : une équipe versionne dans git un seul fichier demandant à Amelia d’utiliser systématiquement l’outil MCP Context7 pour la documentation des bibliothèques et de se rabattre sur Linear quand une story n’est pas dans la liste locale des epics. Chaque workflow de développement qu’Amelia lance (dev-story, quick-dev, create-story, code-review) hérite de ce comportement, sans modification du code ni duplication par workflow.
Il existe aussi une seconde surface de personnalisation pour les préoccupations *transversales* : la configuration centrale `_bmad/config.toml` et `_bmad/config.user.toml` (tous deux gérés par l’installateur, reconstruits à partir du `module.yaml` de chaque module) plus `_bmad/custom/config.toml` (équipe, versionné dans git) et `_bmad/custom/config.user.toml` (personnel, ignoré par git) pour les overrides. C’est là que se trouve le **registre des agents** — les descripteurs légers que les consommateurs du registre comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation` lisent pour savoir qui est disponible et comment l’incarner. Redéfinissez l’image d’un agent pour toute l’organisation avec un override d’équipe ; ajoutez des personnages fictifs (Kirk, Spock, un persona expert du domaine) comme expériences personnelles via l’override `.user.toml` — sans toucher aucun dossier de skill. Le fichier par skill façonne la façon dont Mary *se comporte* quand elle s’active ; la configuration centrale façonne la façon dont les autres skills *la perçoivent* quand ils consultent le registre.
Pour la surface de personnalisation complète et des exemples concrets, consultez :
- [Comment personnaliser BMad](../how-to/customize-bmad.md) — la référence sur ce qui est personnalisable et comment fonctionne la fusion
- [Comment étendre BMad pour votre organisation](../how-to/expand-bmad-for-your-org.md) — six recettes pratiques couvrant les règles globales des agents, les conventions de workflow, la publication externe, les remplacements de templates et la personnalisation du registre des agents
- Skill `bmad-customize` — l’assistant de rédaction guidée qui transforme une intention en fichier d’override correctement placé et vérifié
## L’idée plus grande
La plupart des assistants IA aujourd’hui sont soit des menus, soit des prompts, et les deux déplacent la charge cognitive vers l’utilisateur. Les agents nommés associés à des skills personnalisables vous permettent de parler à un coéquipier qui connaît déjà le travail, et laissent votre organisation façonner ce coéquipier sans forker.
La prochaine fois que vous tapez « Hey Mary, brainstormons » et qu’elle se met directement au travail, remarquez ce qui ne s’est pas produit. Il n’y a eu ni commande slash, ni menu à parcourir, ni rappel maladroit de ce qu’elle peut faire. Cette absence, c’est le design.

40
docs/fr/explanation/party-mode.md
View File

@ -2,18 +2,18 @@
title: "Party Mode"
description: Collaboration multi-agents - regroupez tous vos agents IA dans une seule conversation
sidebar:
order: 10
order: 11
---
Regroupez tous vos agents IA dans une seule conversation.
## Qu'est-ce que le Party Mode ?
## Qu’est-ce que le Party Mode ?
Lancez `bmad-party-mode` et vous avez toute votre équipe IA dans une même pièce - PM, Architecte, Développeur, Designer UX, selon vos besoins. BMad Master orchestre, en sélectionnant les agents pertinents à chaque message. Les agents répondent en personnage, sont en accord ou désaccord, et construisent sur les idées des autres.
Lancez `bmad-party-mode` et vous avez toute votre équipe IA dans une même pièce - PM, Architecte, Développeur, Designer UX, selon vos besoins. Le Party Mode orchestre la discussion en sélectionnant, à chaque message, les agents pertinents parmi ceux installés. Les agents répondent en personnage, sont en accord ou désaccord, et construisent sur les idées des autres.
La conversation continue aussi longtemps que vous le souhaitez. Posez des questions de suivi, remettez en question les réponses, redirigez la discussion - c'est un véritable échange avec vos agents jusqu'à ce que vous ayez terminé.
La conversation continue aussi longtemps que vous le souhaitez. Posez des questions de suivi, remettez en question les réponses, redirigez la discussion - c’est un véritable échange avec vos agents jusqu’à ce que vous ayez terminé.
**Idéal pour :**
**Idéal pour**
- Les grandes décisions avec des compromis
- Les sessions de brainstorming
@ -24,35 +24,35 @@ La conversation continue aussi longtemps que vous le souhaitez. Posez des questi
### Remettre en question une mauvaise architecture
**Vous :** « Ok l'équipe, notre dernier sprint a été un désastre. Le service d'authentification est tombé trois fois. Qui a cafouillé ? »
**Vous :** « Ok l’équipe, notre dernier sprint a été un désastre. Le service d’authentification est tombé trois fois. Qui a cafouillé ? »
**Architecte :** « Le design était solide - authentification distribuée avec des fallbacks appropriés. Si l'implémentation a dévié des specs... »
**Architecte :** « Le design était solide - authentification distribuée avec des fallbacks appropriés. Si l’implémentation a dévié des specs... »
**Développeur :** « J'ai suivi le document d'architecture à la lettre. Les specs ne prenaient pas en compte les race conditions lors de l'invalidation de sessions concurrentes. »
**Développeur :** « J’ai suivi le document d’architecture à la lettre. Les specs ne prenaient pas en compte les race conditions lors de l’invalidation de sessions concurrentes. »
**PM :** « Vous avez tous les deux raté le vrai problème - nous n'avons pas validé les exigences de gestion des sessions dans le PRD. C'est de ma faute de ne pas l'avoir repéré. »
**PM :** « Vous avez tous les deux raté le vrai problème - nous n’avons pas validé les exigences de gestion des sessions dans le PRD. C’est de ma faute de ne pas l’avoir repéré. »
**TEA :** « Et j'aurais dû le repérer dans les tests d'intégration. Les scénarios de test ne couvraient pas l'invalidation concurrente. »
**TEA :** « Et j’aurais dû le repérer dans les tests d’intégration. Les scénarios de test ne couvraient pas l’invalidation concurrente. »
### Brainstorming créatif
**Vous :** « Comment rendre l'onboarding magique au lieu d'ennuyeux ? »
**Vous :** « Comment rendre l’onboarding magique au lieu d’ennuyeux ? »
**Designer UX :** « Commençons par la divulgation progressive - révélons les fonctionnalités au fur et à mesure que les utilisateurs en ont besoin, pas d'un coup dans un tutoriel. »
**Designer UX :** « Commençons par la divulgation progressive - révélons les fonctionnalités au fur et à mesure que les utilisateurs en ont besoin, pas d’un coup dans un tutoriel. »
**Storyteller :** « Et si l'onboarding était une histoire ? Chaque étape révèle le parcours d'un personnage - l'utilisateur EST le héros. »
**Storyteller :** « Et si l’onboarding était une histoire ? Chaque étape révèle le parcours d’un personnage - l’utilisateur EST le héros. »
**Game Designer :** « En partant de là - et si la première "quête" consistait à résoudre un vrai problème utilisateur ? Ils apprennent en faisant quelque chose d'utile. »
**Game Designer :** « En partant de là - et si la première « quête » consistait à résoudre un vrai problème utilisateur ? Ils apprennent en faisant quelque chose d’utile. »
### Décision technique
**Vous :** « Monolithe ou microservices pour le MVP[^1] ? »
**Vous :** « Monolithe ou microservices pour le MVP[^1] ? »
**Architecte :** « Commencez en monolithe. Les microservices ajoutent une complexité dont vous n'avez pas besoin à 1000 utilisateurs. »
**Architecte :** « Commencez en monolithe. Les microservices ajoutent une complexité dont vous n’avez pas besoin à 1 000 utilisateurs. »
**PM :** « D'accord. Le time-to-market[^2] compte plus que la scalabilité théorique. »
**PM :** « D’accord. Le time-to-market[^2] compte plus que la scalabilité théorique. »
**Développeur :** « Monolithe avec des frontières de modules claires. On pourra extraire des services plus tard si nécessaire. »
**Développeur :** « Monolithe avec des frontières de modules claires. On pourra extraire des services plus tard si nécessaire. »
:::tip[Meilleures décisions]
De meilleures décisions grâce à des perspectives diverses. Bienvenue dans le party mode.
@ -60,5 +60,5 @@ De meilleures décisions grâce à des perspectives diverses. Bienvenue dans le
## Glossaire
[^1]: MVP (Minimum Viable Product) : version minimale d'un produit contenant juste assez de fonctionnalités pour être utilisée par des utilisateurs précoces et valider les hypothèses de marché avant d'investir dans un développement plus complet.
[^2]: Time-to-market : délai nécessaire pour concevoir, développer et lancer un produit sur le marché. Plus ce délai est court, plus l'entreprise peut prendre de l'avance sur ses concurrents.
[^1]: MVP (Minimum Viable Product) : version minimale d’un produit contenant juste assez de fonctionnalités pour être utilisée par des utilisateurs précoces et valider les hypothèses de marché avant d’investir dans un développement plus complet.
[^2]: Time-to-market : délai nécessaire pour concevoir, développer et lancer un produit sur le marché. Plus ce délai est court, plus l’entreprise peut prendre de l’avance sur ses concurrents.

56
docs/fr/explanation/preventing-agent-conflicts.md
View File

@ -1,48 +1,48 @@
---
title: "Prévention des conflits entre agents"
description: Comment l'architecture empêche les conflits lorsque plusieurs agents implémentent un système
description: Comment l’architecture empêche les conflits lorsque plusieurs agents implémentent un système
sidebar:
order: 5
order: 6
---
Lorsque plusieurs agents IA implémentent différentes parties d'un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d'architecture prévient cela en établissant des standards partagés.
Lorsque plusieurs agents IA implémentent différentes parties d’un système, ils peuvent prendre des décisions techniques contradictoires. La documentation d’architecture prévient cela en établissant des standards partagés.
## Types de conflits courants
### Conflits de style d'API
### Conflits de style d’API
Sans architecture :
- L'agent A utilise REST avec `/users/{id}`
- L'agent B utilise des mutations GraphQL
- Résultat : Patterns d'API incohérents, consommateurs confus
- L’agent A utilise REST avec `/users/{id}`
- L’agent B utilise des mutations GraphQL
- Résultat : Patterns d’API incohérents, consommateurs confus
Avec architecture :
- L'ADR[^1] spécifie : « Utiliser GraphQL pour toute communication client-serveur »
- L’ADR[^1] spécifie : « Utiliser GraphQL pour toute communication client-serveur »
- Tous les agents suivent le même pattern
### Conflits de conception de base de données
Sans architecture :
- L'agent A utilise des noms de colonnes en snake_case
- L'agent B utilise des noms de colonnes en camelCase
- Résultat : Schéma incohérent, requêtes illisibles
- L’agent A utilise des noms de colonnes en snake_case
- L’agent B utilise des noms de colonnes en camelCase
- Résultat : Schéma incohérent, requêtes illisibles
Avec architecture :
- Un document de standards spécifie les conventions de nommage
- Tous les agents suivent les mêmes patterns
### Conflits de gestion d'état
### Conflits de gestion d’état
Sans architecture :
- L'agent A utilise Redux pour l'état global
- L'agent B utilise React Context
- Résultat : Multiples approches de gestion d'état, complexité
- L’agent A utilise Redux pour l’état global
- L’agent B utilise React Context
- Résultat : Multiples approches de gestion d’état, complexité
Avec architecture :
- L'ADR spécifie l'approche de gestion d'état
- L’ADR spécifie l’approche de gestion d’état
- Tous les agents implémentent de manière cohérente
## Comment l'architecture prévient les conflits
## Comment l’architecture prévient les conflits
### 1. Décisions explicites via les ADR[^1]
@ -55,21 +55,21 @@ Chaque choix technologique significatif est documenté avec :
### 2. Guidance spécifique aux FR/NFR[^2]
L'architecture associe chaque exigence fonctionnelle à une approche technique :
- FR-001 : Gestion des utilisateurs → Mutations GraphQL
- FR-002 : Application mobile → Requêtes optimisées
L’architecture associe chaque exigence fonctionnelle à une approche technique :
- FR-001 : Gestion des utilisateurs → Mutations GraphQL
- FR-002 : Application mobile → Requêtes optimisées
### 3. Standards et conventions
Documentation explicite de :
- La structure des répertoires
- Les conventions de nommage
- L'organisation du code
- L’organisation du code
- Les patterns de test
## L'architecture comme contexte partagé
## L’architecture comme contexte partagé
Considérez l'architecture comme le contexte partagé que tous les agents lisent avant d'implémenter :
Considérez l’architecture comme le contexte partagé que tous les agents lisent avant d’implémenter :
```text
PRD : "Que construire"
@ -88,18 +88,18 @@ Résultat : Implémentation cohérente
Décisions courantes qui préviennent les conflits :
| Sujet | Exemple de décision |
| ---------------- | -------------------------------------------- |
| Style d'API | GraphQL vs REST vs gRPC |
|------------------|----------------------------------------------|
| Style d’API | GraphQL vs REST vs gRPC |
| Base de données | PostgreSQL vs MongoDB |
| Authentification | JWT vs Sessions |
| Gestion d'état | Redux vs Context vs Zustand |
| Gestion d’état | Redux vs Context vs Zustand |
| Styling | CSS Modules vs Tailwind vs Styled Components |
| Tests | Jest + Playwright vs Vitest + Cypress |
## Anti-patterns à éviter
:::caution[Erreurs courantes]
- **Décisions implicites** — « On décidera du style d'API au fur et à mesure » mène à l'incohérence
- **Décisions implicites** — « On décidera du style d’API au fur et à mesure » mène à l’incohérence
- **Sur-documentation** — Documenter chaque choix mineur cause une paralysie analytique
- **Architecture obsolète** — Les documents écrits une fois et jamais mis à jour poussent les agents à suivre des patterns dépassés
:::
@ -107,7 +107,7 @@ Décisions courantes qui préviennent les conflits :
:::tip[Approche correcte]
- Documenter les décisions qui traversent les frontières des epics
- Se concentrer sur les zones sujettes aux conflits
- Mettre à jour l'architecture au fur et à mesure des apprentissages
- Mettre à jour l’architecture au fur et à mesure des apprentissages
- Utiliser `bmad-correct-course` pour les changements significatifs
:::

56
docs/fr/explanation/project-context.md
View File

@ -2,48 +2,48 @@
title: "Contexte du Projet"
description: Comment project-context.md guide les agents IA avec les règles et préférences de votre projet
sidebar:
order: 11
order: 12
---
Le fichier `project-context.md` est le guide d'implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d'autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.
Le fichier `project-context.md` est le guide d’implémentation de votre projet pour les agents IA. Similaire à une « constitution » dans d’autres systèmes de développement, il capture les règles, les patterns et les préférences qui garantissent une génération de code cohérente à travers tous les workflows.
## Ce Qu'il Fait
## Ce Qu’il Fait
Les agents IA prennent constamment des décisions d'implémentation — quels patterns suivre, comment structurer le code, quelles conventions utiliser. Sans guidance claire, ils peuvent :
Les agents IA prennent constamment des décisions d’implémentation — quels patterns suivre, comment structurer le code, quelles conventions utiliser. Sans guidance claire, ils peuvent :
- Suivre des bonnes pratiques génériques qui ne correspondent pas à votre codebase
- Prendre des décisions incohérentes selon les différentes stories
- Passer à côté d'exigences ou de contraintes spécifiques au projet
- Passer à côté d’exigences ou de contraintes spécifiques au projet
Le fichier `project-context.md` résout ce problème en documentant ce que les agents doivent savoir dans un format concis et optimisé pour les LLM.
## Comment Ça Fonctionne
Chaque workflow d'implémentation charge automatiquement `project-context.md` s'il existe. Le workflow architecte le charge également pour respecter vos préférences techniques lors de la conception de l'architecture.
Chaque workflow d’implémentation charge automatiquement `project-context.md` s’il existe. Le workflow architecte le charge également pour respecter vos préférences techniques lors de la conception de l’architecture.
**Chargé par ces workflows :**
**Chargé par ces workflows :**
- `bmad-create-architecture` — respecte les préférences techniques pendant la phase de solutioning
- `bmad-create-story` — informe la création de stories avec les patterns du projet
- `bmad-dev-story` — guide les décisions d'implémentation
- `bmad-dev-story` — guide les décisions d’implémentation
- `bmad-code-review` — valide par rapport aux standards du projet
- `bmad-quick-dev` — applique les patterns lors de l'implémentation des spécifications techniques
- `bmad-quick-dev` — applique les patterns lors de l’implémentation des spécifications techniques
- `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` — fournit le contexte global du projet
## Quand Le Créer
Le fichier `project-context.md` est utile à n'importe quel stade d'un projet :
Le fichier `project-context.md` est utile à n’importe quel stade d’un projet :
| Scénario | Quand Créer | Objectif |
|------------------------------------------|-----------------------------------------------------|---------------------------------------------------------------------------------------|
| **Nouveau projet, avant l'architecture** | Manuellement, avant `bmad-create-architecture` | Documenter vos préférences techniques pour que l'architecte les respecte |
| **Nouveau projet, après l'architecture** | Via `bmad-generate-project-context` ou manuellement | Capturer les décisions d'architecture pour les agents d'implémentation |
| **Nouveau projet, avant l’architecture** | Manuellement, avant `bmad-create-architecture` | Documenter vos préférences techniques pour que l’architecte les respecte |
| **Nouveau projet, après l’architecture** | Via `bmad-generate-project-context` ou manuellement | Capturer les décisions d’architecture pour les agents d’implémentation |
| **Projet existant** | Via `bmad-generate-project-context` | Découvrir les patterns existants pour que les agents suivent les conventions établies |
| **Projet Quick Dev** | Avant ou pendant `bmad-quick-dev` | Garantir que l'implémentation rapide respecte vos patterns |
| **Projet Quick Dev** | Avant ou pendant `bmad-quick-dev` | Garantir que l’implémentation rapide respecte vos patterns |
:::tip[Recommandé]
Pour les nouveaux projets, créez-le manuellement avant l'architecture si vous avez de fortes préférences techniques. Sinon, générez-le après l'architecture pour capturer ces décisions.
Pour les nouveaux projets, créez-le manuellement avant l’architecture si vous avez de fortes préférences techniques. Sinon, générez-le après l’architecture pour capturer ces décisions.
:::
## Ce Qu'il Contient
## Ce Qu’il Contient
Le fichier a deux sections principales :
@ -88,7 +88,7 @@ Documente les patterns et conventions que les agents pourraient autrement manque
- Les nouvelles routes suivent le modèle de routage basé sur les fichiers dans `/src/app/`
```
Concentrez-vous sur ce qui est **non évident** — des choses que les agents pourraient ne pas déduire en lisant des extraits de code. Ne documentez pas les pratiques standard qui s'appliquent universellement.
Concentrez-vous sur ce qui est **non évident** — des choses que les agents pourraient ne pas déduire en lisant des extraits de code. Ne documentez pas les pratiques standard qui s’appliquent universellement.
## Création du Fichier
@ -104,9 +104,9 @@ mkdir -p _bmad-output
touch _bmad-output/project-context.md
```
Éditez-le avec votre pile technologique et vos règles d'implémentation. Les workflows architecture et implémentation le trouveront et le chargeront automatiquement.
Éditez-le avec votre pile technologique et vos règles d’implémentation. Les workflows architecture et implémentation le trouveront et le chargeront automatiquement.
### Générer Après L'Architecture
### Générer Après L’Architecture
Exécutez le workflow `bmad-generate-project-context` après avoir terminé votre architecture :
@ -114,7 +114,7 @@ Exécutez le workflow `bmad-generate-project-context` après avoir terminé votr
bmad-generate-project-context
```
Cela analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte capturant les décisions prises.
Cela analyse votre document d’architecture et vos fichiers projet pour générer un fichier de contexte capturant les décisions prises.
### Générer Pour Les Projets Existants
@ -126,7 +126,7 @@ bmad-generate-project-context
Le workflow analyse votre codebase pour identifier les conventions, puis génère un fichier de contexte que vous pouvez examiner et affiner.
## Pourquoi C'est Important
## Pourquoi C’est Important
Sans `project-context.md`, les agents font des suppositions qui peuvent ne pas correspondre à votre projet :
@ -135,24 +135,24 @@ Sans `project-context.md`, les agents font des suppositions qui peuvent ne pas c
| Utilise des patterns génériques | Suit vos conventions établies |
| Style incohérent selon les stories | Implémentation cohérente |
| Peut manquer les contraintes spécifiques au projet | Respecte toutes les exigences techniques |
| Chaque agent décide indépendamment | Tous les agents s'alignent sur les mêmes règles |
| Chaque agent décide indépendamment | Tous les agents s’alignent sur les mêmes règles |
C'est particulièrement important pour :
- **Quick Dev** — saute le PRD et l'architecture, le fichier de contexte comble le vide
- **Projets d'équipe** — garantit que tous les agents suivent les mêmes standards
C’est particulièrement important pour :
- **Quick Dev** — saute le PRD et l’architecture, le fichier de contexte comble le vide
- **Projets d’équipe** — garantit que tous les agents suivent les mêmes standards
- **Projets existants** — empêche de casser les patterns établis
## Édition et Mise à Jour
Le fichier `project-context.md` est un document vivant. Mettez-le à jour quand :
- Les décisions d'architecture changent
- Les décisions d’architecture changent
- De nouvelles conventions sont établies
- Les patterns évoluent pendant l'implémentation
- Les patterns évoluent pendant l’implémentation
- Vous identifiez des lacunes dans le comportement des agents
Vous pouvez l'éditer manuellement à tout moment, ou réexécuter `bmad-generate-project-context` pour le mettre à jour après des changements significatifs.
Vous pouvez l’éditer manuellement à tout moment, ou réexécuter `bmad-generate-project-context` pour le mettre à jour après des changements significatifs.
:::note[Emplacement du Fichier]
L'emplacement par défaut est `_bmad-output/project-context.md`. Les workflows le recherchent là, et vérifient également `**/project-context.md` n'importe où dans votre projet.
L’emplacement par défaut est `_bmad-output/project-context.md`. Les workflows le recherchent là, et vérifient également `**/project-context.md` n’importe où dans votre projet.
:::

44
docs/fr/explanation/quick-dev.md
View File

@ -2,12 +2,12 @@
title: "Quick Dev"
description: Réduire la friction de l’interaction humaine sans renoncer aux points de contrôle qui protègent la qualité des résultats
sidebar:
order: 6
order: 7
---
Intention en entrée, modifications de code en sortie, avec aussi peu d'interactions humaines dans la boucle que possible — sans sacrifier la qualité.
Intention en entrée, modifications de code en sortie, avec aussi peu d’interactions humaines dans la boucle que possible — sans sacrifier la qualité.
Il permet au modèle de s'exécuter plus longtemps entre les points de contrôle, puis ne vous fait intervenir que lorsque la tâche ne peut pas se poursuivre en toute sécurité sans jugement humain, ou lorsqu'il est temps de revoir le résultat final.
Il permet au modèle de s’exécuter plus longtemps entre les points de contrôle, puis ne vous fait intervenir que lorsque la tâche ne peut pas se poursuivre en toute sécurité sans jugement humain, ou lorsqu’il est temps de revoir le résultat final.
![Diagramme du workflow Quick Dev](/diagrams/quick-dev-diagram-fr.webp)
@ -15,51 +15,51 @@ Il permet au modèle de s'exécuter plus longtemps entre les points de contrôle
Les interactions humaines dans la boucle sont nécessaires et coûteuses.
Les LLM actuels échouent encore de manière prévisible : ils interprètent mal l'intention, comblent les lacunes avec des suppositions assurées, dérivent vers du travail non lié, et génèrent des résultats à réviser bruyants. En même temps, l'intervention humaine constante limite la fluidité du développement. L'attention humaine est le goulot d'étranglement.
Les LLM actuels échouent encore de manière prévisible : ils interprètent mal l’intention, comblent les lacunes avec des suppositions assurées, dérivent vers du travail non lié, et génèrent des résultats à réviser bruyants. En même temps, l’intervention humaine constante limite la fluidité du développement. L’attention humaine est le goulot d’étranglement.
`bmad-quick-dev` rééquilibre ce compromis. Il fait confiance au modèle pour s'exécuter sans surveillance sur de plus longues périodes, mais seulement après que le workflow ait créé une frontière suffisamment solide pour rendre cela sûr.
`bmad-quick-dev` rééquilibre ce compromis. Il fait confiance au modèle pour s’exécuter sans surveillance sur de plus longues périodes, mais seulement après que le workflow ait créé une frontière suffisamment solide pour rendre cela sûr.
## La conception fondamentale
### 1. Compresser l'intention d'abord
### 1. Compresser l’intention d’abord
Le workflow commence par compresser l’interaction de la personne et du modèle à partir de la requête en un objectif cohérent. L'entrée peut commencer sous forme d'une expression grossière de l'intention, mais avant que le workflow ne s'exécute de manière autonome, elle doit devenir suffisamment petite, claire et sans contradiction pour être exécutable.
Le workflow commence par compresser l’interaction de la personne et du modèle à partir de la requête en un objectif cohérent. L’entrée peut commencer sous forme d’une expression grossière de l’intention, mais avant que le workflow ne s’exécute de manière autonome, elle doit devenir suffisamment petite, claire et sans contradiction pour être exécutable.
L'intention peut prendre plusieurs formes : quelques phrases, un lien vers un outil de suivi de bugs, une sortie du mode planification, du texte copié depuis une session de chat, ou même un numéro de story depuis un fichier `epics.md` de BMAD. Dans ce dernier cas, le workflow ne comprendra pas la sémantique de suivi des stories de BMAD, mais il peut quand même prendre la story elle-même et l'exécuter.
L’intention peut prendre plusieurs formes : quelques phrases, un lien vers un outil de suivi de bugs, une sortie du mode planification, du texte copié depuis une session de chat, ou même un numéro de story depuis un fichier `epics.md` de BMAD. Dans ce dernier cas, le workflow ne comprendra pas la sémantique de suivi des stories de BMAD, mais il peut quand même prendre la story elle-même et l’exécuter.
Ce workflow n'élimine pas le contrôle humain. Il le déplace vers un nombre réduit d’étapes à forte valeur :
Ce workflow n’élimine pas le contrôle humain. Il le déplace vers un nombre réduit d’étapes à forte valeur :
- **Clarification de l'intention** - transformer une demande confuse en un objectif cohérent sans contradictions cachées
- **Approbation de la spécification** - confirmer que la compréhension figée correspond bien à ce qu'il faut construire
- **Clarification de l’intention** - transformer une demande confuse en un objectif cohérent sans contradictions cachées
- **Approbation de la spécification** - confirmer que la compréhension figée correspond bien à ce qu’il faut construire
- **Revue du produit final** - le point de contrôle principal, où la personne décide si le résultat est acceptable à la fin
### 2. Router vers le chemin le plus court et sûr
Une fois l'objectif clair, le workflow décide s'il s'agit d'un véritable changement en une seule étape ou s'il nécessite le chemin complet. Les petits changements à zéro impact peuvent aller directement à l'implémentation. Tout le reste passe par la planification pour que le modèle dispose d'un cadre plus solide avant de s'exécuter plus longtemps de manière autonome.
Une fois l’objectif clair, le workflow décide s’il s’agit d’un véritable changement en une seule étape ou s’il nécessite le chemin complet. Les petits changements à zéro impact peuvent aller directement à l’implémentation. Tout le reste passe par la planification pour que le modèle dispose d’un cadre plus solide avant de s’exécuter plus longtemps de manière autonome.
### 3. S'exécuter plus longtemps avec moins de supervision
### 3. S’exécuter plus longtemps avec moins de supervision
Après cette décision de routage, le modèle peut prendre en charge une plus grande partie du travail par lui-même. Sur le chemin complet, la spécification approuvée devient le cadre dans lequel le modèle s'exécute avec moins de supervision, ce qui est tout l'intérêt de la conception.
Après cette décision de routage, le modèle peut prendre en charge une plus grande partie du travail par lui-même. Sur le chemin complet, la spécification approuvée devient le cadre dans lequel le modèle s’exécute avec moins de supervision, ce qui est tout l’intérêt de la conception.
### 4. Diagnostiquer les échecs au bon niveau
Si l'implémentation est incorrecte parce que l'intention était mauvaise, corriger le code n'est pas la bonne solution. Si le code est incorrect parce que la spécification était faible, corriger le diff n'est pas non plus la bonne solution. Le workflow est conçu pour diagnostiquer où l'échec est entré dans le système, revenir à ce niveau, et régénérer à partir de ce point.
Si l’implémentation est incorrecte parce que l’intention était mauvaise, corriger le code n’est pas la bonne solution. Si le code est incorrect parce que la spécification était faible, corriger le diff n’est pas non plus la bonne solution. Le workflow est conçu pour diagnostiquer où l’échec est entré dans le système, revenir à ce niveau, et régénérer à partir de ce point.
Les résultats de la revue sont utilisés pour décider si le problème provenait de l'intention, de la génération de la spécification, ou de l'implémentation locale. Seuls les véritables problèmes locaux sont corrigés localement.
Les résultats de la revue sont utilisés pour décider si le problème provenait de l’intention, de la génération de la spécification, ou de l’implémentation locale. Seuls les véritables problèmes locaux sont corrigés localement.
### 5. Ne faire intervenir l’humain que si nécessaire
L'entretien sur l'intention implique la personne dans la boucle, mais ce n'est pas le même type d'interruption qu'un point de contrôle récurrent. Le workflow essaie de garder ces points de contrôle récurrents au minimum. Après la mise en forme initiale de l'intention, la personne revient principalement lorsque le workflow ne peut pas continuer en toute sécurité sans jugement, et à la fin, lorsqu'il est temps de revoir le résultat.
L’entretien sur l’intention implique la personne dans la boucle, mais ce n’est pas le même type d’interruption qu’un point de contrôle récurrent. Le workflow essaie de garder ces points de contrôle récurrents au minimum. Après la mise en forme initiale de l’intention, la personne revient principalement lorsque le workflow ne peut pas continuer en toute sécurité sans jugement, et à la fin, lorsqu’il est temps de revoir le résultat.
- **Résolution des lacunes d'intention** - intervenir à nouveau lors de la revue prouve que le workflow n'a pas pu déduire correctement ce qui était voulu
- **Résolution des lacunes d’intention** - intervenir à nouveau lors de la revue prouve que le workflow n’a pas pu déduire correctement ce qui était voulu
Tout le reste est candidat à une exécution autonome plus longue. Ce compromis est délibéré. Les anciens patterns dépensent plus d'attention humaine en supervision continue. Quick Dev fait davantage confiance au modèle, mais préserve l'attention humaine pour les moments où le raisonnement humain a le plus d'impact.
Tout le reste est candidat à une exécution autonome plus longue. Ce compromis est délibéré. Les anciens patterns dépensent plus d’attention humaine en supervision continue. Quick Dev fait davantage confiance au modèle, mais préserve l’attention humaine pour les moments où le raisonnement humain a le plus d’impact.
## Pourquoi le système de revue est important
La phase de revue n'est pas seulement là pour trouver des bugs. Elle est là pour router la correction sans détruire l'élan.
La phase de revue n’est pas seulement là pour trouver des bugs. Elle est là pour router la correction sans détruire l’élan.
Ce workflow fonctionne mieux sur une plateforme capable de générer des sous-agents[^1], ou au moins d'invoquer un autre LLM via la ligne de commande et d'attendre un résultat. Si votre plateforme ne supporte pas cela nativement, vous pouvez ajouter un skill pour le faire. Les sous-agents sans contexte sont une pierre angulaire de la conception de la revue.
Ce workflow fonctionne mieux sur une plateforme capable de générer des sous-agents[^1], ou au moins d’invoquer un autre LLM via la ligne de commande et d’attendre un résultat. Si votre plateforme ne supporte pas cela nativement, vous pouvez ajouter un skill pour le faire. Les sous-agents sans contexte sont une pierre angulaire de la conception de la revue.
Les revues agentiques[^2] échouent souvent de deux manières :
@ -68,7 +68,7 @@ Les revues agentiques[^2] échouent souvent de deux manières :
Quick Dev aborde ces deux problèmes en traitant la revue comme un triage[^3].
Lorsqu’une observation est fortuite plutôt que directement liée au travail en cours, le processus peut la mettre de côté au lieu d’obliger la personne à s’en occuper immédiatement. Cela permet de rester concentré sur l’exécution et d’éviter que des digressions aléatoires ne viennent épuiser le capital d’attention.
Certaines observations concernent le changement en cours, d’autres non. Si une observation est incidente plutôt que directement liée au travail en cours, le workflow peut la différer au lieu d’obliger la personne à la traiter immédiatement. Cela permet de rester concentré sur l’exécution et d’éviter que des digressions aléatoires ne viennent épuiser le capital d’attention.
Ce triage sera parfois imparfait. C’est acceptable. Il est généralement préférable de mal juger certaines observations plutôt que d’inonder la personne de milliers de commentaires de revue à faible valeur. Le système optimise la qualité du rapport, pas d’être exhaustif.

90
docs/fr/explanation/web-bundles.md Normal file
View File

@ -0,0 +1,90 @@
---
title: 'Web Bundles'
description: Skills BMad empaquetés pour Google Gemini Gems et ChatGPT Custom GPTs
---
Exécutez la partie planification de BMad dans votre abonnement LLM web, puis ramenez les artefacts dans votre IDE.
## Qu’est-ce qu’un Web Bundle ?
Un web bundle est un skill BMad reconditionné pour être installé comme **Google Gemini Gem** ou **ChatGPT Custom GPT**. Chaque bundle inclut un protocole `SKILL.md` que vous téléversez comme fichier de connaissance, un bloc `INSTRUCTIONS.md` que vous collez dans les instructions du Gem ou du GPT, et les fichiers de données dont le skill a besoin (CSV, modèles, listes de contrôle de validation, contenu dévoilé progressivement). Le persona vit dans les instructions collées ; le protocole vit dans le fichier de connaissance. Changez de persona sans toucher au protocole.
L’installation ne se fait pas en un clic, mais les étapes sont guidées. **Installez depuis [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**. Le site liste chaque bundle dans une grille, vous montre les étapes d’installation Gemini et ChatGPT directement sur la page, et met le ZIP à disposition. C’est le type d’installation pris en charge ; le schéma est le même dans toute la bibliothèque, donc une fois que vous en avez installé un, le suivant va de soi.
La V4 de BMad a introduit les web bundles. La V6 les réintègre, réécrits pour les plateformes Gem et Custom GPT actuelles et conçus pour Canvas, Deep Research et la génération d’images.
## Pourquoi les utiliser
Le travail de planification et le travail d’implémentation nécessitent des outils différents. Les web bundles permettent à chacun d’utiliser le bon.
| Aspect | LLM web (Gem ou GPT) | IDE (Claude Code, Cursor) |
|----------------------|---------------------------------------------|--------------------------------------------|
| Modèle de coût | Abonnement forfaitaire | Tokens facturés à l’usage |
| Plus performant pour | Conversation, Canvas, Deep Research, images | Fichiers, terminal, contexte du codebase |
| Idéal pour | Brainstorming, briefs, PRD, recherche | Implémentation, refactoring, revue de code |
Lancer une conversation complète de PRD ou d’étude de marché dans un IDE consomme des tokens qu’un Gem ou un Custom GPT gère pour le prix de votre abonnement existant. L’artefact finalisé est ensuite déposé dans votre dépôt et Claude Code ou Cursor prend le relais.
:::tip[Planifiez sur le web, construisez dans l’IDE]
Les économies se cumulent sur les engagements de longue durée. Un passage de PRFAQ et trois cycles de recherche dans un Gem représentent un coût marginal nul ; le même travail dans un IDE représente une dépense réelle.
:::
## Ce que contient la bibliothèque
Les bundles actuellement disponibles couvrent les phases d’analyse et de planification :
| Bundle | Phase | Origine du persona |
|----------------------------------------------------------------|---------------|-------------------------------------------|
| Coach Brainstorming[^1] | Analyse | Osborn (par défaut), Minto (substitution) |
| Coach Product Brief[^2] | Analyse | Mary (analyste BMad) |
| Coach [PRFAQ](./analysis-phase.md#prfaq-working-backwards)[^3] | Analyse | Working Backwards (Bezos) |
| Coach PRD[^4] | Planification | Cagan |
| Coach UX[^5] | Planification | Norman |
| Étude de marché et analyse sectorielle | Analyse | Porter et Christensen |
Chaque bundle intègre un persona par défaut hérité de son agent BMad d’origine (lorsqu’il existe) et un exemple de persona alternatif pour illustrer le changement de voix.
## Comment se déroule une session
1. **Ouvrez le Gem ou le Custom GPT.** Le persona vous salue en restant dans son rôle et ouvre une phase de découverte conversationnelle.
2. **Découvrir le périmètre.** Le persona vous demande ce que vous essayez d’accomplir, ce que vous avez sous la main, quelles contraintes s’appliquent. Pas de formulaire à remplir.
3. **Travailler dans Canvas.** Le protocole ouvre Canvas au démarrage de la session et le met à jour en continu. Les diagrammes Mermaid et les tableaux HTML viennent s’ajouter au texte.
4. **Transmettre.** Quand vous avez terminé, vous avez un document Canvas que vous pouvez exporter, coller dans votre dépôt, ou transmettre à un skill BMad dans votre IDE pour la phase suivante.
Pour les bundles qui intègrent Deep Research (actuellement Market & Industry Research), le persona rédige un brief Deep Research en milieu de session que vous collez dans le mode Deep Research de Gemini ou ChatGPT, puis il intègre le rapport obtenu.
## Quand utiliser un web bundle
- Vous êtes en phase de réflexion amont sur un projet et vous voulez un outil ciblé avec persona, Canvas et Deep Research.
- Vous voulez réserver les tokens de l’IDE au développement réel.
- Vous partagez l’artefact de planification avec des collaborateurs qui n’ont pas votre configuration IDE.
## Quand rester dans l’IDE
- Le travail nécessite de lire ou modifier du code dans votre dépôt.
- Vous êtes déjà en pleine implémentation et voulez conserver le contexte.
- Vous n’avez pas d’abonnement Gemini Advanced ou ChatGPT Plus.
## Mettre à jour et personnaliser
Les bundles évoluent. Quand vous récupérez une version plus récente d’un bundle, la mise à jour typique concerne ses fichiers de connaissance (le protocole `SKILL.md` et les modèles, CSV ou listes de contrôle de validation attachés). Téléversez-les à nouveau dans votre Gem ou Custom GPT pour appliquer la mise à jour. Le bloc d’instructions ne change généralement pas.
Si vous souhaitez personnaliser un bundle pour votre équipe ou votre voix, faites-le dans le **bloc d’instructions** que vous avez collé dans le Gem ou le GPT, pas dans les fichiers de connaissance. Le bloc d’instructions est l’endroit où se trouvent le persona, les préférences et les personnalisations locales ; les fichiers de connaissance sont le protocole livré avec le bundle. Garder la personnalisation dans le bloc d’instructions signifie que les futures mises à jour se résument à remplacer les pièces jointes, pas à fusionner vos modifications.
:::tip[Personnalisez les instructions, joignez-y les connaissances]
Substitutions de persona, nom d’utilisateur par défaut, garde-fous spécifiques à l’équipe, formulations préférées : tout cela appartient au bloc d’instructions collé. Les fichiers de connaissance restent standards pour que vous puissiez les rafraîchir sans perdre vos modifications.
:::
## Créer le vôtre
Les web bundles sont générés à partir de skills BMad en utilisant le skill utilitaire `bmad-os-skill-to-bundle`. Pointez-le vers n’importe quel dossier de skill BMad et il produit les fichiers du bundle en reprenant le persona hérité de l’agent d’origine.
Installez n’importe quel bundle depuis [bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/).
## Glossaire
[^1]: Brainstorming : session de créativité facilitée visant à produire et explorer un large éventail d’idées sur un sujet donné, en s’appuyant sur des techniques d’idéation éprouvées.
[^2]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.
[^3]: PRFAQ (Press Release and Frequently Asked Questions) : méthodologie Working Backwards d’Amazon consistant à rédiger le communiqué de presse d’un produit fini avant son développement, suivie des questions difficiles que clients et parties prenantes poseraient, afin d’éprouver la clarté et la viabilité du concept.
[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
[^5]: UX (User Experience) : discipline qui conçoit et optimise l’ensemble des interactions entre un utilisateur et un produit — organisation, parcours, accessibilité, ergonomie — pour garantir une expérience efficace, satisfaisante et cohérente.

26
docs/fr/explanation/why-solutioning-matters.md
View File

@ -2,10 +2,10 @@
title: "Pourquoi le Solutioning est Important"
description: Comprendre pourquoi la phase de solutioning est critique pour les projets multi-epics
sidebar:
order: 4
order: 5
---
La Phase 3 (Solutioning) traduit le **quoi** construire (issu de la Planification) en **comment** le construire (conception technique). Cette phase évite les conflits entre agents dans les projets multi-epics en documentant les décisions architecturales avant le début de l'implémentation.
La Phase 3 (Solutioning) traduit le **quoi** construire (issu de la Planification) en **comment** le construire (conception technique). Cette phase évite les conflits entre agents dans les projets multi-epics en documentant les décisions architecturales avant le début de l’implémentation.
## Le Problème Sans Solutioning
@ -15,7 +15,7 @@ Agent 2 implémente l'Epic 2 avec GraphQL
Résultat : Conception d'API incohérente, cauchemar d'intégration
```
Lorsque plusieurs agents implémentent différentes parties d'un système sans orientation architecturale partagée, ils prennent des décisions techniques indépendantes qui peuvent entrer en conflit.
Lorsque plusieurs agents implémentent différentes parties d’un système sans orientation architecturale partagée, ils prennent des décisions techniques indépendantes qui peuvent entrer en conflit.
## La Solution Avec le Solutioning
@ -25,13 +25,13 @@ Tous les agents suivent les décisions d'architecture
Résultat : Implémentation cohérente, pas de conflits
```
En documentant les décisions techniques de manière explicite, tous les agents implémentent de façon cohérente et l'intégration devient simple.
En documentant les décisions techniques de manière explicite, tous les agents implémentent de façon cohérente et l’intégration devient simple.
## Solutioning vs Planification
| Aspect | Planification (Phase 2) | Solutioning (Phase 3) |
|----------|--------------------------|-------------------------------------------------|
| Question | Quoi et Pourquoi ? | Comment ? Puis Quelles unités de travail ? |
| Question | Quoi et Pourquoi ? | Comment ? Puis Quelles unités de travail ? |
| Sortie | FRs/NFRs (Exigences)[^1] | Architecture + Epics[^2]/Stories[^3] |
| Agent | PM | Architect → PM |
| Audience | Parties prenantes | Développeurs |
@ -43,15 +43,15 @@ En documentant les décisions techniques de manière explicite, tous les agents
**Rendre les décisions techniques explicites et documentées** pour que tous les agents implémentent de manière cohérente.
Cela évite :
- Les conflits de style d'API (REST vs GraphQL)
- Les conflits de style d’API (REST vs GraphQL)
- Les incohérences de conception de base de données
- Les désaccords sur la gestion du state
- Les inadéquations de conventions de nommage
- Les variations d'approche de sécurité
- Les variations d’approche de sécurité
## Quand le Solutioning est Requis
| Parcours | Solutioning Requis ? |
| Parcours | Solutioning Requis ? |
|-----------------------|-----------------------------|
| Quick Dev | Non - l’ignore complètement |
| Méthode BMad Simple | Optionnel |
@ -66,20 +66,20 @@ Si vous avez plusieurs epics qui pourraient être implémentés par différents
Sauter le solutioning sur des projets complexes entraîne :
- **Des problèmes d'intégration** découverts en milieu de sprint[^5]
- **Des problèmes d’intégration** découverts en milieu de sprint[^5]
- **Du travail répété** dû à des implémentations conflictuelles
- **Un temps de développement plus long** globalement
- **De la dette technique**[^6] due à des patterns incohérents
:::caution[Coût Multiplié]
Détecter les problèmes d'alignement lors du solutioning est 10× plus rapide que de les découvrir pendant l'implémentation.
Détecter les problèmes d’alignement lors du solutioning est 10× plus rapide que de les découvrir pendant l’implémentation.
:::
## Glossaire
[^1]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité, fiabilité, ergonomie, etc.).
[^2]: Epic : dans les méthodologies agiles, une unité de travail importante qui peut être décomposée en plusieurs stories plus petites. Un epic représente généralement une fonctionnalité majeure ou un objectif métier.
[^3]: Story (User Story) : description courte et simple d'une fonctionnalité du point de vue de l'utilisateur, utilisée dans les méthodologies agiles pour planifier et prioriser le travail.
[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
[^5]: Sprint : période de temps fixe (généralement 1 à 4 semaines) dans les méthodologies agiles durant laquelle l'équipe complète un ensemble prédéfini de tâches.
[^3]: Story (User Story) : description courte et simple d’une fonctionnalité du point de vue de l’utilisateur, utilisée dans les méthodologies agiles pour planifier et prioriser le travail.
[^4]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
[^5]: Sprint : période de temps fixe (généralement 1 à 4 semaines) dans les méthodologies agiles durant laquelle l’équipe complète un ensemble prédéfini de tâches.
[^6]: Dette technique : coût futur supplémentaire de travail résultant de choix de facilité ou de raccourcis pris lors du développement initial, nécessitant souvent une refonte ultérieure.

437
docs/fr/how-to/customize-bmad.md
View File

@ -1,174 +1,395 @@
---
title: "Comment personnaliser BMad"
description: Personnalisez les agents, les workflows et les modules tout en préservant la compatibilité avec les mises à jour
description: Personnalisez les agents et les workflows tout en préservant la compatibilité avec les mises à jour
sidebar:
order: 7
order: 8
---
Utilisez les fichiers `.customize.yaml` pour adapter le comportement, les personas[^1] et les menus des agents tout en préservant vos modifications lors des mises à jour.
Adaptez les personas d’agents, injectez du contexte métier, ajoutez des capacités et configurez le comportement des workflows — le tout sans modifier les fichiers installés. Vos personnalisations sont préservées à chaque mise à jour.
:::tip[Vous ne voulez pas rédiger du TOML à la main ? Utilisez `bmad-customize`]
Le skill `bmad-customize` est un assistant de rédaction guidée pour les **options de personnalisation par skill (agent/workflow)** décrite dans ce document. Il scanne ce qui est personnalisable dans votre installation, vous aide à choisir la bonne surface (agent ou workflow) pour votre intention, écrit le fichier d’override pour vous et vérifie que la fusion a fonctionné. Les overrides de la configuration centrale (`_bmad/custom/config.toml`) ne sont pas couverts par la v1 du skill — rédigez-les manuellement en vous référant à la section Configuration centrale ci-dessous. Exécutez le skill chaque fois que vous souhaitez modifier un skill spécifique ; ce document est la référence sur *ce que* chaque surface expose et comment fonctionne la fusion.
:::
## Quand utiliser cette fonctionnalité
- Vous souhaitez modifier le nom, la personnalité ou le style de communication d'un agent
- Vous avez besoin que les agents se souviennent du contexte spécifique au projet
- Vous souhaitez ajouter des éléments de menu personnalisés qui déclenchent vos propres workflows ou prompts
- Vous voulez que les agents effectuent des actions spécifiques à chaque démarrage
- Vous souhaitez changer la personnalité ou le style de communication d’un agent
- Vous devez fournir à un agent des faits persistants qu’il devra retenir (ex. « notre org est 100 % AWS »)
- Vous souhaitez ajouter des étapes procédurales de démarrage que l’agent doit exécuter à chaque session
- Vous souhaitez ajouter des éléments de menu personnalisés qui déclenchent vos propres skills ou prompts
- Votre équipe a besoin de personnalisations partagées versionnées dans git, avec des préférences personnelles ajoutées par-dessus
:::note[Prérequis]
- BMad installé dans votre projet (voir [Comment installer BMad](./install-bmad.md))
- Un éditeur de texte pour les fichiers YAML
- Python 3.11+ sur votre PATH (pour le script de résolution — utilise `tomllib` de la bibliothèque standard, pas de `pip install`, pas de `uv`, pas de virtualenv)
- Un éditeur de texte pour les fichiers TOML
:::
:::caution[Protégez vos personnalisations]
Utilisez toujours les fichiers `.customize.yaml` décrits ici plutôt que de modifier directement les fichiers d'agents. L'installateur écrase les fichiers d'agents lors des mises à jour, mais préserve vos modifications dans les fichiers `.customize.yaml`.
:::
## Comment ça marche
Chaque skill personnalisable embarque un fichier `customize.toml` avec ses valeurs par défaut. Ce fichier définit la surface de personnalisation complète du skill — lisez-le pour voir ce qui est personnalisable. Ne modifiez jamais ce fichier. À la place, créez des fichiers d’override allégés contenant uniquement les champs que vous souhaitez changer.
### Modèle d’override à trois couches
```text
Priorité 1 (gagne) : _bmad/custom/{skill-name}.user.toml (personnel, ignoré par git)
Priorité 2 : _bmad/custom/{skill-name}.toml (équipe/org, versionné dans git)
Priorité 3 (base) : customize.toml du skill (valeurs par défaut)
```
Le dossier `_bmad/custom/` est initialement vide. Les fichiers n’apparaissent que lorsqu’un utilisateur commence à personnaliser.
### Règles de fusion (par forme, pas par nom de champ)
Le résolveur applique quatre règles structurelles. Les noms de champ n’ont pas de traitement particulier — le comportement est déterminé uniquement par la forme de la valeur :
| Forme | Règle |
|-------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|
| Scalaire (chaîne, entier, booléen, flottant) | L’override prévaut |
| Table | Fusion profonde (application récursive des mêmes règles) |
| Tableau de tables où chaque élément partage le **même** champ identifiant (chaque élément a `code`, ou chaque élément a `id`) | Fusionner par cette clé — les clés correspondantes **remplacent sur place**, les nouvelles clés **s’ajoutent** |
| Tout autre tableau (scalaires ; tables sans identifiant ; tableaux qui mélangent `code` et `id` entre les éléments) | **Ajouter** — éléments de base en premier, puis éléments d’équipe, puis éléments utilisateur |
**Pas de mécanisme de suppression.** Les overrides ne peuvent pas effacer les éléments de base. Si vous devez supprimer un élément de menu par défaut, surchargez-le via son `code` avec une description ou un prompt sans effet. Si vous devez restructurer un tableau plus en profondeur, forkez le skill.
**La convention `code` / `id`.** BMad utilise `code` (code court comme `"BP"` ou `"R1"`) et `id` (identifiant stable plus long) comme clés de fusion dans les tableaux de tables. Si vous rédigez un tableau de tables personnalisé destiné à être fusionné par clé plutôt que par simple ajout, choisissez **une** convention (soit `code` sur chaque élément, soit `id` sur chaque élément) et respectez-la dans tout le tableau. Mélanger `code` sur certains éléments et `id` sur d’autres revient à un simple ajout — le résolveur ne devinera pas quelle clé utiliser pour la fusion.
### Certains champs d’agent sont en lecture seule
`agent.name` et `agent.title` sont présents dans `customize.toml` comme source de vérité, mais le SKILL.md de l’agent ne les lit pas à l’exécution — leur identité est codée en dur. Mettre `name = "Bob"` dans un fichier d’override n’a aucun effet. Si vous avez vraiment besoin d’un agent avec un nom différent, copiez le dossier du skill, renommez-le et distribuez-le comme skill personnalisé.
## Étapes
### 1. Localiser les fichiers de personnalisation
### 1. Trouver la surface de personnalisation du skill
Après l'installation, vous trouverez un fichier `.customize.yaml` par agent dans :
Consultez le `customize.toml` du skill dans son répertoire d’installation. Par exemple, l’agent PM :
```text
_bmad/_config/agents/
├── bmm-analyst.customize.yaml
├── bmm-architect.customize.yaml
└── ... (un fichier par agent installé)
.claude/skills/bmad-agent-pm/customize.toml
```
### 2. Modifier le fichier de personnalisation
(Le chemin varie selon l’IDE — Cursor utilise `.cursor/skills/`, Cline utilise `.cline/skills/`, etc.)
Ouvrez le fichier `.customize.yaml` de l'agent que vous souhaitez modifier. Chaque section est facultative — personnalisez uniquement ce dont vous avez besoin.
Ce fichier est le schéma canonique. Chaque champ que vous voyez est personnalisable (à l’exception des champs d’identité en lecture seule mentionnés ci-dessus).
| Section | Comportement | Objectif |
| ------------------ | ------------ | ------------------------------------------------ |
| `agent.metadata` | Remplace | Remplacer le nom d'affichage de l'agent |
| `persona` | Remplace | Définir le rôle, l'identité, le style et les principes |
| `memories` | Ajoute | Ajouter un contexte persistant que l'agent se rappelle toujours |
| `menu` | Ajoute | Ajouter des éléments de menu personnalisés pour les workflows ou prompts |
| `critical_actions` | Ajoute | Définir les instructions de démarrage de l'agent |
| `prompts` | Ajoute | Créer des prompts réutilisables pour les actions du menu |
### 2. Créer votre fichier d’override
Les sections marquées **Remplace** écrasent entièrement les valeurs par défaut de l'agent. Les sections marquées **Ajoute** s'ajoutent à la configuration existante.
Créez le répertoire `_bmad/custom/` à la racine de votre projet s’il n’existe pas. Puis créez un fichier portant le même nom que le skill :
**Nom de l'agent**
Modifier la façon dont l'agent se présente :
```yaml
agent:
metadata:
name: 'Bob l’éponge' # Par défaut : "Amelia"
```text
_bmad/custom/
bmad-agent-pm.toml # overrides d'équipe (versionnés dans git)
bmad-agent-pm.user.toml # préférences personnelles (ignoré par git)
```
**Persona**
:::caution[Ne copiez PAS le `customize.toml` complet]
Les fichiers d’override sont **allégés**. Incluez uniquement les champs que vous modifiez — rien d’autre. Chaque champ omis est hérité automatiquement de la couche inférieure (l’équipe hérite des valeurs par défaut, l’utilisateur de l’équipe ou des valeurs par défaut).
Remplacer la personnalité, le rôle et le style de communication de l'agent :
Copier le `customize.toml` complet dans un override est contre-productif : la prochaine mise à jour livrera de nouvelles valeurs par défaut, mais votre fichier d’override figera les anciennes valeurs. Votre configuration s’éloignera silencieusement des valeurs par défaut à chaque mise à jour.
:::
```yaml
persona:
role: 'Ingénieur Full-Stack Senior'
identity: 'Habite dans un ananas (au fond de la mer)'
communication_style: 'Style agaçant de Bob l’Éponge'
principles:
- 'Jamais de nidification, les devs Bob l’Éponge détestent plus de 2 niveaux d’imbrication'
- 'Privilégier la composition à l’héritage'
**Exemple — changer l’icône et ajouter un principe :**
```toml
# _bmad/custom/bmad-agent-pm.toml
# Uniquement les champs que je modifie. Tout le reste est hérité.
[agent]
icon = "🏥"
principles = [
"Ne rien livrer qui ne puisse passer un audit FDA.",
]
```
La section `persona`[^1] remplace entièrement le persona par défaut, donc incluez les quatre champs si vous la définissez.
Ceci ajoute le nouveau principe aux valeurs par défaut (en laissant les principes existants intacts) et remplace l’icône. Tous les autres champs restent inchangés.
**Souvenirs**
### 3. Personnaliser selon vos besoins
Ajouter un contexte persistant que l'agent gardera toujours en mémoire :
Tous les exemples ci-dessous supposent le schéma d’agent plat de BMad. Les champs se trouvent directement sous `[agent]` — pas de sous-tables `metadata` ou `persona` imbriquées.
```yaml
memories:
- 'Travaille au Krusty Krab'
- 'Célébrité préférée : David Hasselhoff'
- 'Appris dans l’Epic 1 que ce n’est pas cool de faire semblant que les tests ont passé'
**Scalaires (icon, role, identity, communication_style).** Les overrides scalaires prévalent. Vous n’avez besoin de définir que les champs que vous modifiez :
```toml
# _bmad/custom/bmad-agent-pm.toml
[agent]
icon = "🏥"
role = "Pilote la découverte produit pour un domaine de santé réglementé."
communication_style = "Précis, sensible à la réglementation, pose des questions orientées conformité tôt."
```
**Éléments de menu**
**Faits persistants, principes, hooks d’activation (tableaux en mode ajout).** Les quatre tableaux ci-dessous sont en ajout uniquement. Les éléments d’équipe s’exécutent après les valeurs par défaut, les éléments utilisateur s’exécutent en dernier.
Ajouter des entrées personnalisées au menu d'affichage de l'agent. Chaque élément nécessite un `trigger`, une cible (chemin `workflow` ou référence `action`), et une `description` :
```toml
[agent]
# Faits statiques que l'agent garde en tête pendant toute la session — règles d'org,
# constantes de domaine, préférences utilisateur. Distinct du sidecar de mémoire runtime.
#
# Chaque entrée est soit une phrase littérale, soit une référence `file:` dont le
# contenu est chargé comme des faits (patterns glob supportés).
persistent_facts = [
"Notre org est 100 % AWS — ne pas proposer GCP ni Azure.",
"Tous les PRD nécessitent une validation légale avant le démarrage de l'ingénierie.",
"Les utilisateurs cibles sont des cliniciens, pas des patients — formuler les exemples en conséquence.",
"file:{project-root}/docs/compliance/hipaa-overview.md",
"file:{project-root}/_bmad/custom/company-glossary.md",
]
```yaml
menu:
- trigger: my-workflow
workflow: 'my-custom/workflows/my-workflow.yaml'
description: Mon workflow personnalisé
- trigger: deploy
action: '#deploy-prompt'
description: Déployer en production
# S'ajoute au système de valeurs de l'agent
principles = [
"Ne rien livrer qui ne puisse passer un audit FDA.",
"Valeur utilisateur d'abord, conformité toujours.",
]
# S'exécute AVANT l'activation standard (persona, persistent_facts, config, salutation).
# À utiliser pour les préchargements, vérifications de conformité, tout ce qui doit être
# en contexte avant que l'agent ne se présente.
activation_steps_prepend = [
"Scanner {project-root}/docs/compliance/ et charger tout document lié à HIPAA comme contexte.",
]
# S'exécute APRÈS la salutation, AVANT le menu. Utiliser pour le chargement de contexte
# qui doit intervenir après le message d'accueil.
activation_steps_append = [
"Lire {project-root}/_bmad/custom/company-glossary.md s'il existe.",
]
```
**Actions critiques**
**Pourquoi deux hooks ?** Le préfixe s’exécute avant la salutation pour que l’agent puisse charger le contexte dont il a besoin pour personnaliser la salutation elle-même. Le suffixe s’exécute après la salutation pour que l’utilisateur ne reste pas devant un terminal vide pendant les scans lourds.
Définir des instructions qui s'exécutent au démarrage de l'agent :
**Personnalisation du menu (fusion par `code`).** Le menu est un tableau de tables. Chaque élément possède un champ `code` (convention BMad). Le résolveur fusionne donc par code : les codes correspondants remplacent sur place, les nouveaux codes s’ajoutent.
```yaml
critical_actions:
- 'Vérifier les pipelines CI avec le Skill XYZ et alerter l’utilisateur au réveil si quelque chose nécessite une attention urgente'
La syntaxe TOML pour les tableaux de tables utilise `[[agent.menu]]` pour chaque élément :
```toml
# Remplacer l'élément CE existant par un skill personnalisé
[[agent.menu]]
code = "CE"
description = "Créer des Epics avec notre framework de livraison"
skill = "custom-create-epics"
# Ajouter un nouvel élément (le code RC n'existe pas dans les valeurs par défaut)
[[agent.menu]]
code = "RC"
description = "Exécuter une pré-vérification de conformité"
prompt = """
Lire {project-root}/_bmad/custom/compliance-checklist.md
et scanner tous les documents dans {planning_artifacts} en les comparant à celui-ci.
Signaler tout écart et citer la section réglementaire pertinente.
"""
```
**Prompts personnalisés**
Chaque élément de menu possède exactement un `skill` (invoque un skill enregistré) ou `prompt` (exécute le texte directement). Les éléments non listés dans votre override conservent leurs valeurs par défaut.
Créer des prompts réutilisables que les éléments de menu peuvent référencer avec `action="#id"` :
**Référencer des fichiers.** Quand le texte d’un champ doit pointer vers un fichier (dans `persistent_facts`, `activation_steps_prepend`/`activation_steps_append`, ou le `prompt` d’un élément de menu), utilisez un chemin complet partant de `{project-root}`. Même si le fichier se trouve à côté de votre override dans `_bmad/custom/`, écrivez le chemin complet : `{project-root}/_bmad/custom/info.md`. L’agent résout `{project-root}` à l’exécution.
```yaml
prompts:
- id: deploy-prompt
content: |
Déployer la branche actuelle en production :
1. Exécuter tous les tests
2. Build le projet
3. Exécuter le script de déploiement
### 4. Personnel vs Équipe
**Fichier d’équipe** (`bmad-agent-pm.toml`) : Versionné dans git. Partagé au sein de l’organisation. À utiliser pour les règles de conformité, le persona de l’entreprise, les capacités personnalisées.
**Fichier personnel** (`bmad-agent-pm.user.toml`) : Automatiquement ignoré par git. À utiliser pour les ajustements de ton, les préférences de workflow personnelles et les faits privés que l’agent doit garder en tête.
```toml
# _bmad/custom/bmad-agent-pm.user.toml
[agent]
persistent_facts = [
"Toujours inclure une estimation approximative de complexité (faible/moyenne/élevée) en présentant les options.",
]
```
### 3. Appliquer vos modifications
## Comment fonctionne la résolution
Après modification, réinstallez pour appliquer les changements :
À l’activation, le SKILL.md de l’agent exécute un script Python partagé qui effectue la fusion à trois couches et renvoie le bloc résolu en JSON. Le script utilise le module `tomllib` de la bibliothèque standard Python (aucune dépendance externe), donc `python3` suffit :
```bash
npx bmad-method install
python3 {project-root}/_bmad/scripts/resolve_customization.py \
--skill {skill-root} \
--key agent
```
L'installateur détecte l'installation existante et propose ces options :
**Prérequis** : Python 3.11+ (les versions antérieures n’incluent pas `tomllib`). Pas de `pip install`, pas de `uv`, pas de virtualenv. Vérifiez avec `python3 --version`. Certaines plateformes (macOS sans Homebrew, Ubuntu 22.04) ont `python3` par défaut en 3.10 ou antérieur, vous devrez peut-être installer 3.11+ séparément.
| Option | Ce qu'elle fait |
| ----------------------------------- | ---------------------------------------------------------------------- |
| **Quick Update** | Met à jour tous les modules vers la dernière version et applique les personnalisations |
| **Modify BMad Installation** | Flux d'installation complet pour ajouter ou supprimer des modules |
`--skill` pointe vers le répertoire installé du skill (où se trouve `customize.toml`). Le nom du skill est déduit du basename du répertoire, et le script cherche automatiquement `_bmad/custom/{skill-name}.toml` et `{skill-name}.user.toml`.
Pour des modifications de personnalisation uniquement, **Quick Update** est l'option la plus rapide.
Exemples d’utilisation :
## Résolution des problèmes
```bash
# Résoudre le bloc agent complet
python3 {project-root}/_bmad/scripts/resolve_customization.py \
--skill /chemin/absolu/vers/bmad-agent-pm \
--key agent
**Les modifications n'apparaissent pas ?**
# Résoudre un seul champ
python3 {project-root}/_bmad/scripts/resolve_customization.py \
--skill /chemin/absolu/vers/bmad-agent-pm \
--key agent.icon
- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour appliquer les modifications
- Vérifiez que votre syntaxe YAML est valide (l'indentation compte)
- Assurez-vous d'avoir modifié le bon fichier `.customize.yaml` pour l'agent
# Dump complet
python3 {project-root}/_bmad/scripts/resolve_customization.py \
--skill /chemin/absolu/vers/bmad-agent-pm
```
**L'agent ne se charge pas ?**
- Vérifiez les erreurs de syntaxe YAML à l'aide d'un validateur YAML en ligne
- Assurez-vous de ne pas avoir laissé de champs vides après les avoir décommentés
- Essayez de revenir au modèle d'origine et de reconstruire
**Besoin de réinitialiser un agent ?**
- Effacez ou supprimez le fichier `.customize.yaml` de l'agent
- Exécutez `npx bmad-method install` et sélectionnez **Quick Update** pour restaurer les valeurs par défaut
La sortie est toujours en JSON. Si le script n’est pas disponible sur une plateforme donnée, le SKILL.md demande à l’agent de lire les trois fichiers TOML directement et d’appliquer les mêmes règles de fusion.
## Personnalisation des workflows
La personnalisation des workflows et skills existants de la méthode BMad arrive bientôt.
Les workflows (skills qui pilotent des processus multi-étapes comme `bmad-product-brief`) partagent le même mécanisme d’override que les agents. Leur surface personnalisable se trouve sous `[workflow]` au lieu de `[agent]` :
## Personnalisation des modules
```toml
# _bmad/custom/bmad-product-brief.toml
Les conseils sur la création de modules d'extension et la personnalisation des modules existants arrivent bientôt.
[workflow]
# Même sémantique préfixe/suffixe que les agents — s'exécute avant et après les étapes
# d'activation propres au workflow. Les overrides s'ajoutent aux valeurs par défaut.
activation_steps_prepend = [
"Charger {project-root}/docs/product/north-star-principles.md comme contexte.",
]
## Glossaire
activation_steps_append = []
[^1]: Persona : définition de la personnalité, du rôle et du style de communication d'un agent IA. Permet d'adapter le comportement et les réponses de l'agent selon les besoins du projet.
# Même sémantique littéral ou fichier que pour la variante agent. Chargé comme contexte
# fondamental pour la durée de l'exécution du workflow.
persistent_facts = [
"Tous les briefs doivent inclure une section explicite de risque réglementaire.",
"file:{project-root}/docs/compliance/product-brief-checklist.md",
]
# Scalaire : s'exécute une fois que le workflow a terminé son livrable principal. L'override prévaut.
on_complete = "Résumer le brief en trois points et proposer de l'envoyer par email via le skill gws-gmail-send."
```
Les mêmes conventions de champs s’appliquent indifféremment aux agents et aux workflows : `activation_steps_prepend`/`activation_steps_append`, `persistent_facts` (avec refs `file:`) et les tables `[[…]]` de style menu avec `code`/`id` pour la fusion par clé. Le résolveur applique les mêmes quatre règles structurelles quelle que soit la clé de premier niveau. Les références dans SKILL.md suivent l’espace de noms : `{workflow.activation_steps_prepend}`, `{workflow.persistent_facts}`, `{workflow.on_complete}`. Tout champ supplémentaire qu’un workflow expose (chemins de sortie, bascules, paramètres de revue, drapeaux d’étape) suit les mêmes règles de fusion basées sur la forme. Lisez le `customize.toml` du workflow pour voir ce qui est personnalisable.
### Ordre d’activation
Les workflows personnalisables exécutent leur activation dans une séquence fixe pour que vous sachiez exactement quand vos hooks se déclenchent :
1. Résoudre le bloc `[workflow]` (fusion base → équipe → utilisateur)
2. Exécuter `activation_steps_prepend` dans l’ordre
3. Charger `persistent_facts` comme contexte fondamental pour l’exécution
4. Charger la configuration (`_bmad/bmm/config.yaml`) et résoudre les variables standard (nom du projet, langues, chemins, date)
5. Saluer l’utilisateur
6. Exécuter `activation_steps_append` dans l’ordre
Après l’étape 6, le corps du workflow commence. Utilisez `activation_steps_prepend` quand vous avez besoin de contexte chargé avant que la salutation puisse être personnalisée ; utilisez `activation_steps_append` quand le chargement est lourd et que vous préférez que l’utilisateur voie la salutation d’abord.
### Périmètre de cette première passe
La personnalisation est déployée de manière incrémentale. Les champs documentés ci-dessus — `activation_steps_prepend`, `activation_steps_append`, `persistent_facts`, `on_complete` — sont la **surface de base** que chaque workflow personnalisable expose, et ils resteront stables d’une version à l’autre. Ils vous donnent un contrôle à grands traits dès aujourd’hui : injecter des étapes pré/post, épingler du contexte fondamental, déclencher des actions de suivi.
Au fil du temps, les workflows individuels exposeront des **points de personnalisation plus ciblés** adaptés à ce que le workflow fait réellement — par exemple des bascules par étape, des drapeaux d’étape, des chemins de templates de sortie ou des jalons de revue. Quand ils arriveront, ils viendront s’ajouter aux champs de base plutôt que de les remplacer, pour que les personnalisations que vous rédigez aujourd’hui continuent de fonctionner.
Si vous avez besoin d’un réglage précis qui n’est pas encore exposé, utilisez `activation_steps_*` et `persistent_facts` pour orienter le comportement, ou ouvrez une issue décrivant le point de personnalisation spécifique que vous souhaitez — ces demandes déterminent quels champs ciblés seront ajoutés ensuite.
## Configuration centrale
Le `customize.toml` par skill couvre le **comportement profond** (hooks, menus, persistent_facts, overrides de persona pour un seul agent ou workflow). Une surface séparée couvre l'**état transversal** — les réponses d’installation et le registre des agents que les skills externes comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation` consomment. Cette surface se trouve dans quatre fichiers TOML à la racine du projet :
```text
_bmad/config.toml (géré par l'installateur) périmètre équipe : réponses d'installation + registre des agents
_bmad/config.user.toml (géré par l'installateur) périmètre utilisateur : user_name, langue, niveau de skill
_bmad/custom/config.toml (rédigé manuellement) overrides d'équipe (versionnés dans git)
_bmad/custom/config.user.toml (rédigé manuellement) overrides personnels (ignoré par git)
```
### Fusion à quatre couches
```text
Priorité 1 (gagne) : _bmad/custom/config.user.toml
Priorité 2 : _bmad/custom/config.toml
Priorité 3 : _bmad/config.user.toml
Priorité 4 (base) : _bmad/config.toml
```
Mêmes règles structurelles que la personnalisation par skill (scalaires prévalent, tables fusionnent en profondeur, tableaux à clé `code`/`id` fusionnent par clé, autres tableaux s’ajoutent).
### Répartition du contenu
L’installateur répartit les réponses selon le `scope:` déclaré sur chaque prompt dans `module.yaml` :
- Les sections `[core]` et `[modules.<code>]` — réponses d’installation. Le scope `team` figure dans `_bmad/config.toml` ; le scope `user` figure dans `_bmad/config.user.toml`.
- `[agents.<code>]` — descripteur de l’agent (code, name, title, icon, description, team) extrait du bloc `agents:` de chaque `module.yaml`. Toujours de scope équipe.
### Règles de modification
- `_bmad/config.toml` et `_bmad/config.user.toml` sont **régénérés à chaque installation** à partir des réponses collectées pendant le processus d’installation. Traitez-les comme des sorties en lecture seule — les modifications directes seront écrasées à la prochaine installation. Pour changer une réponse d’installation de manière durable, relancez l’installateur (il se souvient de vos réponses précédentes comme valeurs par défaut) ou surchargez la valeur dans `_bmad/custom/config.toml`.
- `_bmad/custom/config.toml` et `_bmad/custom/config.user.toml` ne sont **jamais modifiés** par l’installateur. C’est l’espace approprié pour les agents personnalisés, les overrides de descripteur d’agent, les paramètres imposés par l’équipe et toute valeur que vous souhaitez figer indépendamment des réponses d’installation.
### Exemple — Renommer un agent
```toml
# _bmad/custom/config.toml (versionné dans git, s'applique à tous les développeurs)
[agents.bmad-agent-pm]
description = "PM Santé — sensible à la réglementation, orienté parties prenantes, questions orientées FDA en premier."
icon = "🏥"
```
Le résolveur fusionne par-dessus le `[agents.bmad-agent-pm]` écrit par l’installateur. `bmad-party-mode` et tout autre utilisateur du registre récupèrent automatiquement la nouvelle description.
### Exemple — Ajouter un agent fictif
```toml
# _bmad/custom/config.user.toml (personnel, ignoré par git)
[agents.kirk]
team = "startrek"
name = "Captain James T. Kirk"
title = "Starship Captain"
icon = "🖖"
description = "Commandant audacieux, enfreignant les règles. Parle en pauses dramatiques. Pense à voix haute sur le poids du commandement."
```
Pas de dossier de skill requis — le descripteur seul suffit pour que party-mode instancie Kirk comme voix. Filtrez par le champ `team` pour inviter uniquement l’équipage de l’Enterprise à une table ronde.
### Exemple — Override des paramètres d’installation du module
```toml
# _bmad/custom/config.toml
[modules.bmm]
planning_artifacts = "/shared/org-planning-artifacts"
```
L’override prévaut sur ce que chaque développeur a répondu lors de son installation locale. Utile pour figer les conventions d’équipe.
### Quelle surface utiliser pour quel besoin
| Besoin | Utiliser |
|----------------------------------------------------------|-------------------------------------------------------------------------------|
| Ajouter des appels d’outils MCP à chaque workflow de dev | Par skill : `_bmad/custom/bmad-agent-dev.toml` `persistent_facts` |
| Ajouter un élément de menu à un agent | Par skill : `_bmad/custom/bmad-agent-{role}.toml` `[[agent.menu]]` |
| Remplacer le template de sortie d’un workflow | Par skill : `_bmad/custom/{workflow}.toml` override scalaire |
| Renommer le descripteur public d’un agent | **Centrale** : `_bmad/custom/config.toml` `[agents.<code>]` |
| Ajouter un agent personnalisé ou fictif au registre | **Centrale** : `_bmad/custom/config.*.toml` nouvelle entrée `[agents.<code>]` |
| Figer les paramètres d’installation pour l’équipe | **Centrale** : `_bmad/custom/config.toml` `[modules.<code>]` ou `[core]` |
Utilisez les deux espaces dans le même projet selon vos besoins.
## Exemples concrets
Pour des recettes orientées entreprise (façonner un agent à travers tous les workflows qu’il gère, imposer les conventions d’organisation, publier les livrables vers Confluence et Jira, personnaliser le registre des agents et remplacer vos propres templates de sortie), consultez [Comment étendre BMad pour votre organisation](./expand-bmad-for-your-org.md).
## Dépannage
**La personnalisation n’apparaît pas ?**
- Vérifiez que votre fichier se trouve dans `_bmad/custom/` avec le nom de skill correct
- Vérifiez la syntaxe TOML : les chaînes doivent être entre guillemets, les en-têtes de table utilisent `[section]`, les tableaux de tables utilisent `[[section]]`, et toute clé scalaire ou de tableau pour une table doit apparaître *avant* toute `[[sous-table]]` de cette table dans le fichier
- Pour les agents, la personnalisation se trouve sous `[agent]` — les champs écrits sous cet en-tête appartiennent à `agent` jusqu’à ce qu’un autre en-tête de table commence
- Rappelez-vous que `agent.name` et `agent.title` sont en lecture seule ; les overrides n’ont aucun effet
**Les mises à jour ont cassé votre personnalisation ?**
- Avez-vous copié le `customize.toml` complet dans votre fichier d’override ? **Ne le faites pas.** Les fichiers d’override ne doivent contenir que les champs que vous modifiez. Une copie complète fige les anciennes valeurs par défaut et dérive silencieusement à chaque version. Réduisez votre override aux seuls deltas.
**Besoin de voir ce qui est personnalisable ?**
- Exécutez le skill `bmad-customize` — il énumère chaque skill personnalisable installé dans votre projet, montre lesquels ont déjà des overrides et vous guide pour en ajouter ou en modifier.
- Ou lisez directement le `customize.toml` du skill — chaque champ listé est personnalisable (sauf `name` et `title`)
**Besoin de réinitialiser ?**
- Supprimez votre fichier d’override de `_bmad/custom/` — le skill revient à ses valeurs par défaut intégrées.

58
docs/fr/how-to/established-projects.md
View File

@ -2,12 +2,12 @@
title: "Projets existants"
description: Comment utiliser la méthode BMad sur des bases de code existantes
sidebar:
order: 6
order: 7
---
Utilisez la méthode BMad efficacement lorsque vous travaillez sur des projets existants et des bases de code legacy.
Ce guide couvre le flux de travail essentiel pour l'intégration à des projets existants avec la méthode BMad.
Ce guide couvre le flux de travail essentiel pour l’intégration à des projets existants avec la méthode BMad.
:::note[Prérequis]
- méthode BMad installée (`npx bmad-method install`)
@ -15,18 +15,18 @@ Ce guide couvre le flux de travail essentiel pour l'intégration à des projets
- Accès à un IDE IA (Claude Code ou Cursor)
:::
## Étape 1 : Nettoyer les artefacts de planification terminés
## Étape 1 : Nettoyer les artefacts de planification terminés
Si vous avez terminé tous les epics et stories du PRD[^1] via le processus BMad, nettoyez ces fichiers. Archivez-les, supprimez-les, ou appuyez-vous sur l'historique des versions si nécessaire. Ne conservez pas ces fichiers dans :
Si vous avez terminé tous les epics et stories du PRD[^1] via le processus BMad, nettoyez ces fichiers. Archivez-les, supprimez-les, ou appuyez-vous sur l’historique des versions si nécessaire. Ne conservez pas ces fichiers dans :
- `docs/`
- `_bmad-output/planning-artifacts/`
- `_bmad-output/implementation-artifacts/`
## Étape 2 : Créer le contexte du projet
## Étape 2 : Créer le contexte du projet
:::tip[Recommandé pour les projets existants]
Générez `project-context.md` pour capturer les patterns et conventions de votre base de code existante. Cela garantit que les agents IA suivent vos pratiques établies lors de l'implémentation des modifications.
Générez `project-context.md` pour capturer les patterns et conventions de votre base de code existante. Cela garantit que les agents IA suivent vos pratiques établies lors de l’implémentation des modifications.
:::
Exécutez le workflow de génération de contexte du projet :
@ -37,7 +37,7 @@ bmad-generate-project-context
Cela analyse votre base de code pour identifier :
- La pile technologique et les versions
- Les patterns d'organisation du code
- Les patterns d’organisation du code
- Les conventions de nommage
- Les approches de test
- Les patterns spécifiques aux frameworks
@ -46,22 +46,22 @@ Vous pouvez examiner et affiner le fichier généré, ou le créer manuellement
[En savoir plus sur le contexte du projet](../explanation/project-context.md)
## Étape 3 : Maintenir une documentation de projet de qualité
## Étape 3 : Maintenir une documentation de projet de qualité
Votre dossier `docs/` doit contenir une documentation succincte et bien organisée qui représente fidèlement votre projet :
- L'intention et la justification métier
- L’intention et la justification métier
- Les règles métier
- L'architecture
- L’architecture
- Toute autre information pertinente sur le projet
Pour les projets complexes, envisagez d'utiliser le workflow `bmad-document-project`. Il offre des variantes d'exécution qui analyseront l'ensemble de votre projet et documenteront son état actuel réel.
Pour les projets complexes, envisagez d’utiliser le workflow `bmad-document-project`. Il offre des variantes d’exécution qui analyseront l’ensemble de votre projet et documenteront son état actuel réel.
## Étape 4 : Obtenir de l'aide
## Étape 4 : Obtenir de l’aide
### BMad-Help : Votre point de départ
### BMad-Help : Votre point de départ
**Exécutez `bmad-help` chaque fois que vous n'êtes pas sûr de la prochaine étape.** Ce guide intelligent :
**Exécutez `bmad-help` chaque fois que vous n’êtes pas sûr de la prochaine étape.** Ce guide intelligent :
- Inspecte votre projet pour voir ce qui a déjà été fait
- Affiche les options basées sur vos modules installés
@ -73,25 +73,25 @@ bmad-help Quelle est la différence entre quick-dev et la méthode complète ?
bmad-help Montre-moi quels workflows sont disponibles
```
BMad-Help s'exécute également **automatiquement à la fin de chaque workflow**, fournissant des conseils clairs sur exactement quoi faire ensuite.
BMad-Help s’exécute également **automatiquement à la fin de chaque workflow**, fournissant des conseils clairs sur exactement quoi faire ensuite.
### Choisir votre approche
Vous avez deux options principales selon l'ampleur des modifications :
Vous avez deux options principales selon l’ampleur des modifications :
| Portée | Approche recommandée |
| ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Petites mises à jour ou ajouts** | Exécutez `bmad-quick-dev` pour clarifier l'intention, planifier, implémenter et réviser dans un seul workflow. La méthode BMad complète en quatre phases est probablement excessive. |
| **Modifications ou ajouts majeurs** | Commencez avec la méthode BMad, en appliquant autant ou aussi peu de rigueur que nécessaire. |
| Portée | Approche recommandée |
|-------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Petites mises à jour ou ajouts** | Exécutez `bmad-quick-dev` pour clarifier l’intention, planifier, implémenter et réviser dans un seul workflow. La méthode BMad complète en quatre phases est probablement excessive. |
| **Modifications ou ajouts majeurs** | Commencez avec la méthode BMad, en appliquant autant ou aussi peu de rigueur que nécessaire. |
### Pendant la création du PRD
Lors de la création d'un brief ou en passant directement au PRD[^1], assurez-vous que l'agent :
Lors de la création d’un brief ou en passant directement au PRD[^1], assurez-vous que l’agent :
- Trouve et analyse votre documentation de projet existante
- Lit le contexte approprié sur votre système actuel
Vous pouvez guider l'agent explicitement, mais l'objectif est de garantir que la nouvelle fonctionnalité s'intègre bien à votre système existant.
Vous pouvez guider l’agent explicitement, mais l’objectif est de garantir que la nouvelle fonctionnalité s’intègre bien à votre système existant.
### Considérations UX
@ -100,23 +100,23 @@ Le travail UX[^2] est optionnel. La décision dépend non pas de savoir si votre
- Si vous allez travailler sur des modifications UX
- Si des conceptions ou patterns UX significatifs sont nécessaires
Si vos modifications se résument à de simples mises à jour d'écrans existants qui vous satisfont, un processus UX complet n'est pas nécessaire.
Si vos modifications se résument à de simples mises à jour d’écrans existants qui vous satisfont, un processus UX complet n’est pas nécessaire.
### Considérations d'architecture
### Considérations d’architecture
Lors de la création de l'architecture, assurez-vous que l'architecte :
Lors de la création de l’architecture, assurez-vous que l’architecte :
- Utilise les fichiers documentés appropriés
- Analyse la base de code existante
Soyez particulièrement attentif ici pour éviter de réinventer la roue ou de prendre des décisions qui ne s'alignent pas avec votre architecture existante.
Soyez particulièrement attentif ici pour éviter de réinventer la roue ou de prendre des décisions qui ne s’alignent pas avec votre architecture existante.
## Plus d'informations
## Plus d’informations
- **[Corrections rapides](./quick-fixes.md)** - Corrections de bugs et modifications ad-hoc
- **[FAQ Projets existants](../explanation/established-projects-faq.md)** - Questions courantes sur le travail sur des projets établis
## Glossaire
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
[^2]: UX (User Experience) : expérience utilisateur, englobant l'ensemble des interactions et perceptions d'un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d'utilisation.
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
[^2]: UX (User Experience) : expérience utilisateur, englobant l’ensemble des interactions et perceptions d’un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d’utilisation.

328
docs/fr/how-to/expand-bmad-for-your-org.md Normal file
View File

@ -0,0 +1,328 @@
---
title: 'Comment étendre BMad pour votre organisation'
description: Six patterns de personnalisation qui remodèlent BMad sans créer de fork — règles applicables aux agents, conventions de workflow, publication externe, remplacements de templates, modifications du registre des agents et patterns d’intégration avancés
sidebar:
order: 11
---
Le système de personnalisation de BMad permet à une organisation d’adapter les comportements sans modifier les fichiers installés ni forker les skills. Ce guide présente six recettes qui couvrent la plupart des besoins en entreprise.
:::note[Prérequis]
- BMad installé dans votre projet (voir [Comment installer BMad](./install-bmad.md))
- Connaissance du modèle de personnalisation (voir [Comment personnaliser BMad](./customize-bmad.md))
- Python 3.11+ sur le PATH (pour le résolveur — bibliothèque standard uniquement, pas de `pip install`)
:::
:::tip[Appliquer ces recettes]
Les **recettes par skill** ci-dessous (Recettes 1–4) peuvent être appliquées en exécutant le skill `bmad-customize` et en décrivant l’intention — il sélectionnera le bon point de personnalisation, générera le fichier d’override et vérifiera la fusion. La Recette 5 (overrides de la configuration centrale du registre des agents) n’est pas couverte par la v1 du skill et reste rédigée manuellement. Les recettes ici constituent la source de vérité sur *quoi* personnaliser ; `bmad-customize` gère le *comment* pour la surface agent/workflow.
:::
## Le modèle mental à trois couches
Avant de choisir une recette, comprenez où votre override se situe :
| Couche | Où vivent les overrides | Périmètre |
|----------------------------------------------|-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
| **Agent** (ex. Amelia, Mary, John) | Section `[agent]` de `_bmad/custom/bmad-agent-{role}.toml` | Se propage avec le persona dans **chaque workflow que l’agent dispatche** |
| **Workflow** (ex. product-brief, create-prd) | Section `[workflow]` de `_bmad/custom/{workflow-name}.toml` | S’applique uniquement à l’exécution de ce workflow |
| **Configuration centrale** | `[agents.*]`, `[core]`, `[modules.*]` dans `_bmad/custom/config.toml` | Registre des agents (qui est disponible pour party-mode, retrospective, elicitation), paramètres d’installation figés pour toute l’organisation |
En règle générale : si la règle doit s’appliquer partout où un ingénieur travaille sur le développement, personnalisez l'**agent dev**. Si elle s’applique uniquement quand quelqu’un rédige un product brief, personnalisez le **workflow product-brief**. Si elle change *qui participe* (renommer un agent, ajouter une voix personnalisée, imposer un chemin d’artefact partagé), modifiez la **configuration centrale**.
## Recette 1 : Façonner un agent à travers tous les workflows qu’il dispatche
**Cas d’usage :** Standardiser l’utilisation des outils et les intégrations avec les systèmes externes pour que chaque workflow dispatché par un agent hérite du comportement. C’est le pattern le plus impactant.
**Exemple : Amelia (agent dev) utilise toujours Context7 pour la documentation des bibliothèques, et se rabat sur Linear quand une story n’est pas trouvée dans la liste des epics.**
```toml
# _bmad/custom/bmad-agent-dev.toml
[agent]
# Appliqué à chaque activation. Se propage dans dev-story, quick-dev,
# create-story, code-review, qa-generate — chaque skill qu'Amelia dispatche.
persistent_facts = [
"Pour toute recherche de documentation sur une bibliothèque (React, TypeScript, Zod, Prisma, etc.), appeler l'outil MCP context7 (`mcp__context7__resolve_library_id` puis `mcp__context7__get_library_docs`) avant de s'appuyer sur les connaissances des données d'entraînement. Les docs à jour priment sur les API mémorisées.",
"Quand une référence de story n'est pas trouvée dans {planning_artifacts}/epics-and-stories.md, chercher dans Linear via `mcp__linear__search_issues` en utilisant l'ID ou le titre de la story avant de demander à l'utilisateur de clarifier. Si Linear renvoie un résultat, le considérer comme la source de référence pour la story.",
]
```
**Pourquoi ça marche :** Deux phrases suffisent à reconfigurer tous les workflows de dev de l’organisation, sans duplication par workflow ni modification du code source. Chaque nouvel ingénieur qui clone le dépôt hérite automatiquement des conventions.
**Fichier d’équipe vs fichier personnel :**
- `bmad-agent-dev.toml` : versionné dans git ; s’applique à toute l’équipe
- `bmad-agent-dev.user.toml` : ignoré par git ; préférences personnelles ajoutées par-dessus
## Recette 2 : Imposer les conventions de l’organisation dans un workflow spécifique
**Cas d’usage :** Façonner le *contenu* de la sortie d’un workflow pour qu’il réponde aux exigences de conformité, d’audit ou des consommateurs en aval.
**Exemple : chaque product brief doit inclure des champs de conformité, et l’agent connaît les conventions de publication de l’organisation.**
```toml
# _bmad/custom/bmad-product-brief.toml
[workflow]
persistent_facts = [
"Chaque brief doit inclure un champ 'Propriétaire', un champ 'Release cible' et un champ 'Statut de la revue de sécurité'.",
"Les briefs non commerciaux (outils internes, projets de recherche) doivent toujours inclure une section 'valeur utilisateur', mais peuvent omettre la différenciation concurrentielle.",
"file:{project-root}/docs/enterprise/brief-publishing-conventions.md",
]
```
**Ce qui se passe :** Les faits sont chargés durant l’étape 3 de l’activation du workflow. Quand l’agent rédige le brief, il connaît les champs requis et le document de conventions enterprise. La valeur par défaut livrée (`file:{project-root}/**/project-context.md`) se charge toujours, car il s’agit d’un ajout.
## Recette 3 : Publier les livrables finis vers des systèmes externes
**Cas d’usage :** Une fois le livrable produit, le publier automatiquement vers les systèmes de référence de l’entreprise (Confluence, Notion, SharePoint) et créer des tickets de suivi (Jira, Linear, Asana).
**Exemple : les briefs sont automatiquement publiés vers Confluence et proposent la création facultative d’un epic Jira.**
```toml
# _bmad/custom/bmad-product-brief.toml
[workflow]
# Hook terminal. L'override scalaire remplace intégralement la valeur par défaut vide.
on_complete = """
Publier et proposer le suivi :
1. Lire le chemin du fichier brief finalisé depuis l'étape précédente.
2. Appeler `mcp__atlassian__confluence_create_page` avec :
- space : "PRODUCT"
- parent : "Product Briefs"
- title : le titre du brief
- body : le contenu markdown du brief
Capturer l'URL de la page renvoyée.
3. Informer l'utilisateur : "Brief publié sur Confluence : <url>".
4. Demander : "Voulez-vous que j'ouvre un epic Jira pour ce brief maintenant ?"
5. Si oui, appeler `mcp__atlassian__jira_create_issue` avec :
- type : "Epic"
- project : "PROD"
- summary : le titre du brief
- description : un résumé court accompagné d'un lien vers la page Confluence.
Signaler la clé et l'URL de l'epic.
6. Si non, se terminer proprement.
Si l'un des outils MCP échoue, signaler l'échec, afficher le chemin du brief,
et demander à l'utilisateur de publier manuellement.
"""
```
**Pourquoi `on_complete` et pas `activation_steps_append` :** `on_complete` s’exécute exactement une fois, au stade terminal, après que le workflow a écrit sa sortie principale. C’est le bon moment pour publier des artefacts. `activation_steps_append` s’exécute à chaque activation, avant que le workflow ne fasse son travail.
**Arbitrages :**
- **La publication Confluence est non-destructive** et s’exécute toujours à la fin
- **La création d’epic Jira est visible par toute l’équipe** et déclenche un processus de planification de sprint, conditionnez-la donc à la confirmation de l’utilisateur
- **Dégradation gracieuse :** si les outils MCP échouent, passer la main à l’utilisateur plutôt que de silencieusement abandonner le livrable
## Recette 4 : Remplacer le template de sortie par le vôtre
**Cas d’usage :** La structure de sortie par défaut ne correspond pas au format attendu par votre organisation, ou différentes organisations dans le même dépôt ont besoin de templates différents.
**Exemple : pointer le workflow product-brief vers un template appartenant à l’entreprise.**
```toml
# _bmad/custom/bmad-product-brief.toml
[workflow]
brief_template = "{project-root}/docs/enterprise/brief-template.md"
```
**Comment ça marche :** Le `customize.toml` du workflow est fourni avec `brief_template = "resources/brief-template.md"` (chemin relatif, résolu depuis la racine du skill). Votre override pointe vers un fichier sous `{project-root}`, donc l’agent lit votre template à l’étape 4 au lieu de celui livré par défaut.
**Conseils pour la rédaction de templates :**
- Gardez les templates dans `{project-root}/docs/` ou `{project-root}/_bmad/custom/templates/` pour qu’ils soient versionnés avec le fichier d’override
- Utilisez les mêmes conventions structurelles que le template livré (titres de sections, frontmatter) ; l’agent s’adapte à ce qu’il trouve
- Pour les dépôts multi-organisations, utilisez `.user.toml` pour permettre à chaque équipe de pointer vers ses propres templates sans toucher au fichier d’équipe versionné dans git
## Recette 5 : Personnaliser le registre des agents
**Cas d’usage :** Changer *qui sera présent dans la pièce* pour les skills basés sur le registre comme `bmad-party-mode`, `bmad-retrospective` et `bmad-advanced-elicitation`, sans modifier le code source ni forker. Voici trois variantes courantes.
### 5a. Renommer un agent BMad pour toute l’organisation
Chaque agent réel possède un descripteur que l’installateur synthétise à partir de `module.yaml`. Surchargez-le pour changer la voix et le cadrage pour tous les consommateurs du registre :
```toml
# _bmad/custom/config.toml (versionné dans git — s'applique à tous les développeurs)
[agents.bmad-agent-analyst]
description = "Mary l'Analyste d'Affaires sensible à la réglementation — s'inspire de Porter et Minto, mais vit et respire les pistes d'audit FDA. Parle comme un expert en criminalistique présentant un dossier."
```
Party-mode génère Mary avec la nouvelle description. L’activation de l’analyste elle-même fonctionne toujours normalement car le comportement de Mary se trouve dans son `customize.toml` par skill. Cet override change la façon dont **les skills externes la perçoivent et la présentent**, pas la façon dont elle travaille en interne.
### 5b. Ajouter un agent fictif ou personnalisé
Un descripteur complet suffit pour les fonctionnalités basées sur le registre, sans dossier de skill nécessaire. Utile pour varier les personnalités en mode party ou en session de brainstorming :
```toml
# _bmad/custom/config.user.toml (personnel — ignoré par git)
[agents.spock]
team = "startrek"
name = "Commander Spock"
title = "Science Officer"
icon = "🖖"
description = "Logique d'abord, émotion réprimée. Commence ses observations par 'Fascinant.' Ne force jamais le trait. Fait contrepoids à tout argument reposant sur l'intuition."
[agents.mccoy]
team = "startrek"
name = "Dr. Leonard McCoy"
title = "Chief Medical Officer"
icon = "⚕️"
description = "Chaleur du médecin de campagne, caractère explosif. 'Bon sang Jim, je suis un docteur pas un ___.' Contrepoids éthique à Spock."
```
Demandez à party-mode d'« inviter l’équipage de l’Enterprise ». Il filtre par `team = "startrek"` et génère Spock et McCoy avec ces descripteurs. Les agents BMad réels (Mary, Amelia) peuvent se retrouver à la même table si vous les invitez.
### 5c. Figer les paramètres d’installation de l’équipe
L’installateur demande à chaque développeur des valeurs comme le chemin `planning_artifacts`. Quand l’organisation a besoin d’une réponse partagée, figez-la dans la configuration centrale — la réponse locale de chaque développeur est surchargée au moment de la résolution :
```toml
# _bmad/custom/config.toml
[modules.bmm]
planning_artifacts = "{project-root}/shared/planning"
implementation_artifacts = "{project-root}/shared/implementation"
[core]
document_output_language = "English"
```
Les paramètres personnels comme `user_name`, `communication_language` ou `user_skill_level` restent dans leur propre fichier `_bmad/config.user.toml` de chaque développeur. Le fichier d’équipe ne doit pas les modifier.
**Pourquoi la configuration centrale vs le customize.toml par agent :** Les fichiers par agent façonnent la façon dont *un seul* agent se comporte quand il s’active. La configuration centrale façonne ce que les consommateurs du registre *voient* : quels agents existent, comment ils s’appellent, à quelle équipe ils appartiennent, et les paramètres d’installation partagés sur lesquels tout le dépôt s’accorde. Deux surfaces, des rôles différents.
## Renforcer les règles globales dans le fichier de session de votre IDE
Les personnalisations BMad se chargent quand un skill est activé. Beaucoup d’outils IDE chargent aussi un fichier d’instructions global au **début de chaque session**, avant tout skill (`CLAUDE.md`, `AGENTS.md`, `.cursor/rules/`, `.github/copilot-instructions.md`, etc.). Pour les règles qui doivent s’appliquer même en dehors des skills BMad, reproduisez-y les plus critiques.
**Quand les utiliser ensemble :**
- Une règle est suffisamment importante pour qu’une conversation simple (sans skill actif) doive la respecter
- Vous voulez une double sécurisation parce que les défauts des données d’entraînement pourraient autrement détourner le modèle
- La règle est assez concise pour être répétée sans alourdir le fichier de session
**Exemple : une ligne dans le `CLAUDE.md` du dépôt renforçant la règle de l’agent dev de la Recette 1.**
```markdown
<!-- Toute lecture de documentation de bibliothèque passe par l'outil MCP context7
(`mcp__context7__resolve_library_id` puis `mcp__context7__get_library_docs`)
avant de s'appuyer sur les connaissances des données d'entraînement. -->
```
Une phrase, chargée à chaque session. Elle s’associe à la personnalisation `bmad-agent-dev.toml` pour que la règle s’applique à la fois dans les workflows d’Amelia et lors des chats ad hoc avec l’assistant. Chaque couche possède son propre périmètre :
| Couche | Périmètre | Utilisée pour |
|----------------------------------------------------|----------------------------------------------------------|-------------------------------------------------------------------------|
| Fichier de session IDE (`CLAUDE.md` / `AGENTS.md`) | Chaque session, avant toute activation de skill | Règles courtes et universelles qui doivent survivre hors de BMad |
| Personnalisation d’agent BMad | Chaque workflow que l’agent dispatche | Comportement spécifique au persona de l’agent |
| Personnalisation de workflow BMad | Une exécution de workflow | Forme de sortie spécifique au workflow, hooks de publication, templates |
| Configuration centrale BMad | Registre des agents + paramètres d’installation partagés | Qui est dans la pièce et quels chemins partagés l’équipe utilise |
Gardez le fichier IDE **concis**. Une douzaine de lignes bien choisies sont plus efficaces qu’une liste étendue. Les modèles le lisent à chaque tour, et le superflu noie l’information utile.
## Recette 6 : Patterns d’intégration avancés
Plusieurs workflows BMad exposent une surface de configuration plus riche au-delà des bases couvertes dans les Recettes 1–5. Ces patterns — sources de connaissance à la demande, publication automatique des livrables, standards de documentation à la finalisation et templates interchangeables — apparaissent dans plusieurs workflows. Consultez le `customize.toml` d’un workflow pour voir quels champs il expose ; les exemples ci-dessous utilisent `bmad-prd` car il les expose tous, mais les mêmes patterns s’appliquent partout où le champ apparaît.
### Sources de connaissance à la demande (`external_sources`)
Connectez le workflow à des bases de connaissances internes, des bases de données concurrentielles ou des référentiels de conformité. L’agent les consulte à la demande quand la conversation révèle un besoin correspondant — jamais par anticipation.
```toml
# _bmad/custom/bmad-prd.toml (même pattern pour tout workflow exposant external_sources)
[workflow]
external_sources = [
"Quand l'utilisateur mentionne un concurrent ou un segment de marché, interroger corp:competitive_db (category={project_name}) avant de rédiger la section différenciation.",
"Pour les domaines réglementés (santé, fintech, éducation), consulter corp:compliance_reference avant de rédiger les sections spécifiques au domaine.",
]
```
Chaque entrée est une directive en langage naturel nommant l’outil MCP, la condition de déclenchement et les champs nécessaires. Si l’outil n’est pas disponible à l’exécution, le workflow se rabat sur le comportement standard et signale l’écart.
### Publication automatique des livrables (`external_handoffs`)
Acheminez les artefacts terminés vers les systèmes de référence externes après la finalisation du workflow. Contrairement à `on_complete` (Recette 3), `external_handoffs` est un tableau d’ajout dédié — les entrées d’équipe s’accumulent et chaque handoff se déclenche indépendamment avec dégradation progressive si un outil est indisponible.
```toml
# _bmad/custom/bmad-prd.toml (même pattern pour tout workflow exposant external_handoffs)
[workflow]
external_handoffs = [
"Après la finalisation, uploader prd.md et addendum.md vers Confluence via corp:confluence_upload (space_key='PROD', parent_page='PRDs', label='prd', author={user_name}). Capturer et afficher l'URL de la page renvoyée.",
"Répliquer vers Notion via notion:create_page (database_id='abc123', title='PRD: ' + {project_name}).",
]
```
Si un outil nommé est indisponible, le handoff est ignoré et signalé — les fichiers locaux existent toujours indépendamment.
### Standards de documentation à la finalisation (`doc_standards`)
Appliquez les standards rédactionnels de l’organisation aux documents à destination des utilisateurs à la finalisation, après que le contenu est complet mais avant que l’utilisateur ne voie le livrable. Chaque entrée est une directive `skill:`, `file:` ou en texte brut ; les passes s’exécutent comme des sous-agents parallèles.
```toml
# _bmad/custom/bmad-prd.toml (même pattern pour tout workflow exposant doc_standards)
[workflow]
doc_standards = [
"file:{project-root}/docs/enterprise/voice-and-tone.md",
"Toutes les dates doivent utiliser le format ISO 8601 (AAAA-MM-JJ).",
"Remplacer toute utilisation de 'tirer parti de' par 'utiliser'.",
]
```
`doc_standards` est un tableau d’ajout — les entrées d’équipe s’ajoutent aux valeurs par défaut livrées par le workflow. Les passes structurelles larges doivent venir avant les passes rédactionnelles plus ciblées.
### Templates et checklists interchangeables
Les workflows qui produisent des documents structurés exposent généralement des chemins de templates et de checklists comme scalaires surchargeables. Pointez-les vers des fichiers appartenant à l’organisation sous `{project-root}` pour imposer une structure différente sans modifier le code source.
```toml
# _bmad/custom/bmad-prd.toml
[workflow]
# Structure de PRD pour secteur réglementé
prd_template = "{project-root}/docs/enterprise/prd-template-hipaa.md"
# Critères de validation spécifiques à l'organisation
validation_checklist = "{project-root}/docs/enterprise/prd-checklist-regulated.md"
```
L’agent s’adapte à la structure définie par le template. Gardez les templates sous `{project-root}/docs/` ou `{project-root}/_bmad/custom/templates/` pour qu’ils soient versionnés avec le fichier d’override. Pour les dépôts multi-organisations, utilisez `.user.toml` pour permettre aux équipes de pointer vers leurs propres templates sans toucher au fichier d’équipe versionné dans git.
## Combiner les recettes
Les six recettes se combinent librement. Un override entreprise réaliste pour `bmad-product-brief` pourrait définir `persistent_facts` (Recette 2), `on_complete` (Recette 3) et `brief_template` (Recette 4) dans un seul fichier. La règle au niveau agent (Recette 1) se trouve dans un fichier séparé sous le nom de l’agent, la configuration centrale (Recette 5) fige le registre partagé et les paramètres d’équipe, les patterns d’intégration avancés (Recette 6) configurent les sources externes et les handoffs, et toutes les couches s’appliquent en parallèle.
```toml
# _bmad/custom/bmad-product-brief.toml (niveau workflow)
[workflow]
persistent_facts = ["..."]
brief_template = "{project-root}/docs/enterprise/brief-template.md"
on_complete = """ ... """
```
```toml
# _bmad/custom/bmad-agent-analyst.toml (niveau agent — Mary dispatche product-brief)
[agent]
persistent_facts = ["Toujours inclure une section 'Revue réglementaire' quand le domaine implique la santé, la finance ou les données d'enfants."]
```
Résultat : Mary charge la règle de revue réglementaire à l’activation de son persona. Quand l’utilisateur choisit le product brief dans le menu, le workflow charge ses propres conventions par-dessus, écrit avec le template enterprise et publie vers Confluence à la fin. Chaque couche contribue, et aucune n’a nécessité de modifier le code source de BMad.
## Dépannage
**L’override ne prend pas effet ?** Vérifiez que le fichier se trouve sous `_bmad/custom/` avec le nom exact du répertoire du skill (ex. `bmad-agent-dev.toml`, pas `bmad-dev.toml`). Voir [Comment personnaliser BMad](./customize-bmad.md#dépannage).
**Nom d’outil MCP inconnu ?** Utilisez le nom exact que le serveur MCP expose dans la session en cours. Demandez à Claude Code de lister les outils MCP disponibles en cas de doute. Les noms codés en dur dans `persistent_facts` ou `on_complete` ne fonctionneront pas si le serveur MCP n’est pas connecté.
**Le pattern ne s’applique pas à ma configuration ?** Les recettes ci-dessus sont illustratives. L’infrastructure sous-jacente (fusion à trois couches, règles structurelles, agent traversant les workflows) supporte de nombreux patterns supplémentaires ; composez-les selon vos besoins.

66
docs/fr/how-to/get-answers-about-bmad.md
View File

@ -2,14 +2,14 @@
title: "Comment obtenir des réponses à propos de BMad"
description: Utiliser un LLM pour répondre rapidement à vos questions sur BMad
sidebar:
order: 4
order: 5
---
Utilisez l'aide intégrée de BMad, la documentation source ou la communauté pour obtenir des réponses — du plus rapide au plus approfondi.
Utilisez l’aide intégrée de BMad, la documentation source ou la communauté pour obtenir des réponses — du plus rapide au plus approfondi.
## 1. Demandez à BMad-Help
Le moyen le plus rapide d'obtenir des réponses. Le skill `bmad-help` est disponible directement dans votre session IA et répond à plus de 80 % des questions — il inspecte votre projet, voit ce que vous avez accompli et vous dit quoi faire ensuite.
Le moyen le plus rapide d’obtenir des réponses. Le skill `bmad-help` est disponible directement dans votre session IA et répond à plus de 80 % des questions — il inspecte votre projet, voit ce que vous avez accompli et vous dit quoi faire ensuite.
```
bmad-help J'ai une idée de SaaS et je connais toutes les fonctionnalités. Par où commencer ?
@ -23,58 +23,58 @@ Vous pouvez également utiliser `/bmad-help` ou `$bmad-help` selon votre platefo
## 2. Approfondissez avec les sources
BMad-Help s'appuie sur votre configuration installée. Pour les questions sur les éléments internes de BMad, son historique ou son architecture — ou si vous faites des recherches sur BMad avant de l'installer — pointez votre IA directement vers les sources.
BMad-Help s’appuie sur votre configuration installée. Pour les questions sur les éléments internes de BMad, son historique ou son architecture — ou si vous faites des recherches sur BMad avant de l’installer — pointez votre IA directement vers les sources.
Clonez ou ouvrez le [dépôt BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) et posez vos questions à votre IA. Tout outil capable d'utiliser des agents (Claude Code, Cursor, Windsurf, etc.) peut lire les sources et répondre directement à vos questions.
Clonez ou ouvrez le [dépôt BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) et posez vos questions à votre IA. Tout outil capable d’utiliser des agents (Claude Code, Cursor, Windsurf, etc.) peut lire les sources et répondre directement à vos questions.
:::note[Exemple]
**Q :** "Quel est le moyen le plus rapide de construire quelque chose avec BMad ?"
**Q :** « Quel est le moyen le plus rapide de construire quelque chose avec BMad ? »
**R :** Utilisez le flux rapide : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
**R :** Utilisez le flux rapide : Lancez `bmad-quick-dev` — il clarifie votre intention, planifie, implémente, révise et présente les résultats dans un seul workflow, en sautant les phases de planification complètes.
:::
**Conseils pour de meilleures réponses :**
**Conseils pour de meilleures réponses :**
- **Soyez précis** — "Que fait l'étape 3 du workflow PRD ?" est mieux que "Comment fonctionne le PRD ?"
- **Soyez précis** — « Que fait l’étape 3 du workflow PRD ? » est mieux que « Comment fonctionne le PRD ? »
- **Vérifiez les affirmations surprenantes** — Les LLM font parfois des erreurs. Consultez le fichier source ou posez la question sur Discord.
### Vous n'utilisez pas d'agent ? Utilisez le site de documentation
### Vous n’utilisez pas d’agent ? Utilisez le site de documentation
Si votre IA ne peut pas lire des fichiers locaux (ChatGPT, Claude.ai, etc.), importez [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) dans votre session — c'est un instantané en un seul fichier de la documentation BMad.
Si votre IA ne peut pas lire des fichiers locaux (ChatGPT, Claude.ai, etc.), importez [llms-full.txt](https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt) dans votre session — c’est un instantané en un seul fichier de la documentation BMad.
## 3. Demandez à quelqu'un
## 3. Demandez à quelqu’un
Si ni BMad-Help ni la source n'ont répondu à votre question, vous avez maintenant une bien meilleure question à poser.
Si ni BMad-Help ni la source n’ont répondu à votre question, vous avez maintenant une bien meilleure question à poser.
| Canal | Utilisé pour |
| ------------------------- | ------------------------------------------- |
| Forum `help-requests` | Questions |
| `#suggestions-feedback` | Idées et demandes de fonctionnalités |
| Canal | Utilisé pour |
|-------------------------|--------------------------------------|
| Forum `help-requests` | Questions |
| `#suggestions-feedback` | Idées et demandes de fonctionnalités |
**Discord :** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
**Discord :** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
**GitHub Issues :** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
*Toi !*
*Bloqué*
*dans la file d'attente—*
*qui*
*attends-tu ?*
**GitHub Issues :** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
*Toi !*
*Bloqué*
*dans la file d’attente—*
*qui*
*attends-tu ?*
*La source*
*est là,*
*facile à voir !*
*est là,*
*facile à voir !*
*Pointez*
*votre machine.*
*Libérez-la.*
*votre machine.*
*Libérez-la.*
*Elle lit.*
*Elle parle.*
*Demandez—*
*Elle parle.*
*Demandez—*
*Pourquoi attendre*
*demain*
*quand tu as déjà*
*cette journée ?*
*demain*
*quand tu as déjà*
*cette journée ?*
*—Claude*

298
docs/fr/how-to/install-bmad.md
View File

@ -1,116 +1,266 @@
---
title: "Comment installer BMad"
description: Guide étape par étape pour installer BMad dans votre projet
description: Installer, mettre à jour et épingler BMad pour le développement local, les équipes et CI
sidebar:
order: 1
---
Utilisez la commande `npx bmad-method install` pour configurer BMad dans votre projet avec votre choix de modules et d'outils d'IA.
Utilisez `npx bmad-method install` pour configurer BMad dans votre projet. Une seule commande gère les premières installations, les mises à niveau, le changement de canal et les exécutions CI scriptées. Cette page couvre tout cela.
Si vous souhaitez utiliser un installateur non interactif et fournir toutes les options d'installation en ligne de commande, consultez [ce guide](./non-interactive-installation.md).
## Quand l'utiliser
## Quand l’utiliser
- Démarrer un nouveau projet avec BMad
- Ajouter BMad à une base de code existante
- Mettre à jour une installation BMad existante
- Ajouter ou retirer des modules sur une installation existante
- Basculer un module sur main-HEAD ou l’épingler à une version spécifique
- Scripter des installations pour des pipelines CI, des Dockerfiles ou des déploiements en entreprise
:::note[Prérequis]
- **Node.js** 20.12+ (requis pour l'installateur)
- **Git** (recommandé)
- **Outil d'IA** (Claude Code, Cursor, ou similaire)
- **Node.js** 20.12+ (requis pour l’installateur)
- **Git** (pour cloner les modules externes)
- **Un outil d’IA** tel que Claude Code ou Cursor (exécutez `npx bmad-method install --list-tools` pour voir tous les outils supportés)
:::
## Étapes
### 1. Lancer l'installateur
## Première installation (méthode rapide)
```bash
npx bmad-method install
```
:::tip[Vous voulez la dernière version préliminaire ?]
Utilisez le dist-tag `next` :
L’assistant interactif vous pose cinq questions :
1. Le répertoire d’installation (par défaut le répertoire de travail courant)
2. Quels modules installer (cases à cocher pour core, bmm, bmb, cis, gds, tea)
3. **« Ready to install (all stable)? »** — Oui accepte le dernier tag publié pour chaque module externe
4. Quels outils/IDE d’IA intégrer (claude-code, cursor et d’autres)
5. La configuration par module (nom, langue, dossier de sortie)
En acceptant les valeurs par défaut, vous obtenez la dernière version stable de chaque module, configurée pour votre outil choisi.
:::tip[Vous voulez juste la dernière préversion ?]
```bash
npx bmad-method@next install
```
Cela vous permet d'obtenir les nouvelles modifications plus tôt, avec un risque plus élevé de changements que l'installation par défaut.
Exécute l’installateur de préversion, qui fournit un snapshot plus récent de core et bmm. Davantage de changements, avec un délai réduit entre le développement et la publication.
:::
:::tip[Version de développement]
Pour installer la dernière version depuis la branche main (peut être instable) :
## Choisir une version spécifique
Deux axes indépendants contrôlent ce qui se retrouve sur le disque.
### Axe 1 : canaux des modules externes
Chaque module externe — bmb, cis, gds, tea, et tout module communautaire — s’installe via l’un des trois canaux suivants :
| Canal | Ce qui est installé | Pour qui |
|-------------------|--------------------------------------------------------------------------------------|-----------------------------------------------|
| `stable` (défaut) | Le plus haut tag semver publié. Les préversions comme `v2.0.0-alpha.1` sont exclues. | La plupart des utilisateurs |
| `next` | Le HEAD de la branche main au moment de l’installation | Contributeurs, early adopters |
| `pinned` | Un tag spécifique de votre choix | Installations entreprise, reproductibilité CI |
Les canaux sont définis module par module. Vous pouvez exécuter bmb sur `next` tout en laissant cis sur `stable` — les options ci-dessous permettent de les combiner librement.
### Axe 2 : version du binaire de l’installateur
Le paquet npm `bmad-method` lui-même a deux dist-tags :
| Commande | Ce que vous obtenez |
|---------------------------------------|---------------------------------------------------------------------------------------|
| `npx bmad-method install` (`@latest`) | Dernière version stable de l’installateur |
| `npx bmad-method@next install` | Dernière préversion de l’installateur, publiée automatiquement à chaque push sur main |
**Le binaire de l’installateur détermine vos versions de core et bmm.** Ces deux modules sont embarqués dans le paquet de l’installateur plutôt que clonés depuis des dépôts séparés.
### Pourquoi core et bmm n’ont pas leur propre canal
Ils sont liés au binaire de l’installateur que vous avez exécuté :
- `npx bmad-method install` → core et bmm stables les plus récents
- `npx bmad-method@next install` → core et bmm en préversion
- `node /chemin/vers/checkout-local/tools/installer/bmad-cli.js install` → ce que votre checkout local contient
`--pin bmm=v6.3.0` et `--next=bmm` n’ont aucun effet sur les modules intégrés (l’installateur vous avertit si vous tentez de les utiliser). Une prochaine version détachera bmm du paquet de l’installateur ; une fois publiée, bmm disposera d’un sélecteur de canal dédié, comme c’est le cas pour bmb aujourd’hui.
## Mettre à jour une installation existante
Exécuter `npx bmad-method install` dans un répertoire contenant déjà `_bmad/` affiche un menu :
| Choix | Ce qu’il fait |
|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Quick Update** | Réexécute l’installation avec vos paramètres existants. Rafraîchit les fichiers, applique les correctifs et les mises à niveau mineures du canal stable, refuse les mises à niveau majeures. Rapide, non interactif. |
| **Modify Install** | Flux interactif complet. Ajoutez ou retirez des modules, reconfigurez les paramètres, examinez et, si besoin, modifiez les canaux des modules existants. |
### Invites de mise à niveau
Quand Modify détecte un tag stable plus récent pour un module que vous avez installé sur `stable`, il classe le diff et vous invite en conséquence :
| Type de mise à niveau | Exemple | Défaut |
| --------------------- | --------------- | ------ |
| Patch | v1.7.0 → v1.7.1 | O |
| Mineure | v1.7.0 → v1.8.0 | O |
| Majeure | v1.7.0 → v2.0.0 | **N** |
Les mises à niveau majeures sont refusées par défaut (N) car les changements cassants se manifestent souvent comme une « instabilité » quand ils ne sont pas attendus. L’invite inclut une URL vers les notes de version GitHub pour que vous puissiez lire ce qui a changé avant d’accepter.
Avec `--yes`, les mises à niveau patch et mineure s’appliquent automatiquement. Les majeures restent bloquées — utilisez `--pin <code>=<nouveau-tag>` pour les accepter de manière non interactive.
### Changer le canal d’un module
**En mode interactif :** choisissez Modify → répondez **Oui** à « Review channel assignments? » → chaque module externe offre Conserver, Basculer vers stable, Basculer vers next, ou Épingler à un tag.
**En ligne de commande :** les recettes dans la section suivante couvrent les cas courants.
## Installations CI non interactives
### Référence des options
| Option | Objectif |
|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `--yes`, `-y` | Ignorer toutes les invites ; accepter les valeurs des options + les défauts |
| `--directory <chemin>` | Installer dans ce répertoire (défaut : répertoire de travail courant) |
| `--modules <a,b,c>` | Ensemble exact de modules. Core est ajouté automatiquement. Ce n’est pas un delta — listez tout ce que vous voulez conserver. |
| `--tools <a,b>` | Sélection d’IDE/outil. Requis pour les nouvelles installations `--yes`. Exécutez `--list-tools` pour les IDs valides. |
| `--list-tools` | Afficher tous les IDs d’outils/IDE supportés (avec les répertoires cibles) et quitter. |
| `--action <type>` | `install`, `update` ou `quick-update`. La valeur par défaut dépend de l’état de l’installation. |
| `--custom-source <urls>` | Installer des modules personnalisés depuis des URLs Git ou des chemins locaux |
| `--channel <stable\|next>` | Appliquer à tous les externes (alias `--all-stable` / `--all-next`) |
| `--all-stable` | Alias pour `--channel=stable` |
| `--all-next` | Alias pour `--channel=next` |
| `--next=<code>` | Mettre un module sur next. Répétable. |
| `--pin <code>=<tag>` | Épingler un module à un tag spécifique. Répétable. |
| `--set <module>.<clé>=<valeur>` | Définir toute option de config de module de manière non interactive (recommandé — voir [Substitutions de config de module](#substitutions-de-config-de-module)). Répétable. |
| `--list-options [module]` | Afficher chaque clé `--set` pour les modules intégrés et officiels en cache local, puis quitter. Passez un code de module pour limiter à un seul module. |
| `--user-name`, `--communication-language`, `--document-output-language`, `--output-folder` | Raccourcis historiques équivalents à `--set core.<clé>=<valeur>` (toujours supportés) |
Priorité en cas de chevauchement des options : `--pin` bat `--next=` bat `--channel` / `--all-*` bat le défaut du registre (`stable`).
:::note[Exemple de résolution]
`--all-next --pin cis=v0.2.0` met bmb, gds et tea sur next tout en épinglant cis à v0.2.0.
:::
### Recettes
**Installation par défaut — dernière version stable pour tout :**
```bash
npx github:bmad-code-org/BMAD-METHOD install
npx bmad-method install --yes --modules bmm,bmb,cis --tools claude-code
```
**Installation entreprise verrouillée — reproductible à l’octet près :**
```bash
npx bmad-method install --yes \
--modules bmm,bmb,cis \
--pin bmb=v1.7.0 --pin cis=v0.2.0 \
--tools claude-code
```
**Bleeding edge — externes sur le HEAD de main :**
```bash
npx bmad-method install --yes --modules bmm,bmb --all-next --tools claude-code
```
**Ajouter un module à une installation existante** (conserver tout le reste) :
```bash
npx bmad-method install --yes --action update \
--modules bmm,bmb,gds
```
`--tools` est omis intentionnellement — `--action update` réutilise les outils configurés lors de la première installation.
**Mixer les canaux — bmb sur next, gds sur stable :**
```bash
npx bmad-method install --yes --action update \
--modules bmm,bmb,cis,gds \
--next=bmb
```
### Substitutions de config de module
`--set <module>.<clé>=<valeur>` vous permet de définir toute option de config de module de manière non interactive. Cette option est répétable et s’adapte à chaque module — présent et futur. L’option est appliquée comme un correctif post-installation : l’installateur exécute d’abord son flux normal, puis `--set` insère ou met à jour chaque valeur dans `_bmad/config.toml` (portée équipe) ou `_bmad/config.user.toml` (portée utilisateur), et dans `_bmad/<module>/config.yaml` pour que les valeurs déclarées soient conservées à la prochaine installation.
**Exemple — installer bmm avec des connaissances projet et un niveau de compétence explicites :**
```bash
npx bmad-method install --yes \
--modules bmm \
--tools claude-code \
--set bmm.project_knowledge=research \
--set bmm.user_skill_level=expert
```
**Découvrir les clés disponibles pour un module :**
```bash
npx bmad-method install --list-options bmm
```
`--list-options` (sans argument) liste chaque clé que l’installateur peut trouver localement — modules intégrés (`core`, `bmm`) plus tous les modules officiels actuellement en cache. Le cache est par machine et peut être vidé, donc les modules officiels précédemment installés n’apparaîtront pas sur un nouveau checkout ou un worker CI éphémère tant qu’ils ne sont pas réinstallés. Les modules communautaires et personnalisés ne sont pas énumérés ici ; lisez directement le `module.yaml` du module pour voir les clés qu’il déclare.
**Comment ça fonctionne :**
- **Routage.** L’étape de correctif cherche `[modules.<module>] <clé>` (ou `[core] <clé>`) dans `config.user.toml` en premier ; si elle y est trouvée, elle met à jour ce fichier. Sinon elle écrit dans le `config.toml` de portée équipe. Ainsi, les clés de portée utilisateur (ex. `core.user_name`, `bmm.user_skill_level`) finissent dans `config.user.toml` et les clés de portée équipe dans `config.toml`, correspondant à la partition utilisée par l’installateur.
- **Valeurs littérales.** La valeur est écrite exactement comme vous l’avez fournie — aucun rendu de template `result:`. Pour obtenir la valeur résolue (ex. `{project-root}/research`), passez-la explicitement : `--set bmm.project_knowledge='{project-root}/research'`.
- **Persistance, clés déclarées.** Les valeurs pour les clés déclarées dans `module.yaml` sont conservées entre les installations car elles sont aussi écrites dans `_bmad/<module>/config.yaml`, que l’installateur lit comme valeur par défaut de l’invite lors de la prochaine exécution.
- **Persistance, clés non déclarées.** Une valeur pour une clé que le schéma du module ne déclare pas est enregistrée dans `config.toml` pour l’installation courante mais ne sera pas réécrite à la prochaine installation (le partitionneur strict au schéma du manifeste ignore les clés inconnues). Repassez `--set` pour qu’elle soit persistante, ou éditez `_bmad/config.toml` directement.
- **Pas de validation.** Les valeurs `single-select` ne sont pas vérifiées contre les choix autorisés, et les clés inconnues ne sont pas rejetées — la valeur fournie est écrite telle quelle.
- **Modules non présents dans `--modules`.** Définir une valeur pour un module que vous n’avez pas inclus affiche un avertissement et la valeur est ignorée (aucun fichier n’est créé pour un module non installé).
Les raccourcis historiques de core (`--user-name`, `--output-folder`, etc.) fonctionnent toujours et restent documentés pour la rétrocompatibilité, mais `--set core.user_name=...` est équivalent.
:::note[Fonctionne avec quick-update]
`--set` est un correctif post-installation, il s’applique donc de la même manière quel que soit le type d’action. Avec `bmad install --action quick-update` (ou `--yes` sur une installation existante, où quick-update est le défaut), `--set` met à jour les fichiers de configuration centraux à la fin comme une installation normale.
:::
### 2. Choisir l'emplacement d'installation
:::caution[Limitation de débit sur les IPs partagées]
Les appels anonymes à l’API GitHub sont limités à 60/heure par IP. Une seule installation fait un appel API par module externe pour résoudre le tag stable. Les bureaux derrière NAT, les pools de runners CI et les VPN peuvent collectivement épuiser cette limite.
L'installateur vous demandera où installer les fichiers BMad :
- Répertoire courant (recommandé pour les nouveaux projets si vous avez créé le répertoire vous-même et l'exécutez depuis ce répertoire)
- Chemin personnalisé
### 3. Sélectionner vos outils d'IA
Choisissez les outils d'IA que vous utilisez :
- Claude Code
- Cursor
- Autres
Chaque outil a sa propre façon d'intégrer les skills. L'installateur crée de petits fichiers de prompt pour activer les workflows et les agents — il les place simplement là où votre outil s'attend à les trouver.
:::note[Activer les skills]
Certaines plateformes nécessitent que les skills soient explicitement activés dans les paramètres avant d'apparaître. Si vous installez BMad et ne voyez pas les skills, vérifiez les paramètres de votre plateforme ou demandez à votre assistant IA comment activer les skills.
Définissez `GITHUB_TOKEN=<personal access token>` dans l’environnement pour augmenter la limite à 5 000/heure par compte. Tout PAT avec accès en lecture aux dépôts publics fonctionne ; aucune portée spécifique n’est requise.
:::
### 4. Choisir les modules
## Ce qui a été installé
L'installateur affiche les modules disponibles. Sélectionnez ceux dont vous avez besoin — la plupart des utilisateurs veulent simplement **méthode BMad** (le module de développement logiciel).
Après toute installation, `_bmad/_config/manifest.yaml` enregistre exactement ce qui est sur le disque :
### 5. Suivre les instructions
L'installateur vous guide pour le reste — paramètres, intégrations d'outils, etc.
## Ce que vous obtenez
```text
votre-projet/
├── _bmad/
│ ├── bmm/ # Vos modules sélectionnés
│ │ └── config.yaml # Paramètres du module (si vous devez les modifier)
│ ├── core/ # Module core requis
│ └── ...
├── _bmad-output/ # Artefacts générés
├── .claude/ # Skills Claude Code (si vous utilisez Claude Code)
│ └── skills/
│ ├── bmad-help/
│ ├── bmad-persona/
│ └── ...
└── .cursor/ # Skills Cursor (si vous utilisez Cursor)
└── skills/
└── ...
```yaml
modules:
- name: bmb
version: v1.7.0 # le tag, ou "main" pour next
channel: stable # stable | next | pinned
sha: 86033fc9aeae2ca6d52c7cdb675c1f4bf17fc1c1
source: external
repoUrl: https://github.com/bmad-code-org/bmad-builder
```
## Vérifier l'installation
Le champ `sha` est écrit pour les modules basés sur git (externes, communautaires et personnalisés par URL). Les modules intégrés (core, bmm) et les modules personnalisés par chemin local n’en ont pas — leur code voyage avec le binaire de l’installateur ou votre système de fichiers, pas un ref clonable.
Exécutez `bmad-help` pour vérifier que tout fonctionne et voir quoi faire ensuite.
Pour la reproductibilité inter-machines, ne comptez pas sur la réexécution de la même commande `--modules`. Les installations sur canal stable résolvent vers le plus haut tag publié **au moment de l’installation**, donc une réexécution ultérieure obtiendra les versions publiées entre-temps. Convertissez les tags enregistrés de `manifest.yaml` en options `--pin` explicites sur la machine cible, par ex. :
**BMad-Help est votre guide intelligent** qui va :
- Confirmer que votre installation fonctionne
- Afficher ce qui est disponible en fonction de vos modules installés
- Recommander votre première étape
Vous pouvez aussi lui poser des questions :
```
bmad-help Je viens d'installer, que dois-je faire en premier ?
bmad-help Quelles sont mes options pour un projet SaaS ?
```bash
npx bmad-method install --yes --modules bmb,cis \
--pin bmb=v1.7.0 --pin cis=v0.4.2 --tools claude-code
```
## Résolution de problèmes
**L'installateur affiche une erreur** — Copiez-collez la sortie dans votre assistant IA et laissez-le résoudre le problème.
### « Could not resolve stable tag » ou « API rate limit exceeded »
**L'installateur a fonctionné mais quelque chose ne fonctionne pas plus tard** — Votre IA a besoin du contexte BMad pour vous aider. Consultez [Comment obtenir des réponses à propos de BMad](./get-answers-about-bmad.md) pour savoir comment diriger votre IA vers les bonnes sources.
Vous avez atteint la limite anonyme de 60/heure de GitHub. Définissez `GITHUB_TOKEN` et réessayez. Si vous avez déjà un token défini, il peut être expiré ou limité sur son propre budget — essayez un token différent ou attendez la réinitialisation horaire.
### « Tag ’vX.Y.Z' not found »
Le tag que vous avez passé à `--pin` n’existe pas dans le dépôt du module. Consultez la page des releases du dépôt sur GitHub pour les tags valides.
### Une installation épinglée continue de se mettre à niveau
Les installations épinglées ne se mettent pas à niveau. Quick-update applique les correctifs et les mises à niveau mineures uniquement sur le canal stable ; il ne touche pas `pinned` ou `next`. Si une installation épinglée a changé, ouvrez `_bmad/_config/manifest.yaml` — `channel: pinned` plus un `version` et `sha` fixes doivent rester stables d’une exécution à l’autre, sauf écrasement explicite via les options.
### `--pin bmm=X` n’a rien fait
bmm est un module intégré — `--pin` et `--next=` ne s’appliquent pas. Utilisez `npx bmad-method@next install` pour un core/bmm en préversion, ou clonez le dépôt bmad-bmm et exécutez l’installateur localement pour obtenir les modifications non publiées.

181
docs/fr/how-to/install-custom-modules.md Normal file
View File

@ -0,0 +1,181 @@
---
title: "Installer des modules personnalisés et communautaires"
description: Installer des modules tiers depuis le registre communautaire, des dépôts Git ou des chemins locaux
sidebar:
order: 3
---
Utilisez l’installateur BMad pour ajouter des modules depuis le registre communautaire, des dépôts Git tiers ou des chemins locaux.
## Quand l’utiliser
- Installer un module contribué par la communauté depuis le registre BMad
- Installer un module depuis un dépôt Git tiers (GitHub, GitLab, Bitbucket, auto-hébergé)
- Tester un module que vous développez localement avec BMad Builder
- Installer des modules depuis un serveur Git privé ou auto-hébergé
:::note[Prérequis]
Nécessite [Node.js](https://nodejs.org) v20.12+ et `npx` (inclus avec npm). Les modules personnalisés et communautaires peuvent être sélectionnés lors d’une nouvelle installation ou ajoutés à une installation existante.
:::
## Modules communautaires
Les modules communautaires sont regroupés dans le [marketplace de plugins BMad](https://github.com/bmad-code-org/bmad-plugins-marketplace). Ils sont organisés par catégorie et épinglés à un commit approuvé pour des raisons de sécurité.
### 1. Lancer l’installateur
```bash
npx bmad-method install
```
### 2. Parcourir le catalogue communautaire
Après avoir sélectionné les modules officiels, l’installateur demande :
```
Would you like to browse community modules?
```
Sélectionnez **Yes** pour accéder au navigateur de catalogue. Vous pouvez :
- Parcourir par catégorie
- Voir les modules phares
- Voir tous les modules disponibles
- Rechercher par mot-clé
### 3. Sélectionner des modules
Choisissez des modules dans n’importe quelle catégorie. L’installateur affiche les descriptions, versions et niveaux de confiance. Les modules déjà installés sont pré-sélectionnés pour la mise à jour.
### 4. Poursuivre l’installation
Après avoir sélectionné les modules communautaires, l’installateur passe aux sources personnalisées, puis à la configuration des outils/IDE et au reste du flux d’installation.
## Sources personnalisées (URL Git et chemins locaux)
Les modules personnalisés peuvent provenir de n’importe quel dépôt Git ou d’un répertoire local sur votre machine. L’installateur résout la source, analyse la structure du module et l’installe aux côtés de vos autres modules.
### Installation interactive
Durant l’installation, après l’étape des modules communautaires, l’installateur demande :
```
Would you like to install from a custom source (Git URL or local path)?
```
Sélectionnez **Yes**, puis indiquez une source :
| Type d’entrée | Exemple |
| ------------------------- | ------------------------------------------------- |
| URL HTTPS (tout hôte) | `https://github.com/org/repo` |
| URL HTTP (tout hôte) | `http://host/org/repo` |
| URL HTTPS avec sous-rép. | `https://github.com/org/repo/tree/main/my-module` |
| URL SSH | `git@github.com:org/repo.git` |
| Chemin local | `/Users/me/projects/my-module` |
| Chemin local avec tilde | `~/projects/my-module` |
L’installateur clone le dépôt (pour les URL) ou lit directement depuis le disque (pour les chemins locaux), puis présente les modules découverts pour la sélection.
### Installation non interactive
Utilisez l’option `--custom-source` pour installer des modules personnalisés depuis la ligne de commande :
```bash
npx bmad-method install \
--directory . \
--custom-source /path/to/my-module \
--tools claude-code \
--yes
```
Quand `--custom-source` est fourni sans `--modules`, seuls le cœur et les modules personnalisés sont installés. Pour inclure également les modules officiels, ajoutez `--modules` :
```bash
npx bmad-method install \
--directory . \
--modules bmm \
--custom-source https://gitlab.com/myorg/my-module \
--tools claude-code \
--yes
```
Plusieurs sources peuvent être séparées par des virgules :
```bash
--custom-source /path/one,https://github.com/org/repo,/path/two
```
## Fonctionnement de la découverte de modules
L’installateur utilise deux modes pour trouver les modules installables dans une source :
| Mode | Déclencheur | Comportement |
|------------|------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|
| Découverte | La source contient `.claude-plugin/marketplace.json` | Liste tous les plugins du manifeste ; vous choisissez lesquels installer |
| Direct | Aucun `marketplace.json` trouvé | Analyse le répertoire pour trouver des skills (sous-répertoires avec `SKILL.md`), les résout en un module unique |
Le mode découverte est typique des modules publiés. Le mode direct est pratique pour pointer vers un répertoire de skills pendant le développement local.
:::note[À propos de `.claude-plugin/`]
Le chemin `.claude-plugin/marketplace.json` est une convention standard adoptée par plusieurs installateurs d’outils IA pour la découvabilité des plugins. Il ne nécessite pas Claude, n’utilise pas les API Claude et n’a aucun impact sur l’outil d’IA que vous utilisez. Tout module contenant ce fichier peut être découvert par tout installateur suivant cette convention.
:::
## Flux de travail en développement local
Si vous construisez un module avec [BMad Builder](https://github.com/bmad-code-org/bmad-builder), vous pouvez l’installer directement depuis votre répertoire de travail :
```bash
npx bmad-method install \
--directory ~/my-project \
--custom-source ~/my-module-repo/skills \
--tools claude-code \
--yes
```
Les sources locales sont référencées par leur chemin, non copiées dans un cache. Lorsque vous mettez à jour la source de votre module et réinstallez, l’installateur récupère les dernières modifications.
:::caution[Suppression de la source]
Si vous supprimez le répertoire source local après l’installation, les fichiers du module installé dans `_bmad/` sont préservés. Le module sera ignoré lors des mises à jour tant que le chemin source n’est pas restauré.
:::
## Ce que vous obtenez
Après l’installation, les modules personnalisés apparaissent dans `_bmad/` aux côtés des modules officiels :
```
your-project/
├── _bmad/
│ ├── core/ # Module cœur intégré
│ ├── bmm/ # Module officiel (si sélectionné)
│ ├── my-module/ # Votre module personnalisé
│ │ ├── my-skill/
│ │ │ └── SKILL.md
│ │ └── module-help.csv
│ └── _config/
│ └── manifest.yaml # Suit tous les modules, versions et sources
└── ...
```
Le manifeste enregistre la source de chaque module personnalisé (`repoUrl` pour les sources Git, `localPath` pour les sources locales) afin que les mises à jour rapides puissent localiser la source à nouveau.
## Mettre à jour les modules personnalisés
Les modules personnalisés participent au flux de mise à jour normal :
- **Mise à jour rapide** (`--action quick-update`) : Rafraîchit tous les modules depuis leurs sources d’origine. Les modules Git sont re-téléchargés ; les modules locaux sont relus depuis leur chemin source.
- **Mise à jour complète** : Relance la sélection de modules pour que vous puissiez ajouter ou retirer des modules personnalisés.
## Créer vos propres modules
Utilisez [BMad Builder](https://github.com/bmad-code-org/bmad-builder) pour créer des modules que d’autres pourront installer :
1. Exécutez `bmad-module-builder` pour générer la structure de votre module
2. Ajoutez des skills, agents et workflows avec les divers outils BMad Builder
3. Publiez dans un dépôt Git ou partagez le dossier
4. D’autres installent avec `--custom-source <url-de-votre-dépôt>`
Pour que les modules supportent le mode découverte, incluez un fichier `.claude-plugin/marketplace.json` à la racine de votre dépôt (c’est une convention multi-outils, pas spécifique à Claude). Consultez la [documentation BMad Builder](https://github.com/bmad-code-org/bmad-builder) pour le format du fichier `marketplace.json`.
:::tip[Tester localement d’abord]
Pendant le développement, installez votre module avec un chemin local pour itérer rapidement avant de publier dans un dépôt Git.
:::

161
docs/fr/how-to/non-interactive-installation.md
View File

@ -1,165 +1,10 @@
---
title: Installation non-interactive
description: Installer BMad en utilisant des options de ligne de commande pour les pipelines CI/CD et les déploiements automatisés
description: La documentation sur les installations headless / CI a été déplacée
sidebar:
order: 2
---
Utilisez les options de ligne de commande pour installer BMad de manière non-interactive. Cela est utile pour :
## Quand utiliser cette méthode
- Déploiements automatisés et pipelines CI/CD
- Installations scriptées
- Installations par lots sur plusieurs projets
- Installations rapides avec des configurations connues
:::note[Prérequis]
Nécessite [Node.js](https://nodejs.org) v20.12+ et `npx` (inclus avec npm).
:::
## Options disponibles
### Options d'installation
| Option | Description | Exemple |
|------|-------------|---------|
| `--directory <chemin>` | Répertoire d'installation | `--directory ~/projects/myapp` |
| `--modules <modules>` | IDs de modules séparés par des virgules | `--modules bmm,bmb` |
| `--tools <outils>` | IDs d'outils/IDE séparés par des virgules (utilisez `none` pour ignorer) | `--tools claude-code,cursor` ou `--tools none` |
| `--action <type>` | Action pour les installations existantes : `install` (par défaut), `update`, ou `quick-update` | `--action quick-update` |
### Configuration principale
| Option | Description | Par défaut |
|------|-------------|---------|
| `--user-name <nom>` | Nom à utiliser par les agents | Nom d'utilisateur système |
| `--communication-language <langue>` | Langue de communication des agents | Anglais |
| `--document-output-language <langue>` | Langue de sortie des documents | Anglais |
| `--output-folder <chemin>` | Chemin du dossier de sortie (voir les règles de résolution ci-dessous) | `_bmad-output` |
#### Résolution du chemin du dossier de sortie
La valeur passée à `--output-folder` (ou saisie de manière interactive) est résolue selon ces règles :
| Type d'entrée | Exemple | Résolu comme |
|-------------------------------|----------------------------|--------------------------------------------------------------|
| Chemin relatif (par défaut) | `_bmad-output` | `<racine-du-projet>/_bmad-output` |
| Chemin relatif avec traversée | `../../shared-outputs` | Chemin absolu normalisé — ex. `/Users/me/shared-outputs` |
| Chemin absolu | `/Users/me/shared-outputs` | Utilisé tel quel — la racine du projet n'est **pas** ajoutée |
Le chemin résolu est ce que les agents et les workflows vont utiliser lors de l'écriture des fichiers de sortie. L'utilisation d'un chemin absolu ou d'un chemin relatif avec traversée vous permet de diriger tous les artefacts générés vers un répertoire en dehors de l'arborescence de votre projet — utile pour les configurations partagées ou les monorepos.
### Autres options
| Option | Description |
|------|-------------|
| `-y, --yes` | Accepter tous les paramètres par défaut et ignorer les invites |
| `-d, --debug` | Activer la sortie de débogage pour la génération du manifeste |
## IDs de modules
IDs de modules disponibles pour l’option `--modules` :
- `bmm` — méthode BMad Master
- `bmb` — BMad Builder
Consultez le [registre BMad](https://github.com/bmad-code-org) pour les modules externes disponibles.
## IDs d'outils/IDE
IDs d'outils disponibles pour l’option `--tools` :
**Recommandés :** `claude-code`, `cursor`
Exécutez `npx bmad-method install` de manière interactive une fois pour voir la liste complète actuelle des outils pris en charge, ou consultez la [configuration des codes de la plateforme](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
## Modes d'installation
| Mode | Description | Exemple |
|------|-------------|---------|
| Entièrement non-interactif | Fournir toutes les options pour ignorer toutes les invites | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
| Semi-interactif | Fournir certains options ; BMad demande les autres | `npx bmad-method install --directory . --modules bmm` |
| Paramètres par défaut uniquement | Accepter tous les paramètres par défaut avec `-y` | `npx bmad-method install --yes` |
| Sans outils | Ignorer la configuration des outils/IDE | `npx bmad-method install --modules bmm --tools none` |
## Exemples
### Installation dans un pipeline CI/CD
```bash
#!/bin/bash
# install-bmad.sh
npx bmad-method install \
--directory "${GITHUB_WORKSPACE}" \
--modules bmm \
--tools claude-code \
--user-name "CI Bot" \
--communication-language Français \
--document-output-language Français \
--output-folder _bmad-output \
--yes
```
### Mettre à jour une installation existante
```bash
npx bmad-method install \
--directory ~/projects/myapp \
--action update \
--modules bmm,bmb,custom-module
```
### Mise à jour rapide (conserver les paramètres)
```bash
npx bmad-method install \
--directory ~/projects/myapp \
--action quick-update
```
## Ce que vous obtenez
- Un répertoire `_bmad/` entièrement configuré dans votre projet
- Des agents et des flux de travail configurés pour vos modules et outils sélectionnés
- Un dossier `_bmad-output/` pour les artefacts générés
## Validation et gestion des erreurs
BMad valide toutes les options fournis :
- **Directory** — Doit être un chemin valide avec des permissions d'écriture
- **Modules** — Avertit des IDs de modules invalides (mais n'échoue pas)
- **Tools** — Avertit des IDs d'outils invalides (mais n'échoue pas)
- **Action** — Doit être l'une des suivantes : `install`, `update`, `quick-update`
Les valeurs invalides entraîneront soit :
1. L’affichage d’un message d'erreur suivi d’un exit (pour les options critiques comme le répertoire)
2. Un avertissement puis la continuation de l’installation (pour les éléments optionnels)
3. Un retour aux invites interactives (pour les valeurs requises manquantes)
:::tip[Bonnes pratiques]
- Utilisez des chemins absolus pour `--directory` pour éviter toute ambiguïté
- Utilisez un chemin absolu pour `--output-folder` lorsque vous souhaitez que les artefacts soient écrits en dehors de l'arborescence du projet (ex. un répertoire de sorties partagé dans un monorepo)
- Testez les options localement avant de les utiliser dans des pipelines CI/CD
- Combinez avec `-y` pour des installations vraiment sans surveillance
- Utilisez `--debug` si vous rencontrez des problèmes lors de l'installation
:::
## Résolution des problèmes
### L'installation échoue avec "Invalid directory"
- Le chemin du répertoire doit exister (ou son parent doit exister)
- Vous avez besoin des permissions d'écriture
- Le chemin doit être absolu ou correctement relatif au répertoire actuel
### Module non trouvé
- Vérifiez que l'ID du module est correct
- Les modules externes doivent être disponibles dans le registre
:::note[Toujours bloqué ?]
Exécutez avec `--debug` pour une sortie détaillée, essayez le mode interactif pour isoler le problème, ou signalez-le à <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
:::note[Cette page a été déplacée]
Les flags d’installation headless et CI, la sélection de canal et l’épinglage de version se trouvent désormais dans le guide unifié [Comment installer BMad](./install-bmad.md). Consultez la section [Installations CI non interactives](./install-bmad.md#installations-ci-non-interactives) pour la référence des flags et les exemples prêts à copier-coller.
:::

38
docs/fr/how-to/project-context.md
View File

@ -2,10 +2,10 @@
title: "Gérer le contexte du projet"
description: Créer et maintenir project-context.md pour guider les agents IA
sidebar:
order: 8
order: 9
---
Utilisez le fichier `project-context.md` pour garantir que les agents IA respectent les préférences techniques et les règles d'implémentation de votre projet tout au long des workflows. Pour vous assurer qu'il est toujours disponible, vous pouvez également ajouter la ligne `Le contexte et les conventions importantes du projet se trouvent dans [chemin vers le contexte du projet]/project-context.md` à votre fichier de contexte ou de règles permanentes (comme `AGENTS.md`).
Utilisez le fichier `project-context.md` pour garantir que les agents IA respectent les préférences techniques et les règles d’implémentation de votre projet tout au long des workflows. Pour vous assurer qu’il est toujours disponible, vous pouvez également ajouter la ligne `Le contexte et les conventions importantes du projet se trouvent dans [chemin vers le contexte du projet]/project-context.md` à votre fichier de contexte ou de règles permanentes (comme `AGENTS.md`).
:::note[Prérequis]
- Méthode BMad installée
@ -14,31 +14,31 @@ Utilisez le fichier `project-context.md` pour garantir que les agents IA respect
## Quand utiliser cette fonctionnalité
- Vous avez des préférences techniques fortes avant de commencer l'architecture
- Vous avez terminé l'architecture et souhaitez consigner les décisions pour l'implémentation
- Vous avez des préférences techniques fortes avant de commencer l’architecture
- Vous avez terminé l’architecture et souhaitez consigner les décisions pour l’implémentation
- Vous travaillez sur une base de code existante avec des patterns établis
- Vous remarquez que les agents prennent des décisions incohérentes entre les stories
## Étape 1 : Choisissez votre approche
## Étape 1 : Choisissez votre approche
**Création manuelle** — Idéal lorsque vous savez exactement quelles règles vous souhaitez documenter
**Génération après l'architecture** — Idéal pour capturer les décisions prises lors du solutioning
**Génération après l’architecture** — Idéal pour capturer les décisions prises lors du solutioning
**Génération pour les projets existants** — Idéal pour découvrir les patterns dans les bases de code existantes
## Étape 2 : Créez le fichier
## Étape 2 : Créez le fichier
### Option A : Création manuelle
### Option A : Création manuelle
Créez le fichier à l'emplacement `_bmad-output/project-context.md` :
Créez le fichier à l’emplacement `_bmad-output/project-context.md` :
```bash
mkdir -p _bmad-output
touch _bmad-output/project-context.md
```
Ajoutez votre pile technologique et vos règles d'implémentation :
Ajoutez votre pile technologique et vos règles d’implémentation :
```markdown
---
@ -72,7 +72,7 @@ sections_completed: ['technology_stack', 'critical_rules']
- Tests d'intégration utilisent MSW pour le mock API
```
### Option B : Génération après l'architecture
### Option B : Génération après l’architecture
Exécutez le workflow dans une nouvelle conversation :
@ -80,9 +80,9 @@ Exécutez le workflow dans une nouvelle conversation :
bmad-generate-project-context
```
Le workflow analyse votre document d'architecture et vos fichiers projet pour générer un fichier de contexte qui capture les décisions prises.
Le workflow analyse votre document d’architecture et vos fichiers projet pour générer un fichier de contexte qui capture les décisions prises.
### Option C : Génération pour les projets existants
### Option C : Génération pour les projets existants
Pour les projets existants, exécutez :
@ -92,9 +92,9 @@ bmad-generate-project-context
Le workflow analyse votre base de code pour identifier les conventions, puis génère un fichier de contexte que vous pouvez réviser et affiner.
## Étape 3 : Vérifiez le contenu
## Étape 3 : Vérifiez le contenu
Révisez le fichier généré et assurez-vous qu'il capture :
Révisez le fichier généré et assurez-vous qu’il capture :
- Les versions correctes des technologies
- Vos conventions réelles (pas les bonnes pratiques génériques)
@ -109,15 +109,15 @@ Un fichier `project-context.md` qui :
- Garantit que tous les agents suivent les mêmes conventions
- Évite les décisions incohérentes entre les stories
- Capture les décisions d'architecture pour l'implémentation
- Capture les décisions d’architecture pour l’implémentation
- Sert de référence pour les patterns et règles de votre projet
## Conseils
:::tip[Bonnes pratiques]
- **Concentrez-vous sur ce qui n'est pas évident** — Documentez les patterns que les agents pourraient manquer (par ex. « Utiliser JSDoc sur chaque classe publique »), et non les pratiques universelles comme « utiliser des noms de variables significatifs ».
- **Gardez-le concis** — Ce fichier est chargé par chaque workflow d'implémentation. Les fichiers longs gaspillent le contexte. Excluez le contenu qui ne s'applique qu'à un périmètre restreint ou à des stories spécifiques.
- **Mettez à jour si nécessaire** — Modifiez manuellement lorsque les patterns changent, ou régénérez après des changements d'architecture significatifs.
- **Concentrez-vous sur ce qui n’est pas évident** — Documentez les patterns que les agents pourraient manquer (par ex. « Utiliser JSDoc sur chaque classe publique »), et non les pratiques universelles comme « utiliser des noms de variables significatifs ».
- **Gardez-le concis** — Ce fichier est chargé par chaque workflow d’implémentation. Les fichiers longs gaspillent le contexte. Excluez le contenu qui ne s’applique qu’à un périmètre restreint ou à des stories spécifiques.
- **Mettez à jour si nécessaire** — Modifiez manuellement lorsque les patterns changent, ou régénérez après des changements d’architecture significatifs.
- Fonctionne aussi bien pour Quick Dev que pour les projets complets méthode BMad.
:::

28
docs/fr/how-to/quick-fixes.md
View File

@ -2,7 +2,7 @@
title: "Corrections Rapides"
description: Comment effectuer des corrections rapides et des modifications ciblées
sidebar:
order: 5
order: 6
---
Utilisez **Quick Dev** pour les corrections de bugs, les refactorisations ou les petites modifications ciblées qui ne nécessitent pas la méthode BMad complète.
@ -23,11 +23,11 @@ Utilisez **Quick Dev** pour les corrections de bugs, les refactorisations ou les
### 1. Démarrer une Nouvelle Conversation
Ouvrez une **nouvelle conversation** dans votre IDE IA. Réutiliser une session d'un workflow précédent peut causer des conflits de contexte.
Ouvrez une **nouvelle conversation** dans votre IDE IA. Réutiliser une session d’un workflow précédent peut causer des conflits de contexte.
### 2. Spécifiez Votre Intention
Quick Dev accepte l'intention en forme libre — avant, avec, ou après l'invocation. Exemples :
Quick Dev accepte l’intention en forme libre — avant, avec, ou après l’invocation. Exemples :
```text
quick-dev — Corrige le bug de validation de connexion qui permet les mots de passe vides.
@ -52,18 +52,18 @@ quick-dev
Refactoriser UserService pour utiliser async/await au lieu des callbacks.
```
Texte brut, chemins de fichiers, URLs d'issues GitHub, liens de trackers de bugs — tout ce que le LLM peut résoudre en une intention concrète.
Texte brut, chemins de fichiers, URLs d’issues GitHub, liens de trackers de bugs — tout ce que le LLM peut résoudre en une intention concrète.
### 3. Répondre aux Questions et Approuver
Quick Dev peut poser des questions de clarification ou présenter une courte spécification demandant votre approbation avant l'implémentation. Répondez à ses questions et approuvez lorsque vous êtes satisfait du plan.
Quick Dev peut poser des questions de clarification ou présenter une courte spécification demandant votre approbation avant l’implémentation. Répondez à ses questions et approuvez lorsque vous êtes satisfait du plan.
### 4. Réviser et Pousser
Quick Dev implémente la modification, révise son propre travail, corrige les problèmes et effectue un commit local. Lorsqu'il a terminé, il ouvre les fichiers affectés dans votre éditeur.
Quick Dev implémente la modification, révise son propre travail, corrige les problèmes et effectue un commit local. Lorsqu’il a terminé, il ouvre les fichiers affectés dans votre éditeur.
- Parcourez le diff pour confirmer que la modification correspond à votre intention
- Si quelque chose semble incorrect, dites à l'agent ce qu'il faut corriger — il peut itérer dans la même session
- Si quelque chose semble incorrect, dites à l’agent ce qu’il faut corriger — il peut itérer dans la même session
Une fois satisfait, poussez le commit. Quick Dev vous proposera de pousser et de créer une PR pour vous.
@ -79,20 +79,20 @@ Si une modification poussée cause des problèmes inattendus, utilisez `git reve
## Travail Différé
Quick Dev garde chaque exécution concentrée sur un seul objectif. Si votre demande contient plusieurs objectifs indépendants, ou si la revue remonte des problèmes préexistants non liés à votre modification, Quick Dev les diffère vers un fichier (`deferred-work.md` dans votre répertoire d'artefacts d'implémentation) plutôt que d'essayer de tout régler en même temps.
Quick Dev garde chaque exécution concentrée sur un seul objectif. Si votre demande contient plusieurs objectifs indépendants, ou si la revue remonte des problèmes préexistants non liés à votre modification, Quick Dev les diffère vers un fichier (`deferred-work.md` dans votre répertoire d’artefacts d’implémentation) plutôt que d’essayer de tout régler en même temps.
Consultez ce fichier après une exécution — c'est votre backlog[^1] de choses sur lesquelles revenir. Chaque élément différé peut être introduit dans une nouvelle exécution Quick Dev ultérieurement.
Consultez ce fichier après une exécution — c’est votre backlog[^1] de choses sur lesquelles revenir. Chaque élément différé peut être introduit dans une nouvelle exécution Quick Dev ultérieurement.
## Quand Passer à une Planification Formelle
Envisagez d'utiliser la méthode BMad complète lorsque :
Envisagez d’utiliser la méthode BMad complète lorsque :
- La modification affecte plusieurs systèmes ou nécessite des mises à jour coordonnées dans de nombreux fichiers
- Vous n'êtes pas sûr de la portée et avez besoin d'une découverte des exigences d'abord
- Vous avez besoin de documentation ou de décisions architecturales enregistrées pour l'équipe
- Vous n’êtes pas sûr de la portée et avez besoin d’une découverte des exigences d’abord
- Vous avez besoin de documentation ou de décisions architecturales enregistrées pour l’équipe
Voir [Quick Dev](../explanation/quick-dev.md) pour plus d'informations sur la façon dont Quick Dev s'intègre dans la méthode BMad.
Voir [Quick Dev](../explanation/quick-dev.md) pour plus d’informations sur la façon dont Quick Dev s’intègre dans la méthode BMad.
## Glossaire
[^1]: Backlog : liste priorisée de tâches ou d'éléments de travail à traiter ultérieurement, issue des méthodologies agiles.
[^1]: Backlog : liste priorisée de tâches ou d’éléments de travail à traiter ultérieurement, issue des méthodologies agiles.

16
docs/fr/how-to/shard-large-documents.md
View File

@ -2,20 +2,20 @@
title: "Guide de Division de Documents"
description: Diviser les fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte
sidebar:
order: 9
order: 10
---
Utilisez l'outil `bmad-shard-doc` si vous avez besoin de diviser des fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte.
Utilisez l’outil `bmad-shard-doc` si vous avez besoin de diviser des fichiers markdown volumineux en fichiers plus petits et organisés pour une meilleure gestion du contexte.
:::caution[Déprécié]
Ceci n'est plus recommandé, et bientôt avec les workflows mis à jour et la plupart des LLM et outils majeurs supportant les sous-processus, cela deviendra inutile.
Ceci n’est plus recommandé, et bientôt avec les workflows mis à jour et la plupart des LLM et outils majeurs supportant les sous-processus, cela deviendra inutile.
:::
## Quand l’Utiliser
Utilisez ceci uniquement si vous remarquez que votre combinaison outil / modèle ne parvient pas à charger et lire tous les documents en entrée lorsque c'est nécessaire.
Utilisez ceci uniquement si vous remarquez que votre combinaison outil / modèle ne parvient pas à charger et lire tous les documents en entrée lorsque c’est nécessaire.
## Qu'est-ce que la Division de Documents ?
## Qu’est-ce que la Division de Documents ?
La division de documents divise les fichiers markdown volumineux en fichiers plus petits et organisés basés sur les titres de niveau 2 (`## Titre`).
@ -38,7 +38,7 @@ _bmad-output/planning-artifacts/
## Étapes
### 1. Exécuter l'Outil Shard-Doc
### 1. Exécuter l’Outil Shard-Doc
```bash
/bmad-shard-doc
@ -64,7 +64,7 @@ Agent : Division de PRD.md...
Les workflows BMad utilisent un **système de découverte double** :
1. **Essaye d'abord le document entier** - Rechercher `document-name.md`
1. **Essaye d’abord le document entier** - Rechercher `document-name.md`
2. **Vérifie la version divisée** - Rechercher `document-name/index.md`
3. **Règle de priorité** - Le document entier a la priorité si les deux existent - supprimez le document entier si vous souhaitez que la version divisée soit utilisée à la place
@ -75,4 +75,4 @@ Tous les workflows BMM prennent en charge les deux formats :
- Documents entiers
- Documents divisés
- Détection automatique
- Transparent pour l'utilisateur
- Transparent pour l’utilisateur

63
docs/fr/how-to/upgrade-to-v6.md
View File

@ -2,10 +2,10 @@
title: "Comment passer à la v6"
description: Migrer de BMad v4 vers v6
sidebar:
order: 3
order: 4
---
Utilisez l'installateur BMad pour passer de la v4 à la v6, qui inclut une détection automatique des installations existantes et une assistance à la migration.
Utilisez l’installateur BMad pour passer de la v4 à la v6, qui inclut une détection automatique des installations existantes et une assistance à la migration.
## Quand utiliser ce guide
@ -20,22 +20,22 @@ Utilisez l'installateur BMad pour passer de la v4 à la v6, qui inclut une déte
## Étapes
### 1. Lancer l'installateur
### 1. Lancer l’installateur
Suivez les [Instructions d'installation](./install-bmad.md).
Suivez les [Instructions d’installation](./install-bmad.md).
### 2. Gérer l'installation existante
### 2. Gérer l’installation existante
Quand v4 est détecté, vous pouvez :
- Autoriser l'installateur à sauvegarder et supprimer `.bmad-method`
- Autoriser l’installateur à sauvegarder et supprimer `.bmad-method`
- Quitter et gérer le nettoyage manuellement
Si vous avez nommé votre dossier de méthode bmad autrement, vous devrez supprimer le dossier vous-même manuellement.
Si votre dossier de méthode BMad porte un nom différent, vous devrez le supprimer manuellement.
### 3. Nettoyer les skills IDE
Supprimez manuellement les commandes/skills IDE v4 existants - par exemple si vous avez Claude Code, recherchez tous les dossiers imbriqués qui commencent par bmad et supprimez-les :
Supprimez manuellement les commandes/skills IDE v4 existants - par exemple si vous utilisez Claude Code, recherchez tous les dossiers imbriqués qui commencent par bmad et supprimez-les :
- `.claude/commands/`
@ -45,28 +45,28 @@ Les nouveaux skills v6 sont installés dans :
### 4. Migrer les artefacts de planification
**Si vous avez des documents de planification (Brief/PRD/UX/Architecture) :**
**Si vous avez des documents de planification (Brief/PRD/UX/Architecture) :**
Déplacez-les dans `_bmad-output/planning-artifacts/` avec des noms descriptifs :
- Incluez `PRD` dans le nom de fichier pour les documents PRD[^1]
- Incluez `brief`, `architecture`, ou `ux-design` selon le cas
- Les documents divisés peuvent être dans des sous-dossiers nommés
- Les documents divisés peuvent être dans des sous-dossiers au nom descriptif
**Si vous êtes en cours de planification :** Envisagez de redémarrer avec les workflows v6. Utilisez vos documents existants comme entrées - les nouveaux workflows de découverte progressive avec recherche web et mode plan IDE produisent de meilleurs résultats.
**Si vous êtes en cours de planification :** Envisagez de recommencer avec les workflows v6. Utilisez vos documents existants comme entrées — les nouveaux workflows de découverte progressive avec recherche web et le mode plan de l’IDE produisent de meilleurs résultats.
### 5. Migrer le développement en cours
Si vous avez des stories[^3] créées ou implémentées :
1. Terminez l'installation v6
1. Terminez l’installation v6
2. Placez `epics.md` ou `epics/epic*.md`[^2] dans `_bmad-output/planning-artifacts/`
3. Lancez le workflow Développeur `bmad-sprint-planning`[^4]
4. Indiquez à l’agent quels epics/stories sont déjà terminés
## Ce que vous obtenez
## Résultat de la migration
**Structure unifiée v6 :**
**Structure unifiée v6 :**
```text
votre-projet/
@ -77,30 +77,31 @@ votre-projet/
│ ├── bmm/ # Module BMad Method
│ ├── bmb/ # BMad Builder
│ └── cis/ # Creative Intelligence Suite
└── _bmad-output/ # Dossier de sortie (était le dossier doc en v4)
└── _bmad-output/ # Dossier de sortie (remplace le dossier doc de la v4)
```
## Migration des modules
| Module v4 | Statut v6 |
| ----------------------------- | ----------------------------------------- |
| `.bmad-2d-phaser-game-dev` | Intégré dans le Module BMGD |
| `.bmad-2d-unity-game-dev` | Intégré dans le Module BMGD |
| `.bmad-godot-game-dev` | Intégré dans le Module BMGD |
| `.bmad-infrastructure-devops` | Déprécié - nouvel agent DevOps bientôt disponible |
| `.bmad-creative-writing` | Non adapté - nouveau module v6 bientôt disponible |
| Module v4 | Statut v6 |
|-------------------------------|---------------------------------------------------|
| `.bmad-2d-phaser-game-dev` | Intégré dans le Module BMGD |
| `.bmad-2d-unity-game-dev` | Intégré dans le Module BMGD |
| `.bmad-godot-game-dev` | Intégré dans le Module BMGD |
| `.bmad-infrastructure-devops` | Obsolète — nouvel agent DevOps bientôt disponible |
| `.bmad-creative-writing` | Non migré — nouveau module v6 bientôt disponible |
## Changements clés
| Concept | v4 | v6 |
| ------------- | ------------------------------------- | ------------------------------------ |
| **Core** | `_bmad-core` était en fait la méthode BMad | `_bmad/core/` est le framework universel |
| **Method** | `_bmad-method` | `_bmad/bmm/` |
| **Config** | Fichiers modifiés directement | `config.yaml` par module |
| **Documents** | Division ou non division requise | Entièrement flexible, scan automatique |
| Concept | v4 | v6 |
|---------------|---------------------------------------------------------|------------------------------------------|
| **Core** | `_bmad-core` correspondait en réalité à la méthode BMad | `_bmad/core/` est le framework universel |
| **Method** | `_bmad-method` | `_bmad/bmm/` |
| **Config** | Fichiers modifiés directement | `config.yaml` par module |
| **Documents** | Division en fragments obligatoire ou optionnelle | Totalement flexible, analyse automatique |
## Glossaire
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
[^2]: Epic : dans les méthodologies agiles, une grande unité de travail qui peut être décomposée en plusieurs stories. Un epic représente généralement une fonctionnalité majeure ou un ensemble de capacités livrable sur plusieurs sprints.
[^3]: Story (User Story) : une description courte et simple d'une fonctionnalité du point de vue de l'utilisateur. Les stories sont des unités de travail suffisamment petites pour être complétées en un sprint.
[^4]: Sprint : dans Scrum, une période de temps fixe (généralement 1 à 4 semaines) pendant laquelle l'équipe travaille à livrer un incrément de produit potentiellement libérable.
[^3]: Story (User Story) : une description courte et simple d’une fonctionnalité du point de vue de l’utilisateur. Les stories sont des unités de travail suffisamment petites pour être complétées en un sprint.
[^4]: Sprint : dans Scrum, une période de temps fixe (généralement 1 à 4 semaines) pendant laquelle l’équipe travaille à livrer un incrément de produit potentiellement libérable.

41
docs/fr/how-to/use-web-bundles.md Normal file
View File

@ -0,0 +1,41 @@
---
title: 'Utiliser les Web Bundles'
description: Installer un web bundle BMad comme Google Gemini Gem ou ChatGPT Custom GPT
---
Les web bundles s’installent depuis **[bmadcode.com/web-bundles](https://bmadcode.com/web-bundles/)**.
## Pourquoi une seule porte d’entrée
Le site est le seul chemin d’installation pris en charge pour la bibliothèque. Il maintient les étapes à jour au fil de l’évolution de Gemini et ChatGPT, pointe toujours vers la dernière version taguée, et une seule inscription suffit pour être notifié des nouveaux bundles dès leur parution.
## Ce que vous ferez sur le site
1. Choisissez un bundle dans la grille de cartes.
2. Ouvrez la modale d’installation. Basculez entre les onglets **Gemini Gem** et **ChatGPT GPT** pour les étapes spécifiques à chaque plateforme.
3. Téléchargez le ZIP du bundle (un clic ; inscription gratuite en une étape pour les membres email uniquement).
4. Suivez les étapes indiquées sur la page : créez le Gem ou le Custom GPT, téléversez les fichiers de connaissance, collez le bloc d’instructions, sauvegardez.
## Prérequis
- **Pour les Gemini Gems** : abonnement Gemini Advanced.
- **Pour les ChatGPT Custom GPTs** : plan Plus, Pro, Business ou Enterprise.
- Pour les bundles qui utilisent **Deep Research** (actuellement Étude de marché et analyse sectorielle), activez-le depuis la barre de prompt (Outils → Deep Research). Deep Research a ses propres limites de plan.
## Personnaliser le persona
Le fichier `INSTRUCTIONS.md` de chaque bundle (dans le ZIP) inclut un **exemple de substitution de persona** au-dessus du séparateur de la zone à coller. Remplacez le bloc `[persona]` dans vos instructions installées par l’exemple de substitution pour changer le persona sans modifier le protocole. Vous pouvez aussi créer votre propre persona de zéro ; le protocole reste le même.
## Ce que vous obtenez
- Un Gem ou Custom GPT réutilisable dédié à une capacité de planification BMad.
- Des artefacts finalisés (briefs, PRD, rapports de recherche, spécifications UX) prêts à déposer dans votre IDE pour l’implémentation.
- Les conversations de planification se déroulent sur votre abonnement LLM web existant au lieu de consommer des tokens IDE facturés.
:::caution[Dérive du persona]
Les LLM web abandonnent parfois le persona au cours de longues sessions. Si le modèle commence à parler hors personnage, rappelez-lui son persona ou démarrez une nouvelle session.
:::
## Créer le vôtre
Pour transformer un skill BMad existant en web bundle, utilisez le skill utilitaire `bmad-os-skill-to-bundle` disponible sur [bmad-utility-skills](https://github.com/bmad-code-org/bmad-utility-skills). Il produit les fichiers du bundle en reprenant le persona hérité de l’agent d’origine et un exemple de persona alternatif. Soumettez votre bundle à la bibliothèque en ouvrant une PR sur [BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) qui ajoute le répertoire du bundle et une entrée dans `web-bundles/bundles.json`.

58
docs/fr/index.md
View File

@ -1,63 +1,63 @@
---
title: Bienvenue dans la méthode BMad
description: Framework de développement propulsé par l'IA avec des agents spécialisés, des workflows guidés et une planification intelligente
description: Framework de développement alimenté par l’IA avec des agents spécialisés, des workflows guidés et une planification intelligente
---
La méthode BMad (**B**uild **M**ore **A**rchitect **D**reams) est un module[^1] de développement assisté par l'IA au sein de l'écosystème BMad, conçu pour vous faciliter la création de logiciels par un processus complet, de l'idéation et de la planification jusqu'à l'implémentation agentique. Elle fournit des agents[^2] IA spécialisés, des workflows guidés et une planification intelligente qui s'adapte à la complexité de votre projet, que vous corrigiez un bug ou construisiez une plateforme d'entreprise.
La méthode BMad (**B**uild **M**ore **A**rchitect **D**reams) est un module[^1] de développement assisté par l’IA au sein de l’écosystème BMad. Elle couvre l’intégralité du processus de création logicielle — de l’idéation et de la planification jusqu’à la mise en œuvre par des agents. BMad met à votre disposition des agents IA spécialisés[^2], des workflows guidés et une planification intelligente qui s’adapte à la complexité de votre projet, qu’il s’agisse de corriger un bug ou de bâtir une plateforme d’entreprise.
Si vous êtes à l'aise avec les assistants de codage IA comme Claude, Cursor ou GitHub Copilot, vous êtes prêt à commencer.
Si vous êtes à l’aise avec les assistants de codage IA comme Claude, Cursor ou GitHub Copilot, vous êtes prêt à commencer.
:::note[🚀 La V6 est là et ce n'est que le début !]
Architecture par Skills, BMad Builder v1, automatisation Dev Loop, et bien plus encore en préparation. **[Consultez la Feuille de route →](./roadmap)**
:::note[🚀 La V6 est là et ce n’est que le début !]
Architecture de Skills, BMad Builder v1, automatisation Dev Loop, et bien plus encore à venir. **[Consultez la Feuille de route →](./roadmap)**
:::
## Première visite ? Commencez par un tutoriel
## Vous découvrez BMad ? Commencez par un tutoriel
La façon la plus rapide de comprendre BMad est de l'essayer.
La façon la plus rapide de comprendre BMad est de l’essayer.
- **[Premiers pas avec BMad](./tutorials/getting-started.md)** — Installez et comprenez comment fonctionne BMad
- **[Carte des workflows](./reference/workflow-map.md)** — Vue d'ensemble visuelle des phases BMM, des workflows et de la gestion du contexte
- **[Premiers pas avec BMad](./tutorials/getting-started.md)** — Installez BMad et découvrez son fonctionnement
- **[Carte des workflows](./reference/workflow-map.md)** — Vue d’ensemble visuelle des phases BMM, des workflows et de la gestion du contexte
:::tip[Envie de plonger directement ?]
Installez BMad et utilisez le skill[^3] `bmad-help` — il vous guidera entièrement en fonction de votre projet et de vos modules installés.
:::tip[Envie de passer à la pratique ?]
Installez BMad et utilisez le skill[^3] `bmad-help` — il vous guidera pas à pas, en fonction de votre projet et des modules installés.
:::
## Comment utiliser cette documentation
Cette documentation est organisée en quatre sections selon ce que vous essayez de faire :
Cette documentation est organisée en quatre sections, selon votre objectif :
| Section | Objectif |
| ----------------- | ----------------------------------------------------------------------------------------------------------- |
| **Tutoriels** | Orientés apprentissage. Guides étape par étape qui vous accompagnent dans la construction de quelque chose. Commencez ici si vous êtes nouveau. |
| **Guides pratiques** | Orientés tâches. Guides pratiques pour résoudre des problèmes spécifiques. « Comment personnaliser un agent ? » se trouve ici. |
| **Explication** | Orientés compréhension. Explications en profondeur des concepts et de l'architecture. À lire quand vous voulez savoir *pourquoi*. |
| **Référence** | Orientés information. Spécifications techniques pour les agents, workflows et configuration. |
| Section | Objectif |
|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------|
| **Tutoriels** | Orientés apprentissage. Guides pas à pas pour vous accompagner dans la réalisation d’un projet. Le point de départ idéal si vous débutez. |
| **Guides pratiques** | Orientés tâches. Guides concrets pour résoudre des problèmes spécifiques. Vous y trouverez par exemple « Comment personnaliser un agent ? ». |
| **Explications** | Orientés compréhension. Plongées dans les concepts et l’architecture. À consulter pour comprendre le *pourquoi*. |
| **Référence** | Orientés information. Spécifications techniques des agents, workflows et configuration. |
## Étendre et personnaliser
Vous souhaitez étendre BMad avec vos propres agents, workflows ou modules ? Le **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** fournit le framework et les outils pour créer des extensions personnalisées, que vous ajoutiez de nouvelles capacités à BMad ou que vous construisiez des modules entièrement nouveaux à partir de zéro.
Vous souhaitez étendre BMad avec vos propres agents, workflows ou modules ? Le **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** met à votre disposition le framework et les outils nécessaires pour créer des extensions personnalisées — que ce soit pour ajouter de nouvelles capacités à BMad ou pour concevoir des modules entièrement nouveaux de zéro.
## Ce dont vous aurez besoin
BMad fonctionne avec tout assistant de codage IA qui prend en charge les prompts système personnalisés ou le contexte de projet. Les options populaires incluent :
BMad fonctionne avec tout assistant de codage IA qui prend en charge les prompts système personnalisés ou le contexte de projet. Parmi les options les plus populaires :
- **[Claude Code](https://code.claude.com)** — Outil CLI d'Anthropic (recommandé)
- **[Cursor](https://cursor.sh)** — Éditeur de code propulsé par l'IA
- **[Codex CLI](https://github.com/openai/codex)** — Agent de codage terminal d'OpenAI
- **[Claude Code](https://code.claude.com)** — Outil CLI d’Anthropic (recommandé)
- **[Cursor](https://cursor.sh)** — Éditeur de code propulsé par l’IA
- **[Codex CLI](https://github.com/openai/codex)** — Agent de codage en ligne de commande d’OpenAI
Vous devriez être à l'aise avec les concepts de base du développement logiciel comme le contrôle de version, la structure de projet et les workflows agiles. Aucune expérience préalable avec les systèmes d'agent de type BMad n'est requise — c'est justement le but de cette documentation.
Vous devriez être à l’aise avec les concepts de base du développement logiciel : gestion de versions, structure de projet et méthodologies agiles. Aucune expérience préalable des systèmes d’agents de type BMad n’est requise — c’est précisément l’objet de cette documentation.
## Rejoindre la communauté
Obtenez de l'aide, partagez ce que vous construisez ou contribuez à BMad :
Trouvez de l’aide, partagez vos projets ou contribuez à BMad :
- **[Discord](https://discord.gg/gk8jAdXWmj)** — Discutez avec d'autres utilisateurs de BMad, posez des questions, partagez des idées
- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Code source, issues et contributions
- **[Discord](https://discord.gg/gk8jAdXWmj)** — Discutez avec d’autres utilisateurs de BMad, posez des questions, partagez des idées
- **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Code source, tickets et contributions
- **[YouTube](https://www.youtube.com/@BMadCode)** — Tutoriels vidéo et démonstrations
## Prochaine étape
Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)** et construisez votre premier projet.
Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)** et réalisez votre premier projet.
---
## Glossaire
@ -66,4 +66,4 @@ Prêt à vous lancer ? **[Commencez avec BMad](./tutorials/getting-started.md)**
[^2]: **Agent** : assistant IA spécialisé avec une expertise spécifique qui guide les utilisateurs dans les workflows.
[^3]: **Skill** : capacité ou fonctionnalité invoquable d'un agent pour effectuer une tâche spécifique.
[^3]: **Skill** : capacité ou fonctionnalité invoquable d’un agent pour effectuer une tâche spécifique.

45
docs/fr/reference/agents.md
View File

@ -11,42 +11,41 @@ Cette page liste les agents BMM (suite Agile) par défaut installés avec la mé
## Notes
- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-dev`) est utilisé pour invoquer l’agent.
- Les déclencheurs sont les codes courts de menu (par exemple, `BP`) et les correspondances approximatives affichés dans chaque menu d’agent.
- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`, disponible par l’agent Développeur. L’architecte de tests complet (TEA) se trouve dans son propre module.
- Chaque agent est disponible en tant que skill, généré par l’installateur. L’identifiant de skill (par exemple, `bmad-agent-dev`) est utilisé pour invoquer l’agent.
- Les déclencheurs sont les codes courts affichés dans le menu de chaque agent (par exemple, `PRD`) et les correspondances approximatives présentées dans chaque menu.
- La génération de tests QA est gérée par le skill de workflow `bmad-qa-generate-e2e-tests`, disponible via l’agent Développeur. L’architecte de tests complet (TEA) se trouve dans son propre module.
| Agent | Identifiant de skill | Déclencheurs | Workflows principaux |
|-----------------------------|----------------------|------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Analyste (Mary) | `bmad-analyst` | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorming du projet, Recherche marché/domaine/technique, Création du brief[^1], Défi PRFAQ, Documentation du projet |
| Product Manager (John) | `bmad-pm` | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Créer/Valider/Éditer un PRD, Créer des Epics et Stories, vérifier l’état de préparation à l’Implémentation, Corriger le Cours |
| Architecte (Winston) | `bmad-architect` | `CA`, `IR` | Créer l’architecture, Préparation à l’implémentation |
| Développeur (Amelia) | `bmad-agent-dev` | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, Génération de Tests QA, Code Review, Sprint Planning, Créer Story, Rétrospective d’Epic |
| Designer UX (Sally) | `bmad-ux-designer` | `CU` | Création du design UX[^2] |
| Rédacteur Technique (Paige) | `bmad-tech-writer` | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Documentation du projet, Rédaction de documents, Mise à jour des standards, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts |
| Agent | Identifiant de skill | Déclencheurs | Workflows principaux |
|-----------------------------|--------------------------|------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Analyste (Mary) | `bmad-agent-analyst` | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorming, Recherche marché, Recherche domaine, Recherche technique, Création du brief[^1], Défi PRFAQ, Documentation du projet |
| Product Manager (John) | `bmad-agent-pm` | `PRD`, `CE`, `IR`, `CC` | Créer, mettre à jour ou valider un PRD, Créer des Epics et Stories, vérifier l’état de préparation à l’Implémentation, Corriger le Cours |
| Architecte (Winston) | `bmad-agent-architect` | `CA`, `IR` | Créer l’architecture, Préparation à l’implémentation |
| Développeur (Amelia) | `bmad-agent-dev` | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER`, `IN` | Dev Story, Quick Dev, Génération de Tests QA, Code Review, Sprint Planning, Créer Story, Rétrospective d’Epic, [Enquête de code](../explanation/forensic-investigation.md) |
| Designer UX (Sally) | `bmad-agent-ux-designer` | `CU` | Création du design UX[^2] |
| Rédacteur Technique (Paige) | `bmad-agent-tech-writer` | `DP`, `WD`, `MG`, `VD`, `EC` | Documentation du projet, Rédaction de documents, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts |
## Types de déclencheurs
Les déclencheurs de menu d'agent utilisent deux types d'invocation différents. Connaître le type utilisé par un déclencheur vous aide à fournir la bonne entrée.
Les déclencheurs de menu d’agent utilisent deux types d’invocation différents. Connaître le type utilisé par un déclencheur vous aide à fournir la bonne entrée.
### Déclencheurs de workflow (aucun argument nécessaire)
La plupart des déclencheurs chargent un fichier de workflow structuré. Tapez le code du déclencheur et l'agent démarre le workflow, vous demandant de saisir les informations à chaque étape.
La plupart des déclencheurs chargent un fichier de workflow structuré. Tapez le code du déclencheur et l’agent démarre le workflow, vous demandant de saisir les informations à chaque étape.
Exemples : `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
Exemples : `PRD` (Créer, mettre à jour ou valider un PRD), `DS` (Dev Story), `CA` (Créer l’architecture), `QD` (Quick Dev)
### Déclencheurs conversationnels (arguments requis)
Certains déclencheurs lancent une conversation libre au lieu d'un workflow structuré. Ils s'attendent à ce que vous décriviez ce dont vous avez besoin à côté du code du déclencheur.
Certains déclencheurs lancent une conversation libre au lieu d’un workflow structuré. Ils s’attendent à ce que vous décriviez ce dont vous avez besoin à côté du code du déclencheur.
| Agent | Déclencheur | Ce qu'il faut fournir |
| --- | --- | --- |
| Rédacteur Technique (Paige) | `WD` | Description du document à rédiger |
| Rédacteur Technique (Paige) | `US` | Préférences ou conventions à ajouter aux standards |
| Rédacteur Technique (Paige) | `MG` | Description et type de diagramme (séquence, organigramme, etc.) |
| Rédacteur Technique (Paige) | `VD` | Document à valider et domaines à examiner |
| Rédacteur Technique (Paige) | `EC` | Nom du concept à expliquer |
| Agent | Déclencheur | Ce qu’il faut fournir |
|-----------------------------|-------------|-----------------------------------------------------------------|
| Rédacteur Technique (Paige) | `WD` | Description du document à rédiger |
| Rédacteur Technique (Paige) | `MG` | Description et type de diagramme (séquence, organigramme, etc.) |
| Rédacteur Technique (Paige) | `VD` | Document à valider et domaines à examiner |
| Rédacteur Technique (Paige) | `EC` | Nom du concept à expliquer |
**Exemple :**
**Exemple :**
```text
WD Rédige un guide de déploiement pour notre configuration Docker

106
docs/fr/reference/commands.md
View File

@ -1,50 +1,50 @@
---
title: Skills
description: Référence des skills BMad — ce qu'ils sont, comment ils fonctionnent et où les trouver.
description: Référence des skills BMad — ce qu’ils sont, comment ils fonctionnent et où les trouver.
sidebar:
order: 4
---
Les skills sont des prompts pré-construits qui chargent des agents, exécutent des workflows ou lancent des tâches dans votre IDE. L'installateur BMad les génère à partir de vos modules installés au moment de l'installation. Si vous ajoutez, supprimez ou modifiez des modules ultérieurement, relancez l'installateur pour garder les skills synchronisés (voir [Dépannage](#dépannage)).
Les skills sont des prompts pré-construits qui chargent des agents, exécutent des workflows ou lancent des tâches dans votre IDE. L’installateur BMad les génère à partir de vos modules installés au moment de l’installation. Si vous ajoutez, supprimez ou modifiez des modules ultérieurement, relancez l’installateur pour garder les skills synchronisés (voir [Dépannage](#dépannage)).
## Skills vs. Déclencheurs du menu Agent
BMad offre deux façons de démarrer un travail, chacune ayant un usage différent.
| Mécanisme | Comment l'invoquer | Ce qui se passe |
| --- | --- | --- |
| **Skill** | Tapez le nom du skill (ex. `bmad-help`) dans votre IDE | Charge directement un agent, exécute un workflow ou lance une tâche |
| **Déclencheur du menu agent** | Chargez d'abord un agent, puis tapez un code court (ex. `DS`) | L'agent interprète le code et démarre le workflow correspondant tout en préservant son persona |
| Mécanisme | Comment l’invoquer | Ce qui se passe |
|-------------------------------|---------------------------------------------------------------|------------------------------------------------------------------------------------------------|
| **Skill** | Tapez le nom du skill (ex. `bmad-help`) dans votre IDE | Charge directement un agent, exécute un workflow ou lance une tâche |
| **Déclencheur du menu agent** | Chargez d’abord un agent, puis tapez un code court (ex. `DS`) | L’agent interprète le code et démarre le workflow correspondant tout en préservant son persona |
Les déclencheurs du menu agent nécessitent une session agent active. Utilisez les skills lorsque vous savez quel workflow vous voulez. Utilisez les déclencheurs lorsque vous travaillez déjà avec un agent et souhaitez changer de tâche sans quitter la conversation.
## Comment les skills sont générés
Lorsque vous exécutez `npx bmad-method install`, l'installateur lit les manifests de chaque module sélectionné et écrit un skill par agent, workflow, tâche et outil. Chaque skill est un répertoire contenant un fichier `SKILL.md` qui indique à l'IA de charger le fichier source correspondant et de suivre ses instructions.
Lorsque vous exécutez `npx bmad-method install`, l’installateur lit les manifests de chaque module sélectionné et écrit un skill par agent, workflow, tâche et outil. Chaque skill est un répertoire contenant un fichier `SKILL.md` qui indique à l’IA de charger le fichier source correspondant et de suivre ses instructions.
L'installateur utilise des modèles pour chaque type de skill :
L’installateur utilise des modèles pour chaque type de skill :
| Type de skill | Ce que fait le fichier généré |
| --- | --- |
| **Lanceur d'agent** | Charge le fichier de persona de l'agent, active son menu et reste en caractère |
| **Skill de workflow** | Charge la configuration du workflow et suit ses étapes |
| **Skill de tâche** | Charge un fichier de tâche autonome et suit ses instructions |
| **Skill d'outil** | Charge un fichier d'outil autonome et suit ses instructions |
| Type de skill | Ce que fait le fichier généré |
|-----------------------|--------------------------------------------------------------------------------|
| **Lanceur d’agent** | Charge le fichier de persona de l’agent, active son menu et reste en caractère |
| **Skill de workflow** | Charge la configuration du workflow et suit ses étapes |
| **Skill de tâche** | Charge un fichier de tâche autonome et suit ses instructions |
| **Skill d’outil** | Charge un fichier d’outil autonome et suit ses instructions |
:::note[Relancer l'installateur]
Si vous ajoutez ou supprimez des modules, relancez l'installateur. Il régénère tous les fichiers de skill pour correspondre à votre sélection actuelle de modules.
:::note[Relancer l’installateur]
Si vous ajoutez ou supprimez des modules, relancez l’installateur. Il régénère tous les fichiers de skill pour correspondre à votre sélection actuelle de modules.
:::
## Emplacement des fichiers de skill
L'installateur écrit les fichiers de skill dans un répertoire spécifique à l'IDE à l'intérieur de votre projet. Le chemin exact dépend de l'IDE que vous avez sélectionné lors de l'installation.
L’installateur écrit les fichiers de skill dans un répertoire spécifique à l’IDE à l’intérieur de votre projet. Le chemin exact dépend de l’IDE que vous avez sélectionné lors de l’installation.
| IDE / CLI | Répertoire des skills |
| --- | --- |
| Claude Code | `.claude/skills/` |
| Cursor | `.cursor/skills/` |
| Windsurf | `.windsurf/skills/` |
| Autres IDE | Consultez la sortie de l'installateur pour le chemin cible |
| IDE / CLI | Répertoire des skills |
|-------------|------------------------------------------------------------|
| Claude Code | `.claude/skills/` |
| Cursor | `.agents/skills/` |
| Windsurf | `.agents/skills/` |
| Autres IDE | Consultez la sortie de l’installateur pour le chemin cible |
Chaque skill est un répertoire contenant un fichier `SKILL.md`. Par exemple, une installation Claude Code ressemble à :
@ -52,7 +52,7 @@ Chaque skill est un répertoire contenant un fichier `SKILL.md`. Par exemple, un
.claude/skills/
├── bmad-help/
│ └── SKILL.md
├── bmad-create-prd/
├── bmad-prd/
│ └── SKILL.md
├── bmad-agent-dev/
│ └── SKILL.md
@ -63,7 +63,7 @@ Le nom du répertoire détermine le nom du skill dans votre IDE. Par exemple, le
## Comment découvrir vos skills
Tapez le nom du skill dans votre IDE pour l'invoquer. Certaines plateformes nécessitent d'activer les skills dans les paramètres avant qu'ils n'apparaissent.
Tapez le nom du skill dans votre IDE pour l’invoquer. Certaines plateformes nécessitent d’activer les skills dans les paramètres avant qu’ils n’apparaissent.
Exécutez `bmad-help` pour obtenir des conseils contextuels sur votre prochaine étape.
@ -73,40 +73,40 @@ Les répertoires de skills générés dans votre projet sont la liste de référ
## Catégories de skills
### Skills d'agent
### Skills d’agent
Les skills d'agent chargent un persona[^2] IA spécialisé avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l'agent reste en caractère et répond aux déclencheurs du menu.
Les skills d’agent chargent un persona[^2] IA spécialisé avec un rôle défini, un style de communication et un menu de workflows. Une fois chargé, l’agent reste en caractère et répond aux déclencheurs du menu.
| Exemple de skill | Agent | Rôle |
|------------------|------------------------|-------------------------------------------------------------|
| `bmad-agent-dev` | Amelia (Développeur) | Implémente les stories avec une adhérence stricte aux specs |
| `bmad-pm` | John (Product Manager) | Crée et valide les PRDs[^1] |
| `bmad-architect` | Winston (Architecte) | Conçoit l'architecture système |
| Exemple de skill | Agent | Rôle |
|------------------------|------------------------|-------------------------------------------------------------|
| `bmad-agent-dev` | Amelia (Développeur) | Implémente les stories avec une adhérence stricte aux specs |
| `bmad-agent-pm` | John (Product Manager) | Crée, met à jour et valide les PRDs[^1] |
| `bmad-agent-architect` | Winston (Architecte) | Conçoit l’architecture système |
Consultez [Agents](./agents.md) pour la liste complète des agents par défaut et leurs déclencheurs.
### Skills de workflow
Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d'abord un persona d'agent. Ils chargent une configuration de workflow et suivent ses étapes.
Les skills de workflow exécutent un processus structuré en plusieurs étapes sans charger d’abord un persona d’agent. Ils chargent une configuration de workflow et suivent ses étapes.
| Exemple de skill | Objectif |
| --- | --- |
| `bmad-product-brief` | Créer un product brief[^3] — découverte guidée lorsque votre concept est clair |
| `bmad-prfaq` | Défi [PRFAQ Working Backwards](../explanation/analysis-phase.md#prfaq-working-backwards) pour éprouver votre concept produit |
| `bmad-create-prd` | Créer un PRD[^1] |
| `bmad-create-architecture` | Concevoir l'architecture système |
| `bmad-create-epics-and-stories` | Créer des epics et des stories |
| `bmad-dev-story` | Implémenter une story |
| `bmad-code-review` | Effectuer une revue de code |
| `bmad-quick-dev` | Flux rapide unifié — clarifier l'intention, planifier, implémenter, réviser, présenter |
| Exemple de skill | Objectif |
|---------------------------------|------------------------------------------------------------------------------------------------------------------------------|
| `bmad-product-brief` | Créer ou mettre à jour un product brief[^3] — découverte guidée lorsque votre concept est clair |
| `bmad-prfaq` | Défi [PRFAQ Working Backwards](../explanation/analysis-phase.md#prfaq-working-backwards) pour éprouver votre concept produit |
| `bmad-prd` | Créer, mettre à jour ou valider un PRD[^1] |
| `bmad-create-architecture` | Concevoir l’architecture système |
| `bmad-create-epics-and-stories` | Créer des epics et des stories |
| `bmad-dev-story` | Implémenter une story |
| `bmad-code-review` | Effectuer une revue de code |
| `bmad-quick-dev` | Flux rapide unifié — clarifier l’intention, planifier, implémenter, réviser, présenter |
Consultez la [Carte des workflows](./workflow-map.md) pour la référence complète des workflows organisés par phase.
### Skills de tâche et d'outil
### Skills de tâche et d’outil
Les tâches et outils sont des opérations autonomes qui ne nécessitent pas de contexte d'agent ou de workflow.
Les tâches et outils sont des opérations autonomes qui ne nécessitent pas de contexte d’agent ou de workflow.
**BMad-Help : Votre guide intelligent**
**BMad-Help : Votre guide intelligent**
`bmad-help` est votre interface principale pour découvrir quoi faire ensuite. Il inspecte votre projet, comprend les requêtes en langage naturel et recommande la prochaine étape requise ou optionnelle en fonction de vos modules installés.
@ -120,22 +120,22 @@ bmad-help Quelles sont mes options pour le design UX ?
**Autres tâches et outils principaux**
Le module principal inclut 11 outils intégrés — revues, compression, brainstorming, gestion de documents, et plus. Consultez [Outils principaux](./core-tools.md) pour la référence complète.
Le module principal inclut 12 outils intégrés — specs, revues, brainstorming, personnalisation, gestion de documents, et plus. Consultez [Outils principaux](./core-tools.md) pour la référence complète.
## Convention de nommage
Tous les skills utilisent le préfixe `bmad-` suivi d'un nom descriptif (ex. `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
Tous les skills utilisent le préfixe `bmad-` suivi d’un nom descriptif (ex. `bmad-agent-dev`, `bmad-prd`, `bmad-help`). Consultez [Modules](./modules.md) pour les modules disponibles.
## Dépannage
**Les skills n'apparaissent pas après l'installation.** Certaines plateformes nécessitent d'activer explicitement les skills dans les paramètres. Consultez la documentation de votre IDE ou demandez à votre assistant IA comment activer les skills. Vous devrez peut-être aussi redémarrer votre IDE ou recharger la fenêtre.
**Les skills n’apparaissent pas après l’installation.** Certaines plateformes nécessitent d’activer explicitement les skills dans les paramètres. Consultez la documentation de votre IDE ou demandez à votre assistant IA comment activer les skills. Vous devrez peut-être aussi redémarrer votre IDE ou recharger la fenêtre.
**Des skills attendus sont manquants.** L'installateur génère uniquement les skills pour les modules que vous avez sélectionnés. Exécutez à nouveau `npx bmad-method install` et vérifiez votre sélection de modules. Vérifiez que les fichiers de skill existent dans le répertoire attendu.
**Des skills attendus sont manquants.** L’installateur génère uniquement les skills pour les modules que vous avez sélectionnés. Exécutez à nouveau `npx bmad-method install` et vérifiez votre sélection de modules. Vérifiez que les fichiers de skill existent dans le répertoire attendu.
**Des skills d'un module supprimé apparaissent encore.** L'installateur ne supprime pas automatiquement les anciens fichiers de skill. Supprimez les répertoires obsolètes du répertoire de skills de votre IDE, ou supprimez tout le répertoire de skills et relancez l'installateur pour obtenir un ensemble propre.
**Des skills d’un module supprimé apparaissent encore.** L’installateur ne supprime pas automatiquement les anciens fichiers de skill. Supprimez les répertoires obsolètes du répertoire de skills de votre IDE, ou supprimez tout le répertoire de skills et relancez l’installateur pour obtenir un ensemble propre.
## Glossaire
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
[^2]: Persona : dans le contexte de BMad, un persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l'analyste, Winston l'architecte). Chaque persona garde son "caractère" pendant les interactions.
[^3]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d'un projet ou d'une demande, afin d'aligner rapidement les parties prenantes avant le travail détaillé.
[^2]: Persona : dans le contexte de BMad, un persona désigne un agent IA avec un rôle défini, un style de communication et une expertise spécifiques (ex. Mary l’analyste, Winston l’architecte). Chaque persona garde son « caractère » pendant les interactions.
[^3]: Brief : document synthétique qui formalise le contexte, les objectifs, le périmètre et les contraintes d’un projet ou d’une demande, afin d’aligner rapidement les parties prenantes avant le travail détaillé.

279
docs/fr/reference/core-tools.md
View File

@ -5,71 +5,72 @@ sidebar:
order: 3
---
Chaque installation BMad comprend un ensemble de compétences principales qui peuvent être utilisées conjointement avec tout ce que vous faites — des tâches et des workflows autonomes qui fonctionnent dans tous les projets, tous les modules et toutes les phases. Ceux-ci sont toujours disponibles, quels que soient les modules optionnels que vous installez.
Chaque installation BMad comprend un ensemble de compétences principales utilisables en complément de tout ce que vous faites — des tâches et des workflows autonomes qui fonctionnent dans tous les projets, tous les modules et toutes les phases. Elles restent toujours disponibles, quels que soient les modules optionnels que vous installez.
:::tip[Raccourci Rapide]
Exécutez n'importe quel outil principal en tapant son nom de compétence (par ex., `bmad-help`) dans votre IDE. Aucune session d'agent requise.
Exécutez n’importe quel outil principal en tapant son nom de compétence (par ex., `bmad-help`) dans votre IDE. Aucune session d’agent requise.
:::
## Vue d'ensemble
## Vue d’ensemble
| Outil | Type | Objectif |
|-----------------------------------------------------------------------|----------|------------------------------------------------------------------------------|
| [`bmad-help`](#bmad-help) | Tâche | Obtenir des conseils contextuels sur la prochaine étape |
| [`bmad-brainstorming`](#bmad-brainstorming) | Workflow | Faciliter des sessions de brainstorming interactives |
| [`bmad-party-mode`](#bmad-party-mode) | Workflow | Orchestrer des discussions de groupe multi-agents |
| [`bmad-spec`](#bmad-spec) | Workflow | Distill any intent input into a SPEC kernel and companions (translation pending) |
| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation) | Tâche | Pousser la sortie LLM à travers des méthodes de raffinement itératives |
| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Tâche | Revue cynique qui trouve ce qui manque et ce qui ne va pas |
| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter) | Tâche | Analyse exhaustive des chemins de branchement pour les cas limites non gérés |
| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose) | Tâche | Révision de copie clinique pour la clarté de communication |
| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Tâche | Édition structurelle — coupes, fusions et réorganisation |
| [`bmad-shard-doc`](#bmad-shard-doc) | Tâche | Diviser les fichiers markdown volumineux en sections organisées |
| [`bmad-index-docs`](#bmad-index-docs) | Tâche | Générer ou mettre à jour un index de tous les documents dans un dossier |
| Outil | Type | Objectif |
|-----------------------------------------------------------------------|----------|-------------------------------------------------------------------------------|
| [`bmad-help`](#bmad-help) | Tâche | Obtenir des conseils contextuels sur la prochaine étape |
| [`bmad-brainstorming`](#bmad-brainstorming) | Workflow | Faciliter des sessions de brainstorming interactives |
| [`bmad-party-mode`](#bmad-party-mode) | Workflow | Orchestrer des discussions de groupe multi-agents |
| [`bmad-spec`](#bmad-spec) | Workflow | Distiller toute formulation d’intention en un noyau SPEC et fichiers associés |
| [`bmad-advanced-elicitation`](#bmad-advanced-elicitation) | Tâche | Soumettre la sortie LLM à des méthodes de raffinement itératives |
| [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Tâche | Revue cynique qui traque ce qui manque et ce qui ne va pas |
| [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter) | Tâche | Analyse exhaustive des chemins de branchement pour les cas limites non gérés |
| [`bmad-editorial-review-prose`](#bmad-editorial-review-prose) | Tâche | Correction éditoriale clinique pour la clarté de communication |
| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Tâche | Édition structurelle — coupes, fusions et réorganisation |
| [`bmad-shard-doc`](#bmad-shard-doc) | Tâche | Diviser les fichiers markdown volumineux en sections organisées |
| [`bmad-index-docs`](#bmad-index-docs) | Tâche | Générer ou mettre à jour un index de tous les documents dans un dossier |
| [`bmad-customize`](#bmad-customize) | Tâche | Créer et vérifier des personnalisations BMad |
## bmad-help
**Votre guide intelligent pour la suite.** — Inspecte l'état de votre projet, détecte ce qui a été fait et recommande la prochaine étape requise ou facultative.
**Votre guide intelligent pour la suite.** — Inspecte l’état de votre projet, détecte ce qui a été fait et recommande la prochaine étape requise ou facultative.
**Utilisez-le quand :**
**À utiliser quand :**
- Vous avez terminé un workflow et voulez savoir ce qui suit
- Vous êtes nouveau sur BMad et avez besoin d'orientation
- Vous avez terminé un workflow et voulez savoir quoi faire ensuite
- Vous êtes nouveau sur BMad et avez besoin d’orientation
- Vous êtes bloqué et voulez des conseils contextuels
- Vous avez installé de nouveaux modules et voulez voir ce qui est disponible
**Fonctionnement :**
**Fonctionnement :**
1. Analyse votre projet pour les artefacts existants (PRD, architecture, stories, etc.)
1. Analyse votre projet pour détecter les artefacts existants (PRD, architecture, stories, etc.)
2. Détecte quels modules sont installés et leurs workflows disponibles
3. Recommande les prochaines étapes par ordre de priorité — étapes requises d'abord, puis facultatives
3. Recommande les prochaines étapes par ordre de priorité — étapes requises d’abord, puis facultatives
4. Présente chaque recommandation avec la commande de compétence et une brève description
**Entrée :** Requête optionnelle en langage naturel (par ex., `bmad-help J'ai une idée de SaaS, par où commencer ?`)
**Entrée :** Requête optionnelle en langage naturel (par ex., `bmad-help J'ai une idée de SaaS, par où commencer ?`)
**Sortie :** Liste priorisée des prochaines étapes recommandées avec les commandes de compétence
**Sortie :** Liste priorisée des prochaines étapes recommandées avec les commandes de compétence
## bmad-brainstorming
**Génère des idées diverses à travers des techniques créatives interactives.** — Une session de brainstorming facilitée qui charge des méthodes d'idéation éprouvées depuis une bibliothèque de techniques et vous guide vers plus de 100 idées avant organisation.
**Génère des idées variées grâce à des techniques créatives interactives.** — Une session de brainstorming facilitée qui charge des méthodes d’idéation éprouvées à partir d’une bibliothèque de techniques et vous guide vers plus de 100 idées avant de les organiser.
**Utilisez-le quand :**
**À utiliser quand :**
- Vous commencez un nouveau projet et devez explorer l’espace problème
- Vous êtes bloqué dans la génération d'idées et avez besoin de créativité structurée
- Vous voulez utiliser des cadres d'idéation éprouvés (SCAMPER, brainstorming inversé, etc.)
- Vous êtes bloqué dans la génération d’idées et avez besoin de créativité structurée
- Vous voulez utiliser des cadres d’idéation éprouvés (SCAMPER, brainstorming inversé, etc.)
**Fonctionnement :**
**Fonctionnement :**
1. Configure une session de brainstorming avec votre sujet
2. Charge les techniques créatives depuis une bibliothèque de méthodes
3. Vous guide à travers technique après technique, générant des idées
4. Applique un protocole anti-biais — change de domaine créatif toutes les 10 idées pour éviter le regroupement
2. Charge les techniques créatives à partir d’une bibliothèque de méthodes
3. Vous guide de technique en technique, en générant des idées
4. Applique un protocole anti-biais — bascule de domaine créatif toutes les 10 idées pour éviter les biais de regroupement
5. Produit un document de session en mode ajout uniquement avec toutes les idées organisées par technique
**Entrée :** Sujet de brainstorming ou énoncé de problème, fichier de contexte optionnel
**Entrée :** Sujet de brainstorming ou énoncé de problème, fichier de contexte optionnel
**Sortie :** `brainstorming-session-{date}.md` avec toutes les idées générées
**Sortie :** `brainstorming-session-{date}.md` avec toutes les idées générées
:::note[Cible de Quantité]
La magie se produit dans les idées 50–100. Le workflow encourage la génération de plus de 100 idées avant organisation.
@ -77,195 +78,249 @@ La magie se produit dans les idées 50–100. Le workflow encourage la générat
## bmad-party-mode
**Orchestre des discussions de groupe multi-agents.** — Charge tous les agents BMad installés et facilite une conversation naturelle où chaque agent contribue depuis son expertise et personnalité uniques.
**Orchestre des discussions de groupe multi-agents.** — Charge tous les agents BMad installés et facilite une conversation naturelle où chaque agent apporte son expertise et sa personnalité uniques.
**Utilisez-le quand :**
**À utiliser quand :**
- Vous avez besoin de multiples perspectives d'experts sur une décision
- Vous avez besoin de multiples perspectives d’experts sur une décision
- Vous voulez que les agents remettent en question les hypothèses des autres
- Vous explorez un sujet complexe qui couvre plusieurs domaines
**Fonctionnement :**
**Fonctionnement :**
1. Charge le manifeste d'agents avec toutes les personnalités d'agents installées
1. Charge le manifeste d’agents avec toutes les personnalités d’agents installées
2. Analyse votre sujet pour sélectionner les 2–3 agents les plus pertinents
3. Les agents prennent des tours pour contribuer, avec des échanges naturels et des désaccords
4. Fait rouler la participation des agents pour assurer des perspectives diverses au fil du temps
3. Les agents contribuent à tour de rôle, avec des échanges spontanés et des désaccords
4. Alterne la participation des agents pour garantir des perspectives variées
5. Quittez avec `goodbye`, `end party` ou `quit`
**Entrée :** Sujet de discussion ou question, ainsi que la spécification des personas que vous souhaitez faire participer (optionnel)
**Entrée :** Sujet de discussion ou question, ainsi que la spécification des personas que vous souhaitez faire participer (optionnel)
**Sortie :** Conversation multi-agents en temps réel conservant la personnalité de chaque agent
## bmad-spec
**Distille toute formulation d’intention en un contrat SPEC canonique pour le travail en aval.** — Accepte un brief, un PRD, un GDD, un RFC, un brain dump, une transcription, un dossier UX ou une entrée multi-source mixte et produit un `SPEC.md` structuré autour d’un noyau de cinq champs (Pourquoi, Capacités, Contraintes, Non-objectifs, Signal de succès) ainsi que des fichiers compagnons pour le contenu essentiel qui ne trouve pas sa place dans le noyau.
**À utiliser quand :**
- Vous devez verrouiller le QUOI avant le COMMENT pour tout type de travail (logiciel, game design, recherche, éditorial, politique, entreprise)
- Vous souhaitez un contrat succinct optimisé pour les LLM, sans fioritures, que les compétences en aval peuvent consommer sans relire chaque artefact en amont
- Vous voulez valider ou mettre à jour une spécification existante
**Fonctionnement :**
1. Lit l’entrée et tout document annexe lié
2. Distille en un noyau à cinq champs via un modèle configurable ; redirige l’excédent vers des fichiers compagnons correctement nommés
3. Exécute une auto-validation en deux passes (règles de cohérence, puis préservation de chaque affirmation essentielle de la source)
4. Écrit `SPEC.md`, les compagnons associés, et un `.decision-log.md` sous `{output_folder}/specs/spec-{slug}/`
La loi Spec impose huit règles : les capacités expriment à la fois l’intention et le critère de succès ; les intentions décrivent le QUOI, pas le COMMENT ; les contraintes guident réellement les décisions ; les non-objectifs sont explicites ; les signaux de succès sont concrets ; les identifiants de capacité sont stables ; chaque affirmation essentielle de la source est préservée ; la rédaction est concise.
**Entrée :**
- `input` (requis) — Chemin ou texte fourni directement. Idée vague, brain dump, PRD, GDD, RFC, brief, transcription, dossier de maquettes, multi-source mixte
- `slug` (optionnel) — Requis uniquement lorsque l’entrée est succincte et qu’aucun slug ne peut être dérivé du nom de fichier source
- `target_spec_path` (optionnel) — Définir pour mettre à jour une spécification existante au lieu d’en créer une nouvelle
**Sortie :** Dossier de spécification contenant `SPEC.md`, les éventuels fichiers compagnons, et un `.decision-log.md`. Les appelants en mode headless reçoivent une réponse JSON avec le statut du résultat et la liste des fichiers écrits ou modifiés.
:::note[Contrat de mutation]
`bmad-spec` est le seul outil autorisé à écrire `SPEC.md` et les fichiers compagnons de la spécification. Les autres compétences produisent leurs propres artefacts natifs et invoquent `bmad-spec` en mode headless lorsqu’elles ont besoin d’exprimer une intention sous forme de contrat canonique ou de proposer des mises à jour.
:::
**Sortie :** Conversation multi-agents en temps réel avec des personnalités d'agents maintenues
## bmad-advanced-elicitation
**Passer la sortie du LLM à travers des méthodes de raffinement itératives.** — Sélectionne depuis une bibliothèque de techniques d'élicitation pour améliorer systématiquement le contenu à travers multiples passages.
**Soumet la sortie du LLM à des méthodes de raffinement itératives.** — Sélectionne à partir d’une bibliothèque de techniques d’élicitation pour améliorer systématiquement le contenu en plusieurs passages.
**Utilisez-le quand :**
**À utiliser quand :**
- La sortie du LLM semble superficielle ou générique
- Vous voulez explorer un sujet depuis de multiples angles analytiques
- Vous raffinez un document critique et voulez une réflexion plus approfondie
- Vous voulez explorer un sujet sous plusieurs angles analytiques
- Vous raffinez un document critique et souhaitez une réflexion plus approfondie
**Fonctionnement :**
**Fonctionnement :**
1. Charge le registre de méthodes avec plus de 5 techniques d'élicitation
1. Charge le registre de méthodes avec plus de 5 techniques d’élicitation
2. Sélectionne les 5 méthodes les mieux adaptées selon le type de contenu et la complexité
3. Présente un menu interactif — choisissez une méthode, remélangez, ou listez tout
4. Applique la méthode sélectionnée pour améliorer le contenu
5. Re-présente les options pour l'amélioration itérative jusqu'à ce que vous sélectionniez "Procéder"
5. Affiche à nouveau les options d’amélioration itérative jusqu’à ce que vous sélectionniez « Procéder »
**Entrée :** Section de contenu à améliorer
**Entrée :** Section de contenu à améliorer
**Sortie :** Version améliorée du contenu avec les améliorations appliquées
**Sortie :** Version améliorée du contenu avec les améliorations appliquées
## bmad-review-adversarial-general
**Revue contradictoire qui suppose que des problèmes existent et les recherche.** — Adopte une perspective de réviseur sceptique et blasé avec zéro tolérance pour le travail bâclé. Cherche ce qui manque, pas seulement ce qui ne va pas.
**Revue contradictoire qui part du principe que des problèmes existent et les traque.** — Adopte un regard de réviseur sceptique et blasé, sans aucune tolérance pour le travail bâclé. Cherche ce qui manque, pas seulement ce qui ne va pas.
**Utilisez-le quand :**
**À utiliser quand :**
- Vous avez besoin d'assurance qualité avant de finaliser un livrable
- Vous voulez tester en conditions réelles une spécification, story ou document
- Vous avez besoin d’assurance qualité avant de finaliser un livrable
- Vous voulez éprouver une spécification, une story ou un document
- Vous voulez trouver des lacunes de couverture que les revues optimistes manquent
**Fonctionnement :**
**Fonctionnement :**
1. Lit le contenu avec une perspective contradictoire et critique
2. Identifie les problèmes à travers l'exhaustivité, la justesse et la qualité
1. Lit le contenu avec un regard contradictoire et critique
2. Identifie les problèmes sur les plans de l’exhaustivité, de la justesse et de la qualité
3. Recherche spécifiquement ce qui manque — pas seulement ce qui est présent et faux
4. Doit trouver un minimum de 10 problèmes ou réanalyse plus profondément
4. Doit trouver un minimum de 10 problèmes ou réanalyser plus en profondeur
**Entrée :**
**Entrée :**
- `content` (requis) — Diff, spécification, story, document ou tout artefact
- `also_consider` (optionnel) — Domaines supplémentaires à garder à l'esprit
- `also_consider` (optionnel) — Domaines supplémentaires à garder à l’esprit
**Sortie :** Liste markdown de plus de 10 constatations avec descriptions
**Sortie :** Liste markdown de plus de 10 constatations avec descriptions
## bmad-review-edge-case-hunter
**Parcours tous les chemins de branchement et les conditions limites, ne rapporte que les cas non gérés.** — Méthodologie pure de traçage de chemin[^1] qui dérive mécaniquement les classes de cas limites. Orthogonale à la revue contradictoire — centrée sur la méthode, pas sur l'attitude.
**Parcourt tous les chemins de branchement et les conditions limites, ne signale que les cas non gérés.** — Méthodologie pure de traçage de chemin[^1] qui dérive mécaniquement les classes de cas limites. Orthogonale à la revue contradictoire — centrée sur la méthode, pas sur l’attitude.
**À utiliser quand :**
**À utiliser quand :**
- Vous souhaitez une couverture exhaustive des cas limites pour le code ou la logique
- Vous avez besoin d'un complément à la revue contradictoire (méthodologie différente, résultats différents)
- Vous avez besoin d’un complément à la revue contradictoire (méthodologie différente, résultats différents)
- Vous révisez un diff ou une fonction pour des conditions limites
**Fonctionnement :**
**Fonctionnement :**
1. Énumère tous les chemins de branchement dans le contenu
2. Dérive mécaniquement les classes de cas limites : else/default manquants, entrées non vérifiées, décalage d’unité, overflow arithmétique, coercition implicite des types, conditions de concurrence, écarts de timeout
3. Teste chaque chemin contre les protections existantes
4. Ne rapporte que les chemins non gérés — ignore silencieusement les chemins gérés
2. Dérive mécaniquement les classes de cas limites : else/default manquants, entrées non protégées, erreurs off-by-one, dépassements arithmétiques, conversions de type implicites, conditions de concurrence, dépassements de délai
3. Teste chaque chemin face aux protections existantes
4. Ne signale que les chemins non gérés — ignore silencieusement les chemins gérés
**Entrée :**
**Entrée :**
- `content` (obligatoire) — Diff, fichier complet ou fonction
- `also_consider` (facultatif) — Zones supplémentaires à garder à l’esprit
- `also_consider` (facultatif) — Domaines supplémentaires à garder à l’esprit
**Sortie :** Tableau JSON des résultats, chacun avec `location`, `trigger_condition`, `guard_snippet` et `potential_consequence`
**Sortie :** Tableau JSON des résultats, chacun avec `location`, `trigger_condition`, `guard_snippet` et `potential_consequence`
:::note[Revue Complémentaire]
Exécutez à la fois `bmad-review-adversarial-general` et `bmad-review-edge-case-hunter` pour une couverture orthogonale. La revue contradictoire détecte les problèmes de qualité et de complétude ; le chasseur de cas limites détecte les chemins non gérés.
Exécutez à la fois `bmad-review-adversarial-general` et `bmad-review-edge-case-hunter` pour une couverture orthogonale. La revue contradictoire détecte les problèmes de qualité et de complétude ; le chasseur de cas limites détecte les chemins non gérés.
:::
## bmad-editorial-review-prose
**Relecture éditoriale clinique centrée sur la clarté de communication.** — Analyse le texte pour détecter les problèmes qui nuisent à la compréhension. Applique le Microsoft Writing Style Guide baseline. Préserve la voix de l’auteur.
**Correction éditoriale clinique centrée sur la clarté de communication.** — Analyse le texte pour détecter les problèmes qui nuisent à la compréhension. Applique le Microsoft Writing Style Guide comme référence de base. Préserve la voix de l’auteur.
**À utiliser quand :**
**À utiliser quand :**
- Vous avez rédigé un document et souhaitez polir le style
- Vous avez rédigé un document et souhaitez en polir le style
- Vous devez assurer la clarté pour un public spécifique
- Vous voulez des corrections de communication sans modifier les choix stylistiques
**Fonctionnement :**
**Fonctionnement :**
1. Lit le contenu en ignorant les blocs de code et le frontmatter
2. Identifie les problèmes de communication (pas les préférences de style)
3. Déduit les doublons du même problème à différents emplacements
3. Dédoublonne les occurrences d’un même problème à différents endroits
4. Produit un tableau de corrections en trois colonnes
**Entrée :**
**Entrée :**
- `content` (obligatoire) — Markdown, texte brut ou XML
- `style_guide` (facultatif) — Guide de style spécifique au projet
- `reader_type` (facultatif) — `humans` (par défaut) pour clarté/fluide, ou `llm` pour précision/consistance
**Sortie :** Tableau Markdown en trois colonnes : Texte original | Texte révisé | Modifications
**Sortie :** Tableau Markdown en trois colonnes : Texte original | Texte révisé | Modifications
## bmad-editorial-review-structure
**Édition structurelle — propose des coupes, fusions, déplacements et condensations.** — Révise l'organisation du document et propose des changements substantiels pour améliorer la clarté et le flux avant la révision de copie.
**Édition structurelle — propose des coupes, fusions, réorganisations et condensations.** — Révise l’organisation du document et propose des changements substantiels pour améliorer la clarté et le flux avant la correction éditoriale.
**Utilisez-le quand :**
**À utiliser quand :**
- Un document a été produit depuis de multiples sous-processus et a besoin de cohérence structurelle
- Un document a été produit par plusieurs sous-processus et nécessite une cohérence structurelle
- Vous voulez réduire la longueur du document tout en préservant la compréhension
- Vous devez identifier les violations de portée ou les informations critiques enfouies
**Fonctionnement :**
**Fonctionnement :**
1. Analyse le document contre 5 modèles de structure (Tutoriel, Référence, Explication, Prompt, Stratégique)
2. Identifie les redondances, violations de portée et informations enfouies
3. Produit des recommandations priorisées : COUPER, FUSIONNER, DÉPLACER, CONDENSER, QUESTIONNER, PRÉSERVER
4. Estime la réduction totale en mots et pourcentage
3. Produit des recommandations priorisées : COUPER, FUSIONNER, DÉPLACER, CONDENSER, QUESTIONNER, PRÉSERVER
4. Estime la réduction totale en mots et en pourcentage
**Entrée :**
**Entrée :**
- `content` (requis) — Document à réviser
- `purpose` (optionnel) — Objectif prévu (par ex., "tutoriel de démarrage rapide")
- `purpose` (optionnel) — Objectif prévu (par ex., « tutoriel de démarrage rapide »)
- `target_audience` (optionnel) — Qui lit ceci
- `reader_type` (optionnel) — `humans` ou `llm`
- `length_target` (optionnel) — Réduction cible (par ex., "30% plus court")
- `length_target` (optionnel) — Réduction cible (par ex., « 30% plus court »)
**Sortie :** Résumé du document, liste de recommandations priorisées et réduction estimée
**Sortie :** Résumé du document, liste de recommandations priorisées et réduction estimée
## bmad-shard-doc
**Diviser les fichiers markdown volumineux en fichiers de sections organisés.** — Utilise les en-têtes de niveau 2 comme points de division pour créer un dossier de fichiers de sections autonomes avec un index.
**Fractionne les fichiers markdown volumineux en sections organisées.** — Utilise les en-têtes de niveau 2 comme points de découpe pour créer un dossier de fichiers de sections autonomes avec un index.
**Utilisez-le quand :**
**À utiliser quand :**
- Un document markdown est devenu trop volumineux pour être géré efficacement (plus de 500 lignes)
- Vous voulez diviser un document monolithique en sections navigables
- Vous avez besoin de fichiers séparés pour l'édition parallèle ou la gestion de contexte LLM
- Vous voulez découper un document monolithique en sections navigables
- Vous avez besoin de fichiers séparés pour l’édition parallèle ou la gestion de contexte LLM
**Fonctionnement :**
**Fonctionnement :**
1. Valide que le fichier source existe et est markdown
2. Divise sur les en-têtes de niveau 2 (`##`) en fichiers de sections numérotées
3. Crée un `index.md` avec manifeste de sections et liens
4. Vous invite à supprimer, archiver ou conserver l'original
1. Valide que le fichier source existe et est au format markdown
2. Découpe sur les en-têtes de niveau 2 (`##`) en fichiers de sections numérotées
3. Crée un `index.md` avec le manifeste de sections et les liens
4. Vous invite à supprimer, archiver ou conserver l’original
**Entrée :** Chemin du fichier markdown source, dossier de destination optionnel
**Entrée :** Chemin du fichier markdown source, dossier de destination optionnel
**Sortie :** Dossier avec `index.md` et `01-{section}.md`, `02-{section}.md`, etc.
**Sortie :** Dossier avec `index.md` et `01-{section}.md`, `02-{section}.md`, etc.
## bmad-index-docs
**Générer ou mettre à jour un index de tous les documents dans un dossier.** — Analyse un répertoire, lit chaque fichier pour comprendre son objectif et produit un `index.md` organisé avec liens et descriptions.
**Génère ou met à jour un index de tous les documents dans un dossier.** — Analyse un répertoire, lit chaque fichier pour comprendre son objectif et produit un `index.md` organisé avec liens et descriptions.
**Utilisez-le quand :**
**À utiliser quand :**
- Vous avez besoin d'un index léger pour un scan LLM rapide des documents disponibles
- Un dossier de documentation a grandi et a besoin d'une table des matières organisée
- Vous avez besoin d’un index léger pour un scan LLM rapide des documents disponibles
- Un dossier de documentation a grandi et nécessite une table des matières organisée
- Vous voulez un aperçu auto-généré qui reste à jour
**Fonctionnement :**
**Fonctionnement :**
1. Analyse le répertoire cible pour tous les fichiers non cachés
2. Lit chaque fichier pour comprendre son objectif réel
3. Groupe les fichiers par type, objectif ou sous-répertoire
4. Génère des descriptions concises (3–10 mots chacune)
**Entrée :** Chemin du dossier cible
**Entrée :** Chemin du dossier cible
**Sortie :** `index.md` avec listes de fichiers organisées, liens relatifs et brèves descriptions
**Sortie :** `index.md` avec listes de fichiers organisées, liens relatifs et brèves descriptions
## bmad-customize
**Créer et vérifier des personnalisations.** — Vous aide à modifier le comportement d’un agent ou d’un workflow BMad installé sans avoir à écrire de TOML manuellement.
**À utiliser quand :**
- Vous souhaitez modifier le comportement d’un agent ou d’un workflow
- Vous devez ajouter des faits persistants, des hooks d’activation ou des éléments de menu personnalisés
- Vous voulez que le bon périmètre de surcharge soit sélectionné et vérifié automatiquement
**Fonctionnement :**
1. Analyse les skills BMad installés pour identifier les surfaces personnalisables
2. Sélectionne le bon périmètre pour le changement demandé
3. Écrit les fichiers de surcharge sous `_bmad/custom/`
4. Vérifie la configuration fusionnée
**Entrée :** Description en langage naturel de la personnalisation souhaitée
**Sortie :** Fichiers de surcharge TOML sous `_bmad/custom/`
Pour un guide détaillé sur la personnalisation de BMad, consultez [Comment personnaliser BMad](../how-to/customize-bmad.md).
## Glossaire
[^1]: Path-tracing : méthode d'analyse qui suit systématiquement tous les chemins d'exécution possibles dans un programme pour identifier les cas non gérés.
[^1]: Path-tracing : méthode d’analyse qui suit systématiquement tous les chemins d’exécution possibles dans un programme pour identifier les cas non gérés.

52
docs/fr/reference/modules.md
View File

@ -1,25 +1,25 @@
---
title: Modules Officiels
description: Modules additionnels pour créer des agents personnalisés, de l'intelligence créative, du développement de jeux et des tests
description: Modules additionnels pour créer des agents personnalisés, de l’intelligence créative, du développement de jeux et des tests
sidebar:
order: 5
---
BMad s'étend via des modules officiels que vous sélectionnez lors de l'installation. Ces modules additionnels fournissent des agents, des workflows et des tâches spécialisés pour des domaines spécifiques, au-delà du noyau intégré et de BMM (suite Agile).
BMad s’étend via des modules officiels que vous sélectionnez lors de l’installation. Ces modules additionnels fournissent des agents, des workflows et des tâches spécialisés pour des domaines spécifiques, au-delà du noyau intégré et de BMM (suite Agile).
:::tip[Installer des Modules]
Exécutez `npx bmad-method install` et sélectionnez les modules souhaités. L'installateur gère automatiquement le téléchargement, la configuration et l'intégration IDE.
Exécutez `npx bmad-method install` et sélectionnez les modules souhaités. L’installateur gère automatiquement le téléchargement, la configuration et l’intégration IDE.
:::
## BMad Builder
Créez des agents personnalisés, des workflows et des modules spécifiques à un domaine avec une assistance guidée. BMad Builder est le méta-module pour étendre le framework lui-même.
- **Code :** `bmb`
- **npm :** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
- **GitHub :** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
- **Code :** `bmb`
- **npm :** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
- **GitHub :** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
**Fournit :**
**Fournit :**
- Agent Builder — créez des agents IA spécialisés avec une expertise et un accès aux outils personnalisés
- Workflow Builder — concevez des processus structurés avec des étapes et des points de décision
@ -28,46 +28,46 @@ Créez des agents personnalisés, des workflows et des modules spécifiques à u
## Creative Intelligence Suite
Outils basés sur l'IA pour la créativité structurée, l'idéation et l'innovation pendant le développement en phase amont. La suite fournit plusieurs agents qui facilitent le brainstorming, le design thinking et la résolution de problèmes en utilisant des cadres éprouvés.
Outils basés sur l’IA pour la créativité structurée, l’idéation et l’innovation pendant le développement en phase amont. La suite fournit plusieurs agents qui facilitent le brainstorming, le design thinking et la résolution de problèmes en utilisant des cadres éprouvés.
- **Code :** `cis`
- **npm :** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
- **GitHub :** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
- **Code :** `cis`
- **npm :** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
- **GitHub :** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
**Fournit :**
**Fournit :**
- Agents Innovation Strategist, Design Thinking Coach et Brainstorming Coach
- Problem Solver et Creative Problem Solver pour la pensée systématique et latérale
- Storyteller et Presentation Master pour les récits et les présentations
- Cadres d'idéation incluant SCAMPER[^1], Brainstorming inversé et reformulation de problèmes
- Cadres d’idéation incluant SCAMPER[^1], Brainstorming inversé et reformulation de problèmes
## Game Dev Studio
Workflows de développement de jeux structurés adaptés pour Unity, Unreal, Godot et moteurs personnalisés. Supporte le prototypage rapide via Quick Dev et la production à grande échelle avec des sprints propulsés par epics.
- **Code :** `gds`
- **npm :** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
- **GitHub :** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
- **Code :** `gds`
- **npm :** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
- **GitHub :** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
**Fournit :**
**Fournit :**
- Workflow de génération de Document de Design de Jeu (GDD[^3])
- Mode Quick Dev pour le prototypage rapide
- Support de design narratif pour les personnages, dialogues et construction de monde
- Couverture de plus de 21 types de jeux avec des conseils d'architecture spécifiques au moteur
- Couverture de plus de 21 types de jeux avec des conseils d’architecture spécifiques au moteur
## Test Architect (TEA)
Stratégie de test de niveau entreprise, conseils d'automatisation et décisions de porte de release via un agent expert et neuf workflows structurés. TEA va bien au-delà du workflow QA intégré avec une priorisation basée sur les risques et une traçabilité des exigences.
Stratégie de test de niveau entreprise, conseils d’automatisation et décisions de porte de release via un agent expert et neuf workflows structurés. TEA va bien au-delà du workflow QA intégré avec une priorisation basée sur les risques et une traçabilité des exigences.
- **Code :** `tea`
- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
- **GitHub :** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
- **Code :** `tea`
- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
- **GitHub :** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
**Fournit :**
**Fournit :**
- Agent Murat (Master Test Architect and Quality Advisor)
- Workflows pour la conception de tests, ATDD, l'automatisation, la revue de tests et la traçabilité
- Workflows pour la conception de tests, ATDD, l’automatisation, la revue de tests et la traçabilité
- Évaluation NFR[^2], configuration CI et scaffolding de framework
- Priorisation P0-P3 avec Playwright Utils et intégrations MCP optionnelles
@ -77,6 +77,6 @@ Les modules communautaires et une marketplace de modules sont à venir. Consulte
## Glossaire
[^1]: SCAMPER : acronyme anglais pour une technique de créativité structurée (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse) qui permet d'explorer systématiquement les modifications possibles d'un produit ou d'une idée pour générer des innovations.
[^1]: SCAMPER : acronyme anglais pour une technique de créativité structurée (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse) qui permet d’explorer systématiquement les modifications possibles d’un produit ou d’une idée pour générer des innovations.
[^2]: NFR (Non-Functional Requirement) : exigence décrivant les contraintes de qualité du système (performance, sécurité, fiabilité, ergonomie) plutôt que ses fonctionnalités.
[^3]: GDD (Game Design Document) : document de conception de jeu qui décrit en détail les mécaniques, l'univers, les personnages, les niveaux et tous les aspects du jeu à développer.
[^3]: GDD (Game Design Document) : document de conception de jeu qui décrit en détail les mécaniques, l’univers, les personnages, les niveaux et tous les aspects du jeu à développer.

70
docs/fr/reference/testing.md
View File

@ -1,53 +1,53 @@
---
title: Options de Testing
description: Comparaison du workflow QA intégré avec le module Test Architect (TEA) pour l'automatisation des tests.
description: Comparaison du workflow QA intégré avec le module Test Architect (TEA) pour l’automatisation des tests.
sidebar:
order: 6
---
BMad propose deux approches de test : un workflow QA[^1] intégré pour une génération rapide de tests et un module Test Architect installable pour une stratégie de test de qualité entreprise.
BMad propose deux approches de test : un workflow QA[^1] intégré pour une génération rapide de tests et un module Test Architect installable pour une stratégie de test de qualité entreprise.
## Lequel Choisir ?
## Lequel Choisir ?
| Facteur | QA Intégré | Module TEA |
| Facteur | QA Intégré | Module TEA |
|-------------------------|----------------------------------------------|---------------------------------------------------------------------|
| **Idéal pour** | Projets petits et moyens, couverture rapide | Grands projets, domaines réglementés ou complexes |
| **Installation** | Rien à installer — inclus dans BMM | Installer séparément via `npx bmad-method install` |
| **Approche** | Générer les tests rapidement, itérer ensuite | Planifier d'abord, puis générer avec traçabilité |
| **Installation** | Rien à installer — inclus dans BMM | Installer séparément via `npx bmad-method install` |
| **Approche** | Générer les tests rapidement, itérer ensuite | Planifier d’abord, puis générer avec traçabilité |
| **Types de tests** | Tests API et E2E | API, E2E, ATDD[^2], NFR, et plus |
| **Stratégie** | Chemin nominal + cas limites critiques | Priorisation basée sur les risques (P0-P3) |
| **Nombre de workflows** | 1 (Automate) | 9 (conception, ATDD, automatisation, revue, traçabilité, et autres) |
:::tip[Commencez avec le QA Intégré]
La plupart des projets devraient commencer avec le workflow QA intégré. Si vous avez ensuite besoin d'une stratégie de test, de murs de qualité ou de traçabilité des exigences, installez TEA en complément.
La plupart des projets devraient commencer avec le workflow QA intégré. Si vous avez ensuite besoin d’une stratégie de test, de murs de qualité ou de traçabilité des exigences, installez TEA en complément.
:::
## Workflow QA Intégré
Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l'agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l’agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
**Déclencheur :** `QA` (via l'agent Developer) ou `bmad-qa-generate-e2e-tests`
**Déclencheur :** `QA` (via l’agent Developer) ou `bmad-qa-generate-e2e-tests`
### Ce que le Workflow QA Fait
Le workflow QA exécute un processus unique (Automate) qui parcourt cinq étapes :
1. **Détecte le framework de test** — analyse `package.json` et les fichiers de test existants pour identifier votre framework (Jest, Vitest, Playwright, Cypress, ou tout runner standard). Si aucun n'existe, analyse la pile technologique du projet et en suggère un.
2. **Identifie les fonctionnalités** — demande ce qu'il faut tester ou découvre automatiquement les fonctionnalités dans le codebase.
3. **Génère les tests API** — couvre les codes de statut, la structure des réponses, le chemin nominal, et 1-2 cas d'erreur.
4. **Génére les tests E2E** — couvre les parcours utilisateur avec des localisateurs sémantiques et des assertions sur les résultats visibles.
1. **Détecte le framework de test** — analyse `package.json` et les fichiers de test existants pour identifier votre framework (Jest, Vitest, Playwright, Cypress, ou tout runner standard). Si aucun n’existe, analyse la pile technologique du projet et en suggère un.
2. **Identifie les fonctionnalités** — demande ce qu’il faut tester ou découvre automatiquement les fonctionnalités dans le codebase.
3. **Génère les tests API** — couvre les codes de statut, la structure des réponses, le chemin nominal, et 1-2 cas d’erreur.
4. **Génère les tests E2E** — couvre les parcours utilisateur avec des localisateurs sémantiques et des assertions sur les résultats visibles.
5. **Exécute et vérifie** — lance les tests générés et corrige immédiatement les échecs.
Le workflow QA produit un résumé de test sauvegardé dans le dossier des artefacts d'implémentation de votre projet.
Le workflow QA produit un résumé de test sauvegardé dans le dossier des artefacts d’implémentation de votre projet.
### Patterns de Test
Les tests générés suivent une philosophie "simple et maintenable" :
Les tests générés suivent une philosophie « simple et maintenable » :
- **APIs standard du framework uniquement** — pas d'utilitaires externes ni d'abstractions personnalisées
- **APIs standard du framework uniquement** — pas d’utilitaires externes ni d’abstractions personnalisées
- **Localisateurs sémantiques** pour les tests UI (rôles, labels, texte plutôt que sélecteurs CSS)
- **Tests indépendants** sans dépendances d'ordre
- **Pas d'attentes ou de sleeps codés en dur**
- **Tests indépendants** sans dépendances d’ordre
- **Pas d’attentes ou de sleeps codés en dur**
- **Descriptions claires** qui se lisent comme de la documentation fonctionnelle
:::note[Portée]
@ -59,28 +59,28 @@ Le workflow QA génère uniquement des tests. Pour la revue de code et la valida
- Couverture de test rapide pour une fonctionnalité nouvelle ou existante
- Automatisation de tests accessible aux débutants sans configuration avancée
- Patterns de test standards que tout développeur peut lire et maintenir
- Projets petits et moyens où une stratégie de test complète n'est pas nécessaire
- Projets petits et moyens où une stratégie de test complète n’est pas nécessaire
## Module Test Architect (TEA)
TEA est un module autonome qui fournit un agent expert (Murat) et neuf workflows structurés pour des tests de qualité entreprise. Il va au-delà de la génération de tests pour inclure la stratégie de test, la planification basée sur les risques, les murs de qualité et la traçabilité des exigences.
- **Documentation :** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
- **Installation :** `npx bmad-method install` et sélectionnez le module TEA
- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
- **Documentation :** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
- **Installation :** `npx bmad-method install` et sélectionnez le module TEA
- **npm :** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
### Ce que TEA Fournit
| Workflow | Objectif |
|-----------------------|--------------------------------------------------------------------------------------|
| Test Design | Créer une stratégie de test complète liée aux exigences |
| ATDD | Développement piloté par les tests d'acceptation avec critères des parties prenantes |
| ATDD | Développement piloté par les tests d’acceptation avec critères des parties prenantes |
| Automate | Générer des tests avec des patterns et utilitaires avancés |
| Test Review | Valider la qualité et la couverture des tests par rapport à la stratégie |
| Traceability | Remonter les tests aux exigences pour l'audit et la conformité |
| Traceability | Remonter les tests aux exigences pour l’audit et la conformité |
| NFR Assessment | Évaluer les exigences non-fonctionnelles (performance, sécurité) |
| CI Setup | Configurer l'exécution des tests dans les pipelines d'intégration continue |
| Framework Scaffolding | Configurer l'infrastructure de test et la structure du projet |
| CI Setup | Configurer l’exécution des tests dans les pipelines d’intégration continue |
| Framework Scaffolding | Configurer l’infrastructure de test et la structure du projet |
| Release Gate | Prendre des décisions de livraison go/no-go basées sur les données |
TEA supporte également la priorisation basée sur les risques P0-P3 et des intégrations optionnelles avec Playwright Utils et les outils MCP.
@ -88,24 +88,24 @@ TEA supporte également la priorisation basée sur les risques P0-P3 et des int
### Quand Utiliser TEA
- Projets nécessitant une traçabilité des exigences ou une documentation de conformité
- Équipes ayant besoin d'une priorisation des tests basée sur les risques sur plusieurs fonctionnalités
- Équipes ayant besoin d’une priorisation des tests basée sur les risques sur plusieurs fonctionnalités
- Environnements entreprise avec des murs de qualité formels avant livraison
- Domaines complexes où la stratégie de test doit être planifiée avant d'écrire les tests
- Projets ayant dépassé l'approche à workflow unique du QA intégré
- Domaines complexes où la stratégie de test doit être planifiée avant d’écrire les tests
- Projets ayant dépassé l’approche à workflow unique du QA intégré
## Comment les Tests S'Intègrent dans les Workflows
## Comment les Tests S’Intègrent dans les Workflows
Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s'exécuter **après qu'un epic complet soit terminé** — une fois que toutes les stories d'un epic ont été implémentées et revues. Une séquence typique :
Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s’exécuter **après qu’un epic complet soit terminé** — une fois que toutes les stories d’un epic ont été implémentées et revues. Une séquence typique :
1. Pour chaque story de l'epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
2. Après la fin de l'epic : générer les tests avec `QA` (via l'agent Developer) ou le workflow Automate de TEA
1. Pour chaque story de l’epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
2. Après la fin de l’epic : générer les tests avec `QA` (via l’agent Developer) ou le workflow Automate de TEA
3. Lancer la rétrospective (`bmad-retrospective`) pour capturer les leçons apprises
Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s'intégrer avec les artefacts de planification en amont pour la traçabilité.
Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s’intégrer avec les artefacts de planification en amont pour la traçabilité.
Pour en savoir plus sur la place des tests dans le processus global, consultez la [Carte des Workflows](./workflow-map.md).
## Glossaire
[^1]: QA (Quality Assurance) : assurance qualité, ensemble des processus et activités visant à garantir que le produit logiciel répond aux exigences de qualité définies.
[^2]: ATDD (Acceptance Test-Driven Development) : méthode de développement où les tests d'acceptation sont écrits avant le code, en collaboration avec les parties prenantes pour définir les critères de réussite.
[^2]: ATDD (Acceptance Test-Driven Development) : méthode de développement où les tests d’acceptation sont écrits avant le code, en collaboration avec les parties prenantes pour définir les critères de réussite.

144
docs/fr/reference/workflow-map.md
View File

@ -1,27 +1,27 @@
---
title: "Carte des Workflows"
description: Référence visuelle des phases et des résultats des workflows de la méthode BMad
description: Référence visuelle des phases et des livrables des workflows de la méthode BMad
sidebar:
order: 1
---
La méthode BMad (BMM) est un module de l'écosystème BMad, conçu pour suivre les meilleures pratiques de l'ingénierie du
contexte et de la planification. Les agents IA fonctionnent de manière optimale avec un contexte clair et structuré. Le
système BMM construit ce contexte progressivement à travers 4 phases distinctes — chaque phase, et plusieurs workflows
optionnels au sein de chaque phase, produisent des documents qui alimentent la phase suivante, afin que les agents
sachent toujours quoi construire et pourquoi.
La méthode BMad (BMM) est un module de l’écosystème BMad, conçu pour appliquer les meilleures pratiques d’ingénierie du
contexte et de planification. Les agents IA sont plus performants lorsqu’ils disposent d’un contexte clair et structuré. Le
système BMM construit ce contexte de manière progressive, en 4 phases distinctes — chaque phase, ainsi que les workflows
optionnels qu’elle contient, produit des documents qui nourrissent la phase suivante. Ainsi, les agents savent toujours
ce qu’ils doivent construire et pourquoi.
La logique et les concepts proviennent des méthodologies agiles qui ont été utilisées avec succès dans l'industrie comme
cadre mental de référence.
La logique et les concepts sous-jacents s’appuient sur les méthodologies agiles, largement éprouvées dans l’industrie
comme cadre de référence.
Si à tout moment vous ne savez pas quoi faire, le skill `bmad-help` vous aidera à rester sur la bonne voie ou à savoir
quoi faire ensuite. Vous pouvez toujours vous référer à cette page également — mais `bmad-help` est entièrement
interactif et beaucoup plus rapide si vous avez déjà installé la méthode BMad. De plus, si vous utilisez différents
modules qui ont étendu la méthode BMad ou ajouté d'autres modules complémentaires non extensifs — `bmad-help` évolue
pour connaître tout ce qui est disponible et vous donner les meilleurs conseils du moment.
Si vous ne savez plus où vous en êtes, le skill `bmad-help` vous remettra sur la bonne voie ou vous indiquera la prochaine
étape. Cette page reste une référence utile, mais `bmad-help` est interactif et bien plus rapide si vous avez déjà installé
la méthode BMad. Par ailleurs, si vous utilisez des modules ayant étendu la méthode BMad ou ajouté d’autres modules
complémentaires non extensibles, `bmad-help` s’adapte automatiquement pour couvrir tout ce qui est disponible et vous
fournir les meilleurs conseils en temps réel.
Note finale importante : Chaque workflow ci-dessous peut être exécuté directement avec l'outil de votre choix via un
skill ou en chargeant d'abord un agent et en utilisant l'entrée du menu des agents.
Note importante : chaque workflow ci-dessous peut être exécuté directement via un skill avec l’outil de votre choix, ou
en chargeant d’abord un agent depuis le menu des agents.
<iframe src="/workflow-map-diagram-fr.html" title="Diagramme de la carte des workflows de la méthode BMad" width="100%" height="100%" style="border-radius: 8px; border: 1px solid #334155; min-height: 900px;"></iframe>
@ -29,93 +29,99 @@ skill ou en chargeant d'abord un agent et en utilisant l'entrée du menu des age
<a href="/workflow-map-diagram-fr.html" target="_blank" rel="noopener noreferrer">Ouvrir le diagramme dans un nouvel onglet ↗</a>
</p>
## Phase 1 : Analyse (Optionnelle)
## Phase 1 : Analyse (Optionnelle)
Explorez l’espace problème et validez les idées avant de vous engager dans la planification. [**Découvrez ce que fait
Explorez l’espace problème et validez vos idées avant de vous lancer dans la planification. [**Découvrez ce que fait
chaque outil et quand l’utiliser**](../explanation/analysis-phase.md).
| Workflow | Objectif | Produit |
|---------------------------------------------------------------------------|------------------------------------------------------------------------------------------|---------------------------|
| `bmad-brainstorming` | Brainstormez des idées de projet avec l’accompagnement guidé d’un coach de brainstorming | `brainstorming-report.md` |
| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validez les hypothèses de marché, techniques ou de domaine | Rapport de recherches |
| `bmad-product-brief` | Capturez la vision stratégique — idéal lorsque votre concept est clair | `product-brief.md` |
| `bmad-prfaq` | Working Backwards — éprouvez et forgez votre concept produit | `prfaq-{project}.md` |
| Workflow | Objectif | Livrable |
|---------------------------------------------------------------------------|--------------------------------------------------------------------------------|---------------------------|
| `bmad-brainstorming` | Brainstormez des idées de projet, animé par un coach de brainstorming dédié | `brainstorming-report.md` |
| `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validez vos hypothèses de marché, techniques ou liées au domaine | Rapport de recherches |
| `bmad-product-brief` | Formalisez la vision stratégique — idéal lorsque votre concept est bien défini | `product-brief.md` |
| `bmad-prfaq` | Working Backwards — mettez à l’épreuve et affinez votre concept produit | `prfaq-{project}.md` |
## Phase 2 : Planification
## Phase 2 : Planification
Définissez ce qu'il faut construire et pour qui.
Définissez ce qu’il faut construire et pour qui.
| Workflow | Objectif | Produit |
|-------------------------|---------------------------------------------------------|--------------|
| `bmad-create-prd` | Définissez les exigences (FRs/NFRs)[^1] | `PRD.md`[^2] |
| `bmad-ux` | Concevez l'expérience utilisateur (lorsque l'UX compte) | `DESIGN.md`, `EXPERIENCE.md` |
| Workflow | Objectif | Livrable |
|------------|--------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------|
| `bmad-prd` | Créez, mettez à jour ou validez un PRD[^1] — découverte accompagnée, trois intentions en un seul skill | Création/Mise à jour : `prd.md`, `addendum.md`, `decision-log.md` ; Validation : `validation-report.html` + `.md` |
| `bmad-ux` | Concevez l’expérience utilisateur (lorsque l’UX compte) | `DESIGN.md`, `EXPERIENCE.md` |
## Phase 3 : Solutioning
:::tip[Trois intentions en un seul skill]
`bmad-prd` couvre l’intégralité du cycle de vie du PRD. Précisez votre intention lors de l’appel, sinon le skill vous la demandera :
- **Créer** — nouveau PRD à partir de zéro via une découverte accompagnée ; produit `prd.md`, `addendum.md` et `decision-log.md`
- **Mettre à jour** — réconcilie un PRD existant avec un signal de changement, en mettant en évidence les conflits avant d’appliquer les modifications
- **Valider** — évalue un PRD à l’aide d’une liste de contrôle configurable et produit un rapport de constats structuré au format HTML
:::
:::tip[En amont : `bmad-product-brief`]
`bmad-product-brief` (Phase 1) produit un `product-brief.md` que `bmad-prd` peut exploiter lors de la découverte, réduisant les redondances et gardant les deux documents alignés. Aucun des deux skills ne nécessite l’autre — commencez directement par `bmad-prd` si vous savez déjà ce que vous construisez.
:::
## Phase 3 : Conception de la Solution
Décidez comment le construire et décomposez le travail en stories.
| Workflow | Objectif | Produit |
| Workflow | Objectif | Livrable |
|---------------------------------------|---------------------------------------------------|---------------------------------|
| `bmad-create-architecture` | Rendez les décisions techniques explicites | `architecture.md` avec ADRs[^3] |
| `bmad-create-epics-and-stories` | Décomposez les exigences en travail implémentable | Fichiers d'epic avec stories |
| `bmad-check-implementation-readiness` | Vérification avant implémentation | Décision Passe/Réserves/Échec |
| `bmad-create-architecture` | Rendez explicites les décisions techniques | `architecture.md` avec ADRs[^2] |
| `bmad-create-epics-and-stories` | Décomposez les exigences en tâches implémentables | Fichiers d’epic avec stories |
| `bmad-check-implementation-readiness` | Jalon de validation avant implémentation | Décision OK / RÉSERVES / ÉCHEC |
## Phase 4 : Implémentation
## Phase 4 : Implémentation
Construisez, une story à la fois. Bientôt disponible : automatisation complète de la phase 4 !
Construisez, une story à la fois. L’automatisation complète de la phase 4 arrive bientôt !
| Workflow | Objectif | Produit |
|------------------------|-------------------------------------------------------------------------------------|------------------------------------------------------|
| `bmad-sprint-planning` | Initialisez le suivi (une fois par projet pour séquencer le cycle de développement) | `sprint-status.yaml` |
| `bmad-create-story` | Préparez la story suivante pour implémentation | `story-[slug].md` |
| `bmad-dev-story` | Implémentez la story | Code fonctionnel + tests |
| `bmad-code-review` | Validez la qualité de l'implémentation | Approuvé ou changements demandés |
| `bmad-correct-course` | Gérez les changements significatifs en cours de sprint | Plan mis à jour ou réorientation |
| `bmad-sprint-status` | Suivez la progression du sprint et le statut des stories | Mise à jour du statut du sprint |
| `bmad-retrospective` | Revue après complétion d'un epic | Leçons apprises |
| `bmad-investigate` | Enquête de cas avec conclusions à preuves graduées, calibrée selon l'entrée | `{slug}-investigation.md` |
| Workflow | Objectif | Livrable |
|------------------------|--------------------------------------------------------------------------------------|----------------------------------|
| `bmad-sprint-planning` | Initialisez le suivi (une fois par projet, pour séquencer le cycle de développement) | `sprint-status.yaml` |
| `bmad-create-story` | Préparez la story suivante pour implémentation | `story-[slug].md` |
| `bmad-dev-story` | Implémentez la story | Code fonctionnel + tests |
| `bmad-code-review` | Validez la qualité de l’implémentation | Approuvé ou changements demandés |
| `bmad-correct-course` | Gérez les changements significatifs en cours de sprint | Plan mis à jour ou réorientation |
| `bmad-sprint-status` | Suivez la progression du sprint et le statut des stories | Mise à jour du statut du sprint |
| `bmad-retrospective` | Bilan après l’achèvement d’un epic | Leçons apprises |
| `bmad-investigate` | Analyse forensique avec conclusions pondérées par les preuves, adaptée au cas traité | `{slug}-investigation.md` |
## Quick Dev (Parcours Parallèle)
## Flux Rapide (Parcours Parallèle)
Sautez les phases 1-3 pour les travaux de faible envergure et bien compris.
Ignorez les phases 1 à 3 pour les travaux de faible envergure et bien cernés.
| Workflow | Objectif | Produit |
|------------------|-------------------------------------------------------------------------------------|--------------------|
| `bmad-quick-dev` | Flux rapide unifié — clarifie l'intention, planifie, implémente, révise et présente | `spec-*.md` + code |
| Workflow | Objectif | Livrable |
|------------------|---------------------------------------------------------------------------------------|--------------------|
| `bmad-quick-dev` | Flux rapide unifié — clarifiez l’intention, planifiez, implémentez, révisez et livrez | `spec-*.md` + code |
## Gestion du Contexte
Chaque document devient le contexte de la phase suivante. Le PRD[^2] indique à l'architecte quelles contraintes sont
importantes. L'architecture indique à l'agent de développement quels modèles suivre. Les fichiers de story fournissent
un contexte focalisé et complet pour l'implémentation. Sans cette structure, les agents prennent des décisions
incohérentes.
Chaque document nourrit le contexte de la phase suivante. Le PRD indique à l’architecte les contraintes à respecter.
L’architecture précise à l’agent de développement les modèles à suivre. Les fichiers de story fournissent un contexte
ciblé et exhaustif pour l’implémentation. Sans cette structure, les agents prennent des décisions incohérentes.
### Contexte du Projet
:::tip[Recommandé]
Créez `project-context.md` pour vous assurer que les agents IA suivent les règles et préférences de votre projet. Ce
fichier fonctionne comme une constitution pour votre projet — il guide les décisions d'implémentation à travers tous les
workflows. Ce fichier optionnel peut être généré à la fin de la création de l'architecture, ou dans un projet existant
il peut également être généré pour capturer ce qui est important de conserver aligné avec les conventions actuelles.
Créez `project-context.md` pour que les agents IA respectent les règles et préférences de votre projet. Ce fichier agit
comme une charte pour votre projet — il oriente les décisions d’implémentation à travers tous les workflows. Ce fichier
optionnel peut être généré à la fin de la création de l’architecture, ou, dans un projet existant, pour capturer les
éléments clés et les garder alignés avec les conventions en vigueur.
:::
**Comment le créer :**
**Comment le créer :**
- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre pile technologique et vos règles
d'implémentation
- **Générez-le** — Exécutez `bmad-generate-project-context` pour l'auto-générer à partir de votre architecture ou de
votre codebase
- **Manuellement** — Créez `_bmad-output/project-context.md` avec votre stack technique et vos règles d’implémentation
- **Générez-le** — Exécutez `bmad-generate-project-context` pour l’auto-générer à partir de votre architecture ou de votre codebase
[**En savoir plus sur project-context.md**](../explanation/project-context.md)
## Glossaire
[^1]: FR / NFR (Functional / Non-Functional Requirement) : exigences décrivant respectivement **ce que le système doit
faire** (fonctionnalités, comportements attendus) et **comment il doit le faire** (contraintes de performance, sécurité,
fiabilité, ergonomie, etc.).
[^2]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins
utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur
ce qui doit être construit et pourquoi.
[^3]: ADR (Architecture Decision Record) : document qui consigne une décision d’architecture, son contexte, les options
[^2]: ADR (Architecture Decision Record) : document qui consigne une décision d’architecture, son contexte, les options
envisagées, le choix retenu et ses conséquences, afin d’assurer la traçabilité et la compréhension des décisions
techniques dans le temps.

38
docs/fr/roadmap.mdx
View File

@ -3,7 +3,7 @@ title: Feuille de route
description: La suite pour BMad - Fonctionnalités, améliorations et contributions de la communauté
---
# La Méthode BMad : Feuille de route publique
# La Méthode BMad : Feuille de route publique
La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voici ce sur quoi nous travaillons et ce qui arrive prochainement.
@ -30,17 +30,17 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
<div class="roadmap-future-card">
<span class="roadmap-emoji">📦</span>
<h4>Skills Centralisés</h4>
<p>Installez une fois, utilisez partout. Partagez des skills entre projets sans l'encombrement de fichiers.</p>
<p>Installez une fois, utilisez partout. Partagez des skills entre projets sans l’encombrement de fichiers.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">🔄</span>
<h4>Skills Adaptatifs</h4>
<p>Des skills qui connaissent vos outils. Des variantes optimisées pour Claude, Codex, Kimi et OpenCode, et bien d'autres encore.</p>
<p>Des skills qui connaissent vos outils. Des variantes optimisées pour Claude, Codex, Kimi et OpenCode, et bien d’autres encore.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">📝</span>
<h4>Blog BMad Team Pros</h4>
<p>Guides, articles et perspectives de l'équipe. Lancement prochainement.</p>
<p>Guides, articles et perspectives de l’équipe. Lancement prochainement.</p>
</div>
</div>
@ -60,12 +60,12 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
<div class="roadmap-future-card">
<span class="roadmap-emoji">🚀</span>
<h4>Optimisation Phases 1-3</h4>
<p>Planification éclair avec collecte de contexte par sous-agents. Le mode YOLO rencontre l'excellence guidée.</p>
<p>Planification éclair avec collecte de contexte par sous-agents. Le mode YOLO rencontre l’excellence guidée.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">🌐</span>
<h4>Prêt pour l'Entreprise</h4>
<p>SSO, journaux d'audit, espaces de travail d'équipe. Toutes les choses ennuyantes qui feront dire oui aux entreprises.</p>
<h4>Prêt pour l’Entreprise</h4>
<p>SSO, journaux d’audit, espaces de travail d’équipe. Toutes les choses ennuyantes qui feront dire oui aux entreprises.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">💎</span>
@ -75,7 +75,7 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
<div class="roadmap-future-card">
<span class="roadmap-emoji">⚡</span>
<h4>Automatisation de la Boucle de Développement</h4>
<p>Pilote automatique optionnel pour le développement. Laissez l'IA gérer le flux tout en maintenant une qualité optimale.</p>
<p>Pilote automatique optionnel pour le développement. Laissez l’IA gérer le flux tout en maintenant une qualité optimale.</p>
</div>
</div>
@ -85,12 +85,12 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
<div class="roadmap-future-card">
<span class="roadmap-emoji">🎙️</span>
<h4>Le Podcast de la Méthode BMad</h4>
<p>Conversations sur le développement natif IA. Lancement le 1er mars 2026 !</p>
<p>Conversations sur le développement natif IA. Lancement le 1er mars 2026 !</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">🎓</span>
<h4>Le Master Class de la Méthode BMad</h4>
<p>Passez d'utilisateur à expert. Approfondissements dans chaque phase, chaque workflow, chaque secret.</p>
<p>Passez d’utilisateur à expert. Approfondissements dans chaque phase, chaque workflow, chaque secret.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">🏗️</span>
@ -100,17 +100,17 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
<div class="roadmap-future-card">
<span class="roadmap-emoji">⚡</span>
<h4>BMad Prototype First</h4>
<p>De l'idée au prototype fonctionnel en une seule session. Créez l'application de vos rêves comme une œuvre d'art.</p>
<p>De l’idée au prototype fonctionnel en une seule session. Créez l’application de vos rêves comme une œuvre d’art.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">🌴</span>
<h4>BMad BALM !</h4>
<p>Gestion de vie native IA. Tâches, habitudes, objectifs : votre copilote IA pour tout.</p>
<h4>BMad BALM !</h4>
<p>Gestion de vie native IA. Tâches, habitudes, objectifs : votre copilote IA pour tout.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">🖥️</span>
<h4>UI Officielle</h4>
<p>Une belle interface pour tout l'écosystème BMad. La puissance de la CLI, le polissage de l'interface graphique.</p>
<p>Une belle interface pour tout l’écosystème BMad. La puissance de la CLI, le polissage de l’interface graphique.</p>
</div>
<div class="roadmap-future-card">
<span class="roadmap-emoji">🔒</span>
@ -120,16 +120,16 @@ La Méthode BMad, BMad Method Module (BMM) et BMad Builder (BMB) évoluent. Voic
</div>
<div style="text-align: center; margin-top: 3rem; padding: 2rem; background: var(--color-bg-card); border-radius: 12px; border: 1px solid var(--color-border);">
<h3 style="margin: 0 0 1rem;">Envie de contribuer ?</h3>
<h3 style="margin: 0 0 1rem;">Envie de contribuer ?</h3>
<p style="color: var(--slate-color-400); margin: 0;">
Ce n'est qu'une liste partielle de ce qui est prévu. L'équipe Open Source BMad accueille les contributeurs !{" "}<br />
<a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Rejoignez-nous sur GitHub</a> pour aider à façonner l'avenir du développement propulsé par l'IA.
Ce n’est qu’une liste partielle de ce qui est prévu. L’équipe Open Source BMad accueille les contributeurs !{" "}<br />
<a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Rejoignez-nous sur GitHub</a> pour aider à façonner l’avenir du développement propulsé par l’IA.
</p>
<p style="color: var(--slate-color-400); margin: 1.5rem 0 0;">
Vous aimez ce que nous construisons ? Nous apprécions le soutien ponctuel et mensuel sur{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">Buy Me a Coffee</a>.
Vous aimez ce que nous construisons ? Nous apprécions le soutien ponctuel et mensuel sur{" "}<a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">Buy Me a Coffee</a>.
</p>
<p style="color: var(--slate-color-400); margin: 1rem 0 0;">
Pour les parrainages d'entreprise, les demandes de partenariat, les interventions, les formations ou les demandes médias :{" "}
Pour les parrainages d’entreprise, les demandes de partenariat, les interventions, les formations ou les demandes médias :{" "}
<a href="mailto:contact@bmadcode.com" style="color: var(--color-in-progress);">contact@bmadcode.com</a>
</p>
</div>

225
docs/fr/tutorials/getting-started.md
View File

@ -1,90 +1,91 @@
---
title: "Premiers pas"
description: Installer BMad et construire votre premier projet
description: Installer BMad et développer votre premier projet
---
Construisez des logiciels plus rapidement en utilisant des workflows propulsés par l'IA avec des agents spécialisés qui vous guident à travers la planification, l'architecture et l'implémentation.
Accélérez le développement de vos applications grâce à des workflows alimentés par l’IA et des agents spécialisés qui vous guident dans la planification, l’architecture et l’implémentation.
## Ce que vous allez apprendre
- Installer et initialiser la méthode BMad pour un nouveau projet
- Utiliser **BMad-Help** — votre guide intelligent qui sait quoi faire ensuite
- Choisir la bonne voie de planification selon la taille de votre projet
- Progresser à travers les phases, des exigences au code fonctionnel
- Progresser dans les phases, de la définition des exigences au code fonctionnel
- Utiliser efficacement les agents et les workflows
:::note[Prérequis]
- **Node.js 20.12+** — Requis pour l'installateur
- **Git** — Recommandé pour le contrôle de version
- **IDE IA** — Claude Code, Cursor, ou similaire
- **Une idée de projet** — Même simple, elle fonctionne pour apprendre
- **Node.js 20.12+** — Nécessaire pour l’installation
- **Git** — Recommandé pour la gestion de versions
- **IDE avec IA intégrée** — Claude Code, Cursor ou équivalent
- **Une idée de projet** — Même simple, elle fera l’affaire pour commencer
:::
:::tip[Le chemin le plus simple]
:::tip[Le chemin le plus rapide]
**Installer** → `npx bmad-method install`
**Demander** → `bmad-help que dois-je faire en premier ?`
**Construire** → Laissez BMad-Help vous guider workflow par workflow
**Développez** → Laissez BMad-Help vous guider, workflow par workflow
:::
## Découvrez BMad-Help : votre guide intelligent
## Découvrez BMad-Help : votre guide intelligent
**BMad-Help est le moyen le plus rapide de démarrer avec BMad.** Vous n'avez pas besoin de mémoriser les workflows ou les phases — posez simplement la question, et BMad-Help va :
**BMad-Help est le moyen le plus rapide de démarrer avec BMad.** Pas besoin de mémoriser les workflows ou les phases — posez simplement votre question et BMad-Help saura :
- **Inspecter votre projet** pour voir ce qui a déjà été fait
- **Vous montrer vos options** en fonction des modules que vous avez installés
- **Recommander la prochaine étape** — y compris la première tâche obligatoire
- **Répondre aux questions** comme « J'ai une idée de SaaS, par où commencer ? »
- **Vous présenter vos options** en fonction des modules installés
- **Vous recommander la prochaine étape** — y compris la première tâche obligatoire
- **Répondre à vos questions**, par exemple : « J’ai une idée de SaaS, par où commencer ? »
### Comment utiliser BMad-Help
Exécutez-le dans votre IDE avec IA en invoquant la skill :
Dans votre IDE IA, invoquez le skill :
```
bmad-help
```
Ou combinez-le avec une question pour obtenir des conseils adaptés au contexte :
Ou accompagnez-le d’une question pour obtenir des conseils contextualisés :
```
bmad-help J'ai une idée de produit SaaS, je connais déjà toutes les fonctionnalités que je veux. Par où dois-je commencer ?
```
BMad-Help répondra avec :
BMad-Help vous indiquera :
- Ce qui est recommandé pour votre situation
- Quelle est la première tâche obligatoire
- À quoi ressemble le reste du processus
### Il alimente aussi les workflows
### Il intervient aussi dans les workflows
BMad-Help ne se contente pas de répondre aux questions — **il s'exécute automatiquement à la fin de chaque workflow** pour vous dire exactement quoi faire ensuite. Pas de devinettes, pas de recherche dans la documentation — juste des conseils clairs sur le prochain workflow requis.
BMad-Help ne se contente pas de répondre aux questions — **il se lance automatiquement à la fin de chaque workflow** pour vous indiquer exactement la suite. Finies les devinettes et les recherches dans la doc : vous recevez des instructions claires sur le prochain workflow à exécuter.
:::tip[Commencez ici]
Après avoir installé BMad, invoquez immédiatement la skill `bmad-help`. Elle détectera les modules que vous avez installés et vous guidera vers le bon point de départ pour votre projet.
Après avoir installé BMad, invoquez immédiatement le skill `bmad-help`. Il détectera les modules que vous avez installés et vous orientera vers le bon point de départ pour votre projet.
:::
## Comprendre BMad
BMad vous aide à construire des logiciels grâce à des workflows guidés avec des agents IA spécialisés. Le processus suit quatre phases :
BMad vous aide à développer des logiciels grâce à des workflows guidés par des agents IA spécialisés. Le processus s’articule en quatre phases :
| Phase | Nom | Ce qui se passe |
|-------|----------------|----------------------------------------------------------------|
| 1 | Analyse | Brainstorming, recherche, product brief ou PRFAQ *(optionnel)* |
| 2 | Planification | Créer les exigences (PRD[^1] ou spécification technique) |
| 3 | Solutioning | Concevoir l'architecture *(BMad Method/Enterprise uniquement)* |
| 4 | Implémentation | Construire epic[^2] par epic, story[^3] par story |
| 1 | Analyse | Brainstorming, recherche, product brief ou PRFAQ _(optionnel)_ |
| 2 | Planification | Définir les exigences (PRD[^1] ou spécification technique) |
| 3 | Solutioning | Concevoir l’architecture _(BMad Method/Enterprise uniquement)_ |
| 4 | Implémentation | Développer epic[^2] par epic, story[^3] par story |
**[Ouvrir la carte des workflows](../reference/workflow-map.md)** pour explorer les phases, les workflows et la gestion du contexte.
**[Ouvrez la carte des workflows](../reference/workflow-map.md)** pour explorer les phases, les workflows et la gestion du contexte.
Selon la complexité de votre projet, BMad propose trois voies de planification :
| Voie | Idéal pour | Documents créés |
|------------------|------------------------------------------------------------------------------|----------------------------------------|
| **Quick Dev** | Corrections de bugs, fonctionnalités simples, périmètre clair (1-15 stories) | Spécification technique uniquement |
| **méthode BMad** | Produits, plateformes, fonctionnalités complexes (10-50+ stories) | PRD + Architecture + UX[^4] |
| **BMad Method** | Produits, plateformes, fonctionnalités complexes (10-50+ stories) | PRD + Architecture + UX[^4] |
| **Enterprise** | Conformité, systèmes multi-tenant[^5] (30+ stories) | PRD + Architecture + Security + DevOps |
:::note
Les comptes de stories sont indicatifs, pas des définitions. Choisissez votre voie en fonction des besoins de planification, pas du calcul des stories.
Le nombre de stories est indicatif, pas strictement défini. Choisissez votre voie en fonction de vos besoins de planification, pas d’un simple décompte de stories.
:::
## Installation
@ -95,13 +96,14 @@ Ouvrez un terminal dans le répertoire de votre projet et exécutez :
npx bmad-method install
```
Si vous souhaitez la version préliminaire la plus récente au lieu du canal de release par défaut, utilisez `npx bmad-method@next install`.
Si vous préférez la dernière version préliminaire au lieu du canal de publication par défaut, utilisez `npx bmad-method@next install`.
Lorsque vous êtes invité à sélectionner des modules, choisissez **méthode BMad**.
À l’invite de sélection des modules, choisissez **BMad Method**.
L’installateur crée deux dossiers :
L'installateur crée deux dossiers :
- `_bmad/` — agents, workflows, tâches et configuration
- `_bmad-output/` — vide pour l'instant, mais c'est là que vos artefacts seront enregistrés
- `_bmad-output/` — vide pour le moment, mais c’est là que seront enregistrés vos artefacts
:::tip[Votre prochaine étape]
Ouvrez votre IDE avec IA dans le dossier du projet et exécutez :
@ -110,108 +112,120 @@ Ouvrez votre IDE avec IA dans le dossier du projet et exécutez :
bmad-help
```
BMad-Help détectera ce que vous avez accompli et recommandera exactement quoi faire ensuite. Vous pouvez aussi lui poser des questions comme « Quelles sont mes options ? » ou « J'ai une idée de SaaS, par où devrais-je commencer ? »
BMad-Help détectera ce que vous avez déjà accompli et vous recommandera exactement la suite. Vous pouvez aussi lui poser des questions comme « Quelles sont mes options ? » ou « J’ai une idée de SaaS, par où devrais-je commencer ? »
:::
:::note[Comment charger les agents et exécuter les workflows]
Chaque workflow possède une **skill** que vous invoquez par nom dans votre IDE (par ex., `bmad-create-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l'exécutera — vous n'avez pas besoin de charger les agents séparément. Vous pouvez aussi invoquer directement une skill d'agent pour une conversation générale (par ex., `bmad-agent-pm` pour l'agent PM).
Chaque workflow possède une **skill** que vous invoquez par son nom dans votre IDE (par ex. `bmad-prd`). Votre outil IA reconnaîtra le nom `bmad-*` et l’exécutera — pas besoin de charger les agents séparément. Vous pouvez aussi invoquer directement une skill d’agent pour une conversation générale (par ex. `bmad-agent-pm` pour l’agent PM).
:::
:::caution[Nouveaux chats]
Démarrez toujours un nouveau chat pour chaque workflow. Cela évite que les limitations de contexte ne causent des problèmes.
Démarrez toujours un nouveau chat pour chaque workflow. Cela évite les problèmes liés aux limites de contexte de l’IA.
:::
## Étape 1 : Créer votre plan
## Étape 1 : Élaborer votre plan
Travaillez à travers les phases 1-3. **Utilisez de nouveaux chats pour chaque workflow.**
Parcourez les phases 1 à 3. **Utilisez un nouveau chat pour chaque workflow.**
:::tip[Contexte de projet (Optionnel)]
Avant de commencer, envisagez de créer `project-context.md` pour documenter vos préférences techniques et règles d'implémentation. Cela garantit que tous les agents IA suivent vos conventions tout au long du projet.
:::tip[Contexte projet (optionnel)]
Avant de commencer, pensez à créer `project-context.md` pour documenter vos préférences techniques et vos règles d’implémentation. Ainsi, tous les agents IA respecteront vos conventions tout au long du projet.
Créez-le manuellement dans `_bmad-output/project-context.md` ou générez-le après l'architecture en utilisant `bmad-generate-project-context`. [En savoir plus](../explanation/project-context.md).
Créez-le manuellement à l’emplacement `_bmad-output/project-context.md`, ou générez-le après l’architecture avec `bmad-generate-project-context`. [En savoir plus](../explanation/project-context.md).
:::
### Phase 1 : Analyse (Optionnel)
### Phase 1 : Analyse (optionnelle)
Tous les workflows de cette phase sont optionnels. [**Vous ne savez pas lequel choisir ?**](../explanation/analysis-phase.md)
Tous les workflows de cette phase sont optionnels. [**Pas sûr de quel outil utiliser ?**](../explanation/analysis-phase.md)
- **brainstorming** (`bmad-brainstorming`) — Idéation guidée
- **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Recherche marché, domaine et technique
- **product-brief** (`bmad-product-brief`) — Document de base recommandé lorsque votre concept est clair
- **prfaq** (`bmad-prfaq`) — Défi Working Backwards pour éprouver et forger votre concept produit
- **product-brief** (`bmad-product-brief`) — Document fondateur recommandé une fois votre concept bien défini
- **prfaq** (`bmad-prfaq`) — Exercice Working Backwards pour tester et affiner votre concept produit
### Phase 2 : Planification (Requis)
### Phase 2 : Planification (requise)
**Pour les voies BMad Method et Enterprise :**
1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
2. Exécutez le workflow `bmad-create-prd` (`bmad-create-prd`)
3. Sortie : `PRD.md`
**Pour les voies BMad Method et Enterprise :**
**Pour la voie Quick Dev :**
- Exécutez `bmad-quick-dev` — il gère la planification et l'implémentation dans un seul workflow, passez directement à l'implémentation
1. Exécutez `bmad-prd` dans un nouveau chat — précisez votre intention (Create / Update / Validate) ou laissez le skill vous la demander
2. Résultat : `prd.md`, `addendum.md`, `decision-log.md`
:::note[Design UX (Optionnel)]
Si votre projet a une interface utilisateur, invoquez l'**agent Designer UX** (`bmad-agent-ux-designer`) et exécutez le workflow de design UX (`bmad-ux`) après avoir créé votre PRD.
:::note[Intentions de `bmad-prd`]
- **Create** — exploration guidée à partir de zéro ; le skill nomme le dossier de travail et vous accompagne jusqu’à l’obtention d’un PRD dont vous serez fier
- **Update** — pointez vers un PRD existant et un changement à apporter ; le skill met en évidence les conflits avant d’appliquer les modifications
- **Validate** — critiquez un PRD finalisé à l’aide d’une liste de contrôle et générez un rapport HTML des constatations
:::
### Phase 3 : Solutioning (méthode BMad/Enterprise)
**Créer l'Architecture**
**Pour la voie Quick Dev :**
- Exécutez `bmad-quick-dev` — ce workflow couvre la planification et l’implémentation en une seule fois ; vous pouvez passer directement à l’implémentation
:::note[Design UX (optionnel)]
Si votre projet comporte une interface utilisateur, invoquez l'**agent UX Designer** (`bmad-agent-ux-designer`) et lancez le workflow de design UX (`bmad-ux`) après avoir créé votre PRD.
:::
### Phase 3 : Solutioning (BMad Method/Enterprise)
**Créer l’architecture**
1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
2. Exécutez `bmad-create-architecture` (`bmad-create-architecture`)
3. Sortie : Document d'architecture avec les décisions techniques
3. Résultat : document d’architecture avec les décisions techniques
**Créer les Epics et Stories**
**Créer les epics et les stories**
:::tip[Amélioration V6]
Les epics et stories sont maintenant créés *après* l'architecture. Cela produit des stories de meilleure qualité car les décisions d'architecture (base de données, patterns d'API, pile technologique) affectent directement la façon dont le travail doit être décomposé.
Les epics et stories sont désormais créés *après* l’architecture. Cela produit des stories de meilleure qualité, car les décisions d’architecture (choix de la base de données, patterns d’API, pile technologique) influencent directement la façon dont le travail doit être découpé.
:::
1. Invoquez l'**agent PM** (`bmad-agent-pm`) dans un nouveau chat
2. Exécutez `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
3. Le workflow utilise à la fois le PRD et l'Architecture pour créer des stories techniquement éclairées
3. Le workflow s’appuie sur le PRD et l’architecture pour créer des stories techniquement fondées
**Vérification de la préparation à l’implémentation** *(fortement recommandée)*
**Vérification de préparation à l'implémentation** *(Hautement recommandé)*
1. Invoquez l'**agent Architecte** (`bmad-agent-architect`) dans un nouveau chat
2. Exécutez `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
3. Valide la cohérence entre tous les documents de planification
3. Valide la cohérence de l’ensemble des documents de planification
## Étape 2 : Construire votre projet
## Étape 2 : Développer votre projet
Une fois la planification terminée, passez à l'implémentation. **Chaque workflow doit s'exécuter dans un nouveau chat.**
Une fois la planification terminée, passez à l’implémentation. **Chaque workflow doit être exécuté dans un nouveau chat.**
### Initialiser la planification de sprint
Invoquez **l’agent Développeur** (`bmad-agent-dev`) et lancez `bmad-sprint-planning`. Cela crée `sprint-status.yaml` pour suivre tous les epics et stories.
Invoquez l'**agent Développeur** (`bmad-agent-dev`) et exécutez `bmad-sprint-planning` (`bmad-sprint-planning`). Cette commande crée `sprint-status.yaml` pour suivre tous les epics et stories.
### Le cycle de construction
### Le cycle de développement
Pour chaque story, répétez ce cycle avec de nouveaux chats :
Pour chaque story, répétez ce cycle dans de nouveaux chats :
| Étape | AGENT | Workflow | Commande | Objectif |
| Étape | Agent | Workflow | Commande | Objectif |
|-------|-------|---------------------|---------------------|--------------------------------------|
| 1 | DEV | `bmad-create-story` | `bmad-create-story` | Créer le fichier story depuis l'epic |
| 1 | DEV | `bmad-create-story` | `bmad-create-story` | Créer le fichier story depuis l’epic |
| 2 | DEV | `bmad-dev-story` | `bmad-dev-story` | Implémenter la story |
| 3 | DEV | `bmad-code-review` | `bmad-code-review` | Validation de qualité *(recommandé)* |
| 3 | DEV | `bmad-code-review` | `bmad-code-review` | Validation qualité *(recommandée)* |
Après avoir terminé toutes les stories d'un epic, invoquez **l’agent Développeur** (`bmad-agent-dev`), et exécutez `bmad-retrospective`.
Après avoir terminé toutes les stories d’un epic, invoquez l'**agent Développeur** (`bmad-agent-dev`) et exécutez `bmad-retrospective` (`bmad-retrospective`).
## Ce que vous avez accompli
Vous avez appris les fondamentaux de la construction avec BMad :
Vous maîtrisez maintenant les bases du développement avec BMad :
- Installé BMad et configuré pour votre IDE
- Initialisé un projet avec votre voie de planification choisie
- Créé des documents de planification (PRD, Architecture, Epics & Stories)
- Compris le cycle de construction pour l'implémentation
- Installation et configuration de BMad pour votre IDE
- Initialisation d’un projet avec la voie de planification choisie
- Création des documents de planification (PRD, Architecture, Epics & Stories)
- Compréhension du cycle de développement pour l’implémentation
Votre projet contient maintenant :
Votre projet contient désormais :
```text
your-project/
├── _bmad/ # Configuration BMad
├── _bmad-output/
│ ├── planning-artifacts/
│ │ ├── PRD.md # Votre document d'exigences
│ │ ├── PRD.md # Document d'exigences
│ │ ├── architecture.md # Décisions techniques
│ │ └── epics/ # Fichiers epic et story
│ ├── implementation-artifacts/
@ -224,12 +238,12 @@ your-project/
| Workflow | Commande | Agent | Objectif |
|---------------------------------------|---------------------------------------|-----------|-----------------------------------------------------------------|
| **`bmad-help`** ⭐ | `bmad-help` | Tous | **Votre guide intelligent — posez n'importe quelle question !** |
| `bmad-create-prd` | `bmad-create-prd` | PM | Créer le document d'exigences produit |
| `bmad-create-architecture` | `bmad-create-architecture` | Architect | Créer le document d'architecture |
| **`bmad-help`** ⭐ | `bmad-help` | Tous | **Votre guide intelligent — posez n’importe quelle question !** |
| `bmad-prd` | `bmad-prd` | Tous | Créer, mettre à jour ou valider un PRD |
| `bmad-create-architecture` | `bmad-create-architecture` | Architect | Créer le document d’architecture |
| `bmad-generate-project-context` | `bmad-generate-project-context` | Analyst | Créer le fichier de contexte projet |
| `bmad-create-epics-and-stories` | `bmad-create-epics-and-stories` | PM | Décomposer le PRD en epics |
| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Valider la cohérence de planification |
| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Valider la cohérence de la planification |
| `bmad-sprint-planning` | `bmad-sprint-planning` | DEV | Initialiser le suivi de sprint |
| `bmad-create-story` | `bmad-create-story` | DEV | Créer un fichier story |
| `bmad-dev-story` | `bmad-dev-story` | DEV | Implémenter une story |
@ -237,31 +251,32 @@ your-project/
## Questions fréquentes
**Ai-je toujours besoin d'une architecture ?**
Uniquement pour les voies méthode BMad et Enterprise. Quick Dev passe directement de la spécification technique (spec) à l'implémentation.
**Ai-je toujours besoin d’une architecture ?**
Seulement pour les voies BMad Method et Enterprise. Quick Dev passe directement de la spécification à l’implémentation.
**Puis-je modifier mon plan plus tard ?**
Oui. Utilisez `bmad-correct-course` pour gérer les changements de périmètre en cours d’implémentation.
**Puis-je modifier mon plan en cours de route ?**
Oui. Le workflow `bmad-correct-course` gère les changements de périmètre en cours d’implémentation.
**Et si je veux d'abord faire du brainstorming ?**
Invoquez l'agent Analyst (`bmad-agent-analyst`) et exécutez `bmad-brainstorming` (`bmad-brainstorming`) avant de commencer votre PRD.
**Et si je veux d’abord brainstormer ?**
Invoquez l’agent Analyste (`bmad-agent-analyst`) et exécutez `bmad-brainstorming` (`bmad-brainstorming`) avant de commencer votre PRD.
**Dois-je suivre un ordre strict ?**
Pas strictement. Une fois que vous maîtrisez le flux, vous pouvez exécuter les workflows directement en utilisant la référence rapide ci-dessus.
**Dois-je suivre un ordre strict ?**
Pas strictement. Une fois le flux maîtrisé, vous pouvez exécuter les workflows directement en vous référant au tableau ci-dessus.
## Obtenir de l'aide
## Obtenir de l’aide
:::tip[Premier arrêt : BMad-Help]
**Invoquez `bmad-help` à tout moment** — c'est le moyen le plus rapide de se débloquer. Posez n'importe quelle question :
- « Que dois-je faire après l'installation ? »
- « Je suis bloqué sur le workflow X »
- « Quelles sont mes options pour Y ? »
- « Montre-moi ce qui a été fait jusqu'ici »
:::tip[Premier réflexe : BMad-Help]
**Invoquez `bmad-help` à tout moment** — c’est le moyen le plus rapide de vous débloquer. Posez-lui n’importe quelle question :
BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous dit exactement quoi faire ensuite.
- « Que dois-je faire après l’installation ? »
- « Je suis bloqué sur le workflow X »
- « Quelles sont mes options pour Y ? »
- « Montre-moi ce qui a été fait jusqu’ici »
BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous indique exactement la prochaine étape.
:::
- **Pendant les workflows** — Les agents vous guident avec des questions et des explications
- **Pendant les workflows** — Les agents vous guident à l’aide de questions et d’explications
- **Communauté** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
## Points clés à retenir
@ -269,16 +284,16 @@ BMad-Help inspecte votre projet, détecte ce que vous avez accompli et vous dit
:::tip[Retenez ceci]
- **Commencez par `bmad-help`** — Votre guide intelligent qui connaît votre projet et vos options
- **Utilisez toujours de nouveaux chats** — Démarrez un nouveau chat pour chaque workflow
- **La voie compte** — Quick Dev utilise `bmad-quick-dev` ; La méthode BMad/Enterprise nécessitent PRD et architecture
- **BMad-Help s'exécute automatiquement** — Chaque workflow se termine par des conseils sur la prochaine étape
- **Le choix de la voie est important** — Quick Dev utilise `bmad-quick-dev` ; BMad Method/Enterprise nécessitent un PRD et une architecture
- **BMad-Help se lance automatiquement** — Chaque workflow se termine par des conseils sur la prochaine étape
:::
Prêt à commencer ? Installez BMad, invoquez `bmad-help`, et laissez votre guide intelligent vous montrer le chemin.
Prêt à commencer ? Installez BMad, invoquez `bmad-help`, et laissez votre guide intelligent vous accompagner.
## Glossaire
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d'aligner les équipes sur ce qui doit être construit et pourquoi.
[^1]: PRD (Product Requirements Document) : document de référence qui décrit les objectifs du produit, les besoins utilisateurs, les fonctionnalités attendues, les contraintes et les critères de succès, afin d’aligner les équipes sur ce qui doit être construit et pourquoi.
[^2]: Epic : grand ensemble de fonctionnalités ou de travaux qui peut être décomposé en plusieurs user stories.
[^3]: Story (User Story) : description courte et simple d'une fonctionnalité du point de vue de l'utilisateur ou du client. Elle représente une unité de travail implémentable en un court délai.
[^4]: UX (User Experience) : expérience utilisateur, englobant l'ensemble des interactions et perceptions d'un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, comportements et contexte d'utilisation.
[^5]: Multi-tenant : architecture logicielle où une seule instance de l'application sert plusieurs clients (tenants) tout en maintenant leurs données isolées et sécurisées les unes des autres.
[^3]: Story (User Story) : description courte et simple d’une fonctionnalité du point de vue de l’utilisateur ou du client. Elle représente une unité de travail implémentable en un court délai.
[^4]: UX (User Experience) : expérience utilisateur, englobant l’ensemble des interactions et perceptions d’un utilisateur face à un produit. Le design UX vise à créer des interfaces intuitives, efficaces et agréables en tenant compte des besoins, des comportements et du contexte d’utilisation.
[^5]: Multi-tenant : architecture logicielle où une seule instance de l’application sert plusieurs clients (tenants) tout en maintenant leurs données isolées et sécurisées les unes des autres.

17
docs/reference/agents.md
View File

@ -11,18 +11,18 @@ This page lists the default BMM (Agile suite) agents that install with BMad Meth
## Notes
- Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-dev`) is used to invoke the agent.
- Triggers are the short menu codes (e.g., `CP`) and fuzzy matches shown in each agent menu.
- Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-agent-dev`) is used to invoke the agent.
- Triggers are the short menu codes (e.g., `PRD`) and fuzzy matches shown in each agent menu.
- QA test generation is handled by the `bmad-qa-generate-e2e-tests` workflow skill, available through the Developer agent. The full Test Architect (TEA) lives in its own module.
| Agent | Skill ID | Triggers | Primary workflows |
| --------------------------- | -------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
| Analyst (Mary) | `bmad-analyst` | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorm, Market Research, Domain Research, Technical Research, Create Brief, PRFAQ Challenge, Document Project |
| Product Manager (John) | `bmad-pm` | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course |
| Architect (Winston) | `bmad-architect` | `CA`, `IR` | Create Architecture, Implementation Readiness |
| Analyst (Mary) | `bmad-agent-analyst` | `BP`, `MR`, `DR`, `TR`, `CB`, `WB`, `DP` | Brainstorm, Market Research, Domain Research, Technical Research, Create Brief, PRFAQ Challenge, Document Project |
| Product Manager (John) | `bmad-agent-pm` | `PRD`, `CE`, `IR`, `CC` | Create/Update/Validate PRD, Create Epics and Stories, Implementation Readiness, Correct Course |
| Architect (Winston) | `bmad-agent-architect` | `CA`, `IR` | Create Architecture, Implementation Readiness |
| Developer (Amelia) | `bmad-agent-dev` | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER`, `IN` | Dev Story, Quick Dev, QA Test Generation, Code Review, Sprint Planning, Create Story, Epic Retrospective, [Forensic Investigation](../explanation/forensic-investigation.md) |
| UX Designer (Sally) | `bmad-ux-designer` | `CU` | Create UX Design |
| Technical Writer (Paige) | `bmad-tech-writer` | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |
| UX Designer (Sally) | `bmad-agent-ux-designer` | `CU` | Create UX Design |
| Technical Writer (Paige) | `bmad-agent-tech-writer` | `DP`, `WD`, `MG`, `VD`, `EC` | Document Project, Write Document, Mermaid Generate, Validate Doc, Explain Concept |
## Trigger Types
@ -32,7 +32,7 @@ Agent menu triggers use two different invocation types. Knowing which type a tri
Most triggers load a structured workflow file. Type the trigger code and the agent starts the workflow, prompting you for input at each step.
Examples: `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
Examples: `PRD` (Create, update, or validate PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
### Conversational triggers (arguments required)
@ -41,7 +41,6 @@ Some triggers start a free-form conversation instead of a structured workflow. T
| Agent | Trigger | What to provide |
| --- | --- | --- |
| Technical Writer (Paige) | `WD` | Description of the document to write |
| Technical Writer (Paige) | `US` | Preferences or conventions to add to standards |
| Technical Writer (Paige) | `MG` | Diagram description and type (sequence, flowchart, etc.) |
| Technical Writer (Paige) | `VD` | Document to validate and focus areas |
| Technical Writer (Paige) | `EC` | Concept name to explain |

11
docs/reference/commands.md
View File

@ -42,8 +42,8 @@ The installer writes skill files into an IDE-specific directory inside your proj
| IDE / CLI | Skills directory |
| --- | --- |
| Claude Code | `.claude/skills/` |
| Cursor | `.cursor/skills/` |
| Windsurf | `.windsurf/skills/` |
| Cursor | `.agents/skills/` |
| Windsurf | `.agents/skills/` |
| Other IDEs | See the installer output for the target path |
Each skill is a directory containing a `SKILL.md` file. For example, a Claude Code installation looks like:
@ -80,8 +80,8 @@ Agent skills load a specialized AI persona with a defined role, communication st
| Example skill | Agent | Role |
| --- | --- | --- |
| `bmad-agent-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
| `bmad-pm` | John (Product Manager) | Creates and validates PRDs |
| `bmad-architect` | Winston (Architect) | Designs system architecture |
| `bmad-agent-pm` | John (Product Manager) | Creates and validates PRDs |
| `bmad-agent-architect` | Winston (Architect) | Designs system architecture |
See [Agents](./agents.md) for the full list of default agents and their triggers.
@ -94,6 +94,7 @@ Workflow skills run a structured, multi-step process without loading an agent pe
| `bmad-product-brief` | Create or update a product brief — guided discovery when your concept is clear |
| `bmad-prfaq` | [Working Backwards PRFAQ](../explanation/analysis-phase.md#prfaq-working-backwards) challenge to stress-test your product concept |
| `bmad-prd` | Create, update, or validate a Product Requirements Document |
| `bmad-ux` | Design user experience |
| `bmad-create-architecture` | Design system architecture |
| `bmad-create-epics-and-stories` | Create epics and stories |
| `bmad-dev-story` | Implement a story |
@ -120,7 +121,7 @@ bmad-help What are my options for UX design?
**Other Core Tasks and Tools**
The core module includes 11 built-in tools — reviews, compression, brainstorming, document management, and more. See [Core Tools](./core-tools.md) for the complete reference.
The core module includes 12 built-in tools — specs, reviews, brainstorming, customization, document management, and more. See [Core Tools](./core-tools.md) for the complete reference.
## Naming Convention

24
docs/reference/core-tools.md
View File

@ -26,6 +26,7 @@ Run any core tool by typing its skill name (e.g., `bmad-help`) in your IDE. No a
| [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Task | Structural editing — cuts, merges, and reorganization |
| [`bmad-shard-doc`](#bmad-shard-doc) | Task | Split large markdown files into organized sections |
| [`bmad-index-docs`](#bmad-index-docs) | Task | Generate or update an index of all docs in a folder |
| [`bmad-customize`](#bmad-customize) | Task | Create and verify BMad customization overrides |
## bmad-help
@ -295,3 +296,26 @@ Run both `bmad-review-adversarial-general` and `bmad-review-edge-case-hunter` to
**Input:** Target folder path
**Output:** `index.md` with organized file listings, relative links, and brief descriptions
## bmad-customize
**Create and verify customization overrides.** — Helps you change how an installed BMad agent or workflow behaves without hand-authoring TOML.
**Use it when:**
- You want to change an agent or workflow behavior
- You need to add persistent facts, activation hooks, or custom menu items
- You want the right override scope selected and verified automatically
**How it works:**
1. Scans installed BMad skills for customizable surfaces
2. Selects the right scope for your requested change
3. Writes override files under `_bmad/custom/`
4. Verifies the merged configuration
**Input:** Natural language description of the customization you want
**Output:** TOML override files under `_bmad/custom/`
For a detailed guide on customizing BMad, see [How to Customize BMad](../how-to/customize-bmad.md).

16
src/bmm-skills/3-solutioning/bmad-create-epics-and-stories/steps/step-01-validate-prerequisites.md
View File

@ -48,7 +48,7 @@ Verify required documents exist and are complete:
1. **PRD.md** - Contains requirements (FRs and NFRs) and product scope
2. **Architecture.md** - Contains technical decisions, API contracts, data models
3. **UX Design.md** (if UI exists) - Contains interaction patterns, mockups, user flows
3. **UX design contract** (if UI exists) - Contains visual identity, interaction patterns, mockups, and user flows
### 2. Document Discovery and Validation
@ -66,8 +66,16 @@ Search for required documents using these patterns (sharded means a large docume
**UX Design Document Search (Optional):**
1. `{planning_artifacts}/*ux*.md` (whole document)
2. `{planning_artifacts}/*ux*/index.md` (sharded version)
1. `{planning_artifacts}/ux-designs/ux-*/DESIGN.md` and `{planning_artifacts}/ux-designs/ux-*/EXPERIENCE.md` (bmad-ux spine pair)
2. `{planning_artifacts}/*ux*.md` (legacy whole document)
3. `{planning_artifacts}/*ux*/index.md` (legacy sharded version)
For each matching bmad-ux run folder, treat `DESIGN.md` and `EXPERIENCE.md` as one UX design contract:
- Confirm and load both files together. `DESIGN.md` owns visual identity and design tokens; `EXPERIENCE.md` owns information architecture, behavior, states, interactions, accessibility, and journeys.
- Add both files to the `inputDocuments: []` frontmatter array.
- If only one spine exists, report the incomplete pair and ask whether the user wants to include the partial UX handoff.
- If multiple run folders match, show each run folder with the spine frontmatter `status` and `updated` values when available, then ask the user which UX design contract to include.
Before proceeding, Ask the user if there are any other documents to include for analysis, and if anything found should be excluded. Wait for user confirmation. Once confirmed, create the {planning_artifacts}/epics.md from the ../templates/epics-template.md and in the front matter list the files in the array of `inputDocuments: []`.
@ -136,7 +144,7 @@ Review the Architecture document for technical requirements that impact epic and
**IMPORTANT**: The UX Design Specification is a first-class input document, not supplementary material. Requirements from the UX spec must be extracted with the same rigor as PRD functional requirements.
Read the FULL UX Design document and extract ALL actionable work items:
Read the FULL UX design contract and extract ALL actionable work items. For a bmad-ux spine pair, read both `DESIGN.md` and `EXPERIENCE.md`:
**Look for:**

3
src/bmm-skills/4-implementation/bmad-code-review/SKILL.md
View File

@ -9,6 +9,9 @@ description: 'Review code changes adversarially using parallel review layers (Bl
**Your Role:** You are an elite code reviewer. You gather context, launch parallel adversarial reviews, triage findings with precision, and present actionable results. No noise, no filler.
Subagents, when the capability is available, are an important part of this workflow. Use them as directed by the workflow steps.
If you need an explicit user instruction to run them, ask once now for the whole workflow run.
## Conventions
- Bare paths (e.g. `checklist.md`) resolve from the skill root.

3
src/bmm-skills/4-implementation/bmad-create-story/SKILL.md
View File

@ -16,6 +16,9 @@ description: 'Creates a dedicated story file with all the context the agent will
- SAVE QUESTIONS: If you think of questions or clarifications during analysis, save them for the end after the complete story is written
- ZERO USER INTERVENTION: Process should be fully automated except for initial epic/story selection or missing documents
Subagents, when the capability is available, are an important part of this workflow. Use them as directed by the workflow steps.
If you need an explicit user instruction to run them, ask once now for the whole workflow run.
## Conventions
- Bare paths (e.g. `discover-inputs.md`) resolve from the skill root.

3
src/bmm-skills/4-implementation/bmad-quick-dev/SKILL.md
View File

@ -9,6 +9,9 @@ description: 'Implements any user intent, requirement, story, bug fix or change
**CRITICAL:** If a step says "read fully and follow step-XX", you read and follow step-XX. No exceptions.
Subagents, when the capability is available, are an important part of this workflow. Use them as directed by the workflow steps.
If you need an explicit user instruction to run them, ask once now for the whole workflow run.
## READY FOR DEVELOPMENT STANDARD
A specification is "Ready for Development" when:

28
src/bmm-skills/4-implementation/bmad-retrospective/SKILL.md
View File

@ -225,12 +225,12 @@ Amelia (Developer): "Perfect. Epic {{epic_number}} is complete and ready for ret
</step>
<step n="0.5" goal="Discover and load project documents">
<step n="2" goal="Discover and load project documents">
<action>Load input files according to the Input Files table above. For SELECTIVE_LOAD inputs, load only the epic matching {{epic_number}}. For FULL_LOAD inputs, load the complete document. For INDEX_GUIDED inputs, check the index first and load relevant sections. After discovery, these content variables are available: {epics_content} (selective load for this epic), {architecture_content}, {prd_content}, {document_project_content}</action>
<note>After discovery, these content variables are available: {epics_content} (selective load for this epic), {architecture_content}, {prd_content}, {document_project_content}</note>
</step>
<step n="2" goal="Deep Story Analysis - Extract Lessons from Implementation">
<step n="3" goal="Deep Story Analysis - Extract Lessons from Implementation">
<output>
Amelia (Developer): "Before we start the team discussion, let me review all the story records to surface key themes. This'll help us have a richer conversation."
@ -324,7 +324,7 @@ Amelia (Developer): "We'll get to all of it. But first, let me load the previous
</step>
<step n="3" goal="Load and Integrate Previous Epic Retrospective">
<step n="4" goal="Load and Integrate Previous Epic Retrospective">
<action>Calculate previous epic number: {{prev_epic_num}} = {{epic_number}} - 1</action>
@ -420,7 +420,7 @@ Charlie (Senior Dev): "First epic, first retro. Let's make it count."
</step>
<step n="4" goal="Preview Next Epic with Change Detection">
<step n="5" goal="Preview Next Epic with Change Detection">
<action>Calculate next epic number: {{next_epic_num}} = {{epic_number}} + 1</action>
@ -509,7 +509,7 @@ Amelia (Developer): "No problem. We'll still do a thorough retro on Epic {{epic_
</step>
<step n="5" goal="Initialize Retrospective with Rich Context">
<step n="6" goal="Initialize Retrospective with Rich Context">
<action>Load agent roster from {agent_roster}</action>
<action>Identify which agents participated in Epic {{epic_number}} based on story records</action>
@ -599,7 +599,7 @@ Amelia (Developer): "Exactly. {user_name}, any questions before we dive in?"
</step>
<step n="6" goal="Epic Review Discussion - What Went Well, What Didn't">
<step n="7" goal="Epic Review Discussion - What Went Well, What Didn't">
<output>
Amelia (Developer): "Let's start with the good stuff. What went well in Epic {{epic_number}}?"
@ -673,7 +673,7 @@ Alice (Product Owner): "I appreciate that. I could've been more proactive about
Amelia (Developer): "This is good. We're identifying systemic improvements, not assigning blame."
</output>
<action>Continue the discussion, weaving in patterns discovered from the deep story analysis (Step 2)</action>
<action>Continue the discussion, weaving in patterns discovered from the deep story analysis (Step 3)</action>
<output>
Amelia (Developer): "Speaking of patterns, I noticed something when reviewing all the story records..."
@ -744,13 +744,13 @@ Amelia (Developer): "Does that capture it? Anyone have something important we mi
</step>
<step n="7" goal="Next Epic Preparation Discussion - Interactive and Collaborative">
<step n="8" goal="Next Epic Preparation Discussion - Interactive and Collaborative">
<check if="{{next_epic_exists}} == false">
<output>
Amelia (Developer): "Normally we'd discuss preparing for the next epic, but since Epic {{next_epic_num}} isn't defined yet, let's skip to action items."
</output>
<action>Skip to Step 8</action>
<action>Skip to Step 9</action>
</check>
<output>
@ -868,7 +868,7 @@ Amelia (Developer): "{user_name}, does this preparation plan work for you?"
</step>
<step n="8" goal="Synthesize Action Items with Significant Change Detection">
<step n="9" goal="Synthesize Action Items with Significant Change Detection">
<output>
Amelia (Developer): "Let's capture concrete action items from everything we've discussed."
@ -1109,7 +1109,7 @@ Amelia (Developer): "Everyone clear on what they own?"
</step>
<step n="9" goal="Critical Readiness Exploration - Interactive Deep Dive">
<step n="10" goal="Critical Readiness Exploration - Interactive Deep Dive">
<output>
Amelia (Developer): "Before we close, I want to do a final readiness check."
@ -1292,7 +1292,7 @@ Charlie (Senior Dev): "Better to catch this now than three stories into the next
</step>
<step n="10" goal="Retrospective Closure with Celebration and Commitment">
<step n="11" goal="Retrospective Closure with Celebration and Commitment">
<output>
Amelia (Developer): "We've covered a lot of ground today. Let me bring this retrospective to a close."
@ -1368,7 +1368,7 @@ Amelia (Developer): "See you all when prep work is done. Meeting adjourned!"
</step>
<step n="11" goal="Save Retrospective and Update Sprint Status">
<step n="12" goal="Save Retrospective and Update Sprint Status">
<action>Ensure retrospectives folder exists: {implementation_artifacts}</action>
<action>Create folder if it doesn't exist</action>
@ -1425,7 +1425,7 @@ Retrospective document was saved successfully, but {sprint_status_file} may need
</step>
<step n="12" goal="Final Summary and Handoff">
<step n="13" goal="Final Summary and Handoff">
<output>
**✅ Retrospective Complete, {user_name}!**

2
src/bmm-skills/4-implementation/bmad-retrospective/customize.toml
View File

@ -34,7 +34,7 @@ persistent_facts = [
"file:{project-root}/**/project-context.md",
]
# Scalar: executed when the workflow reaches Step 12 (Final Summary and Handoff),
# Scalar: executed when the workflow reaches Step 13 (Final Summary and Handoff),
# after the retrospective document is saved and sprint-status is updated. Override wins.
# Leave empty for no custom post-completion behavior.

80
src/core-skills/bmad-brainstorming/SKILL.md
View File

@ -1,6 +1,82 @@
---
name: bmad-brainstorming
description: 'Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods. Use when the user says help me brainstorm or help me ideate.'
description: Facilitate a brainstorming session using diverse creative techniques. Use when the user says 'help me brainstorm' or 'help me ideate'.
---
Follow the instructions in ./workflow.md.
# BMad Brainstorming
## Overview
You are a creative brainstorming coach. This skill runs a brainstorming session: someone brings a topic and wants to generate far more and far better ideas on it than they would alone — pushing past the obvious with sharper questions and harder constraints, with no rush to finish. The best sessions end with the user surprised by what came out.
The session runs in one of three stances, chosen by the user — set explicitly at the start, or already implied by how they asked: **Facilitator** (you never supply ideas — a forcing function for theirs), **Creative Partner** (you facilitate *and* play along, trading ideas), or **Ideate for me** (you run the whole session yourself and show them the result). The chosen stance holds for the whole run.
## Conventions
- Bare paths (e.g. `references/headless.md`) resolve from `{skill-root}` (where `customize.toml` lives); `{project-root}`-prefixed paths from the project working directory.
- `{workflow.<name>}` resolves to fields in the merged `customize.toml` `[workflow]` table.
## On Activation
1. Resolve customization: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`. On failure, use a subagent to read `{skill-root}/customize.toml` directly with defaults.
2. Run each `{workflow.activation_steps_prepend}` entry. Treat each `{workflow.persistent_facts}` entry as foundational context (`file:`-prefixed entries are paths/globs under `{project-root}` — load their contents; others are facts verbatim).
3. Load `{project-root}/_bmad/core/config.yaml` (and `config.user.yaml` if present); resolve `{user_name}`, `{communication_language}`, `{document_output_language}`, `{output_folder}`, `{project_name}`, `{date}`. Missing → neutral defaults; never block.
4. **If launched headless** (a machine signal, not a human asking for output — `references/headless.md` lists them): load `references/headless.md` and follow it for the whole run. It is the *only* context where you generate ideas yourself; never load it otherwise.
5. **Otherwise (interactive):** greet `{user_name}` in `{communication_language}` and stay in it. Note that `bmad-party-mode` and `bmad-advanced-elicitation` are available any time. Glob `{workflow.output_dir}/*/.memlog.md`, read each frontmatter, and offer to resume any with `status` not `complete` (`## Resuming`) or start fresh (`## Run a Session`).
Run each `{workflow.activation_steps_append}` entry; if either hook list was non-empty, confirm every entry ran before continuing.
## Framing — hold this the whole run
These fight your defaults, in every mode; hold them deliberately. The stance you pick adds one more frame (`references/mode-*.md`) on top.
- **Aim past 100 ideas; resist concluding.** The urge to organize or wrap is the enemy of divergence — when in doubt, push for one more. Land only when the user is spent or the topic is mined out.
- **Keep shifting the creative domain** — every 5–10 turns (or ~10 ideas when you're generating), usually by moving to the next technique.
- **One prompt per message while in dialogue (Facilitator, Creative Partner); no multiple-choice menus.** Don't stack questions into a wall or hand a menu that invites lazy picking — both pull the user out of generating. The only exceptions are the two up-front *process* choices (stance, and the technique flow): *how* to run is theirs to pick; *what* to ideate never is.
**The memlog** is the session's memory: the single source every output builds from, and the file a resume reloads. Whatever isn't in it is gone. Log every idea, decision, question, and bit of user direction — anything you'd regret losing if the window closed — one line each, the gist in the user's meaning, in time order; never edit or reorder. Skip your prompts and small talk. All writes go through `scripts/memlog.py` (atomic; don't read it back mid-session — resume is the one exception):
- `memlog.py init --workspace {doc_workspace} --field topic="<topic>" --field goal="<goal>" --field mode="<facilitator|partner|autonomous>"` — create it once topic, goal, and stance are known.
- `memlog.py append --workspace {doc_workspace} --type <kind> --text "<one-line gist>"` — log one entry. `--type` ∈ `idea`/`insight`/`question`/`decision`/`direction`/`technique` (a switch: `--text "started <name>"`); omit for a plain note. Add `--by user`/`--by coach` to mark authorship — **required in Creative Partner mode** (renders `(idea by user)`); skip it otherwise.
- `memlog.py set --workspace {doc_workspace} --key status --value complete` — flip status at wrap-up.
(Each is `python3 {skill-root}/scripts/memlog.py …`.)
## Run a Session
Open with one compound question — **what are we brainstorming, and what's the goal or why behind it?** (plus any inputs or special requests). The why shapes technique choice and synthesis (*kids' iPhone apps to build with your own kids* vs. *to win market share* point different ways). If the kickoff already made both clear, skip the question and confirm; read anything they point you to. Derive a kebab-case `{topic_slug}` and bind `{doc_workspace} = {workflow.output_dir}/{workflow.output_folder_name}/`.
Now set the **stance** and the **technique batch** in one step — the composer page does both, so make it the default.
**The composer page (primary).** The file is `{skill-root}/assets/brain-selector.html`. With a customized catalog (overridden `{workflow.brain_methods}` or any `{workflow.additional_techniques}`), regenerate it first: `python3 {skill-root}/scripts/brain.py --file {workflow.brain_methods} [--extra {doc_workspace}/extra-techniques.json] html --out {doc_workspace}/brain-selector.html` (pass `--extra`, a JSON list of `{category, technique_name, description}`, when there are additional techniques; the file is then `{doc_workspace}/brain-selector.html`). Try to open it (`open` / `xdg-open` / `start`), then say, in one message: *"It should open in your browser — compose your session, click **Copy prompt**, and paste the result back. If it didn't open, open `<path>` yourself, or say 'let's do it in chat'."* You can't see their browser, so never claim it opened.
Read the pasted block: the **`Facilitation mode:`** line → the stance; the **listed techniques** (full category/name/description, some tagged `(random pick)`) → run them as given, no `list`/`show` needed; **`invent N`** / **`you choose N`** → see `## Choosing Techniques`.
**Or in chat.** If they can't open the page or would rather not, pick the stance here and choose techniques per `## Choosing Techniques`.
Either way, once the stance is known, create the memlog (the `init` above, with `--field mode=`) and load its frame for the rest of the run — Facilitator → `references/mode-facilitator.md`, Creative Partner → `references/mode-partner.md`, Ideate for me → `references/mode-autonomous.md`. Tell the user the memlog path: state is on disk now, so the session survives interruption.
## Choosing Techniques
For **Facilitator** and **Creative Partner**. (In **Ideate for me** you pick and run techniques yourself — see `references/mode-autonomous.md`.)
Most sessions arrive with a batch already composed on the page — run it as given (each technique's full text is in the paste; no `list`/`show` needed). Two parts of a paste delegate back to you:
- **`invent N`** (Inventive Flow) — invent N brand-new techniques on the fly. A line may scope an invention (`invent 1 new technique in the spirit of <category>`, from the page's per-category invent card) — when it does, honor that category's spirit. Announce the order, log each one's name + description, and offer to save a keeper to `{workflow.additional_techniques}` at wrap-up.
- **`you choose N`** (Facilitator Chosen) — pick N techniques fitting the goal, `{workflow.favorite_techniques}` first; confirm exact names with a scoped `python3 {skill-root}/scripts/brain.py --file {workflow.brain_methods} list --category <cat>`. Never pull the library whole into context.
If they didn't use the page, load `references/in-chat-techniques.md` and pick the batch in chat (**3–4 is the sweet spot**).
Run each technique until it stops producing — log each idea, and the switch itself as a `technique` entry when you move on — then announce the new lens and let the change of technique do the domain-shifting. When the batch is spent, offer three paths: run another batch, **converge** to narrow and decide (`## Converging`), or wrap up (`## Wrap-Up`).
## Converging
The catalog is all *divergent* — built to generate. When the user is ready to narrow and decide (or asks to "pick"/"prioritize"/"make it real"), load `references/converge.md` and follow it; it ends by handing off to `## Wrap-Up`. Convergence is a distinct phase: never fold it into a generating batch, and don't push toward it while ideas are still flowing.
## Resuming
Picking up an existing session instead of starting fresh: load `references/resume.md` and follow it.
## Wrap-Up
Load `references/finalize.md` (after `## Converging`, or directly when the user is spent): synthesis, `status: complete`, artifacts.

239
src/core-skills/bmad-brainstorming/analysis/catalog-analysis.md Normal file
View File

@ -0,0 +1,239 @@
# BMad Brainstorming Catalog — Deep Analysis
> Analysis of the brainstorming library (`assets/brain-methods.csv`) and the selection
> experience (`assets/brain-selector.html`, generated by `scripts/brain.py`). Companion
> data: `method-matrix.csv` (every method tagged on 4 axes).
>
> **Status (implemented, uncommitted for review):** CSV extended with `provenance` /
> `good_for` / `audience` columns; 8 researched `classic` methods added (108 total);
> `brain.py` now renders a "Proven & Professional" lead group, super-group ordering, a
> "Great for" goal filter, and a per-category "Invent a … technique" card; convergence
> shipped as `references/converge.md` (diverge → converge → finalize) and wired into
> `SKILL.md`. Sections below are the rationale.
---
## 1. TL;DR
The catalog is strong, distinctive, and well-built. The opportunities are not "more methods" so much as **navigation and intent**:
1. **The selector sorts categories alphabetically.** There is no ordering/grouping layer, so the well-known professional methods (SCAMPER, Six Hats, Five Whys, etc.) are scattered across four categories and buried below `Absurdist` and `Biomimetic`. Enterprise users meet whimsy before they meet anything they recognize. → **Add a grouping + ordering layer; lead with a "Proven & Professional" group.**
2. **Nothing connects the user's stated goal to technique choice.** The skill asks for the goal up front but then offers an alphabetical wall. The single highest-value addition is a **goal → technique affinity layer** so "I'm adding a feature to a brownfield app" surfaces a different short-list than "planning a sabbatical."
3. **The catalog is 100% divergent (generative).** There is essentially no *convergence* (prioritize / cluster / decide). This is partly a sound principle and partly a real gap — see §5.
4. **Real overlap exists**, but it's mostly "same cognitive move, different costume." Four mechanisms (perspective-shift, constraint, analogy, inversion) account for ~60 of 100 methods; sensory, questioning, systems, and time-shift are comparatively thin.
5. **Descriptions should stay terse** — the brevity is correct. Only two targeted fixes are warranted: the `collaborative` category silently assumes multiple humans, and ~10 "vibe-only" methods lack an output anchor.
6. **Per-category "invent on the fly" is a good idea** — but implement it as a generated synthetic card per section, not 13 near-duplicate CSV rows.
---
## 2. Method — how this was analyzed
Each of the 100 methods was tagged on **four independent axes** (see `method-matrix.csv`). Category alone only captures *aesthetic/mechanism*; these four axes are what expose grouping, overlap, gaps, and the goal-routing opportunity.
| Axis | Values | Answers |
|---|---|---|
| **Provenance** | `classic` · `signature` · `playful` | What goes in the enterprise "proven" group? |
| **Mechanism** (primary + secondary) | inversion · analogy · perspective · constraint · decomposition · time-shift · systems · sensory · questioning · combination · provocation · convergence | Where is the catalog redundant vs thin? |
| **Goal affinity** (multi) | feature · novel · personal · strategy · planning · diagnosis · unstuck | Given the user's goal, what should we recommend? |
| **Audience** | solo · group · either | What breaks in a 1:1 user+LLM session? |
---
## 3. Findings
### 3a. Provenance — the "proven & professional" set exists, but is scattered
The methods an innovation consultant or enterprise facilitator would recognize by name are spread across `structured`, `deep`, `creative`, and `collaborative`. The **canonical core (~22)**:
> SCAMPER · Six Thinking Hats · Mind Mapping · Lotus Blossom · Crazy 8s · Disney Method ·
> Starbursting · Morphological Analysis · Five Whys · Laddering · Causal Loop Mapping ·
> First Principles · Reverse Brainstorming · Assumption Reversal · Worst Possible Idea ·
> Provocation (PO) · Question Storming · Brainwriting/Round Robin · Yes-And · Random Stimulation ·
> Role Playing · Analogical Thinking
A second tier is *recognizable-adjacent* (Concept Blending, Forced Relationships, Decision Tree, Solution Matrix, Failure Analysis/pre-mortem, Devil's Advocate, 1000x Budget). Everything else is `signature` (BMad-original, serious) or `playful` (the delight layer — `wild`, `absurdist`, `theatrical`, much of `quantum`/`cultural`).
**Recommendation — lead with "Proven & Professional."** Three ways to implement (pick in review):
- **Option A — Tag + generated lead section (recommended).** Add a `provenance` column to the CSV. `brain.py` renders a synthetic **"Proven & Professional"** section *first* (pulling all `classic`-tagged methods, cross-category), then the existing categories grouped and ordered (see §7). A method keeps its home category and also appears in the lead group. Pro: zero loss of mechanism categorization; enterprise sees credibility first. Con: those ~22 methods appear twice on the browse page (arguably fine — or filter them out of their home category).
- **Option B — New `classic` category.** Move the ~22 into a single first category. Pro: simplest. Con: destroys the mechanism grouping (SCAMPER is *also* structured; Five Whys is *also* deep), and the category becomes a grab-bag.
- **Option C — Two-level groups only, no provenance tag.** Reorder the 13 categories into super-groups (§7) so "serious" comes first, but don't pull classics out. Pro: cleanest data model. Con: doesn't actually cluster the *named* methods — they stay scattered within their categories.
My pick: **A.** It satisfies "professional methods grouped and shown first" literally, without flattening the taxonomy that makes the rest of the catalog shine.
### 3b. Mechanism — the catalog has four over-served "spines"
Primary-mechanism distribution across the 100:
| Mechanism | ~count | Read |
|---|---|---|
| **perspective-shift** | ~18 | Over-served. Role Playing, Six Hats, Persona, Alien, Ancestor Council, Inner Child, Future Self, Drunk Uncle, Golden Retriever, Infomercial… all "adopt another viewpoint," differentiated only by *who*. |
| **constraint** | ~16 | Over-served. What If, the entire `constraint` category, 1000x, Post-Scarcity, Parallel Universe, Zombie, Quantum Tunneling, Permission Giving… all "add/remove/exaggerate a limit." |
| **analogy / transfer** | ~12 | Healthy. Analogical, Metaphor, Cross-Pollination, Trait Transfer, Nature's Solutions, Fusion Cuisine, Proverb, Random Stimulation. |
| **inversion** | ~11 | Healthy but clustered. Reverse, Assumption Reversal, Worst Idea, Anti-Solution, Failure Analysis, Devil's Advocate, Cursed Genie, Villain's Monologue, Trickster. |
| **combination** | ~9 | Fine. |
| **decomposition** | ~9 | Fine. |
| **systems / emergence** | ~7 | Thin-ish (concentrated in `quantum`/`biomimetic`). |
| **time-shift** | ~6 | Thin. |
| **questioning** | ~5 | Thin. |
| **sensory / intuitive** | ~5 | Thin (all in `introspective_delight`). |
| **convergence** | ~1 | **Effectively absent** (only Superposition Collapse). See §5. |
**Takeaway:** the redundancy is not a defect to delete — the *costume* (a villain's monologue vs. a courtroom vs. "make it worse") is exactly what makes a 30th inversion technique feel fresh to a user. But a curator should know the catalog leans hard on perspective + constraint, and that **convergence is the one genuinely empty cell.** New methods (§6) should target the thin cells, not the spines.
### 3c. Goal affinity — the headline missing capability
`SKILL.md` already opens with *"what are we brainstorming, and what's the goal?"* — but that goal never routes technique selection. Mapping the matrix's `goal_affinity` tags gives a ready recommendation table. This is what powers "AI picks N" intelligently and what an enterprise user wants:
| Goal | Strong default techniques (lead picks **bold**) |
|---|---|
| **Build a feature** (greenfield/brownfield) | **First Principles**, **SCAMPER**, **Morphological Analysis**, Crazy 8s, Solution Matrix, Reverse Brainstorming, One Feature Only, Ship in 60 Minutes, Chaos Engineering, Cursed Genie (edge cases), Persona Journey, *+ new: Job to Be Done, Follow the Anomaly* |
| **Novel concept / new product** | **Concept Blending**, **Cross-Pollination**, **Forced Relationships**, What If, Trait Transfer, Nature's Solutions, Fusion Cuisine, Emerging Tech Collision, Crank the Dial to 11, Quantum Tunneling |
| **Personal / life decision** | **Future Self Interview**, **Values Archaeology**, **Laddering**, Six Hats, Ancestor Council, Proverb Mining, Mythic Frameworks, the `introspective_delight` set, *+ new: Build on What Works* |
| **Strategy / positioning** | **Six Thinking Hats**, **Failure Analysis** (pre-mortem), Field Lines, Ecosystem Thinking, Utopia vs Dystopia, 1000x Budget, Disney Method, Relativity Frame Shift, Infomercial at 3AM, Predator & Prey |
| **Concrete planning** (event/project) | **Mind Mapping**, **Lotus Blossom**, Morphological Analysis, Decision Tree, Six Hats, $0 Mandate, Constraint Roulette, Time Horizon Ladder |
| **Root-cause / diagnosis** | **Five Whys**, **Causal Loop Mapping**, Failure Analysis, Constraint Mapping, Question Storming, Starbursting, Anti-Solution, Alien Anthropologist |
| **Get unstuck / break fixation** | **Random Stimulation**, **Provocation**, **Worst Possible Idea**, Crank the Dial to 11, Constraint Roulette, Three Rounds of Stupid, Drunk History, most of `wild`/`absurdist`/`theatrical` |
**Recommendation:** persist this as machine-readable affinity (a `goals` column on the CSV, sourced from `method-matrix.csv`), then (1) have the skill recommend a batch from the up-front goal, and (2) let the composer page filter/highlight "great for: [your goal]." This is the single change that most improves both enterprise and casual use.
### 3d. Audience — the `collaborative` category quietly assumes a room of people
5 of the 8 `collaborative` methods (Round Robin, Relay Race, Hot Potato, Fold the Paper, Steal & Upgrade) are written for *multiple humans passing artifacts*. In the default 1:1 user+LLM session they don't translate without the coach silently reinterpreting them. This is the one place the catalog can mislead. Options: tag `audience`, and either (a) add a one-clause solo adaptation to each, or (b) have the skill note "this one shines with a group" when picked solo. Low effort, removes the only real footgun.
### 3e. Description anchoring — keep terse, fix ~12 specifically
The deliberate brevity is **right** — the gist + a creative LLM beats over-specification, and it matches the catalog's house style. Do **not** bulk-expand. Two surgical passes only:
1. **Group-dependent `collaborative` methods** (§3d) — add a short solo-mode clause or an audience tag.
2. **~10 "vibe-only" methods** where the *evocation is great but the output is ambiguous*, so different LLM runs would diverge wildly: e.g. **Field Lines**, **Observer Effect**, **Guerrilla Gardening Ideas**, **Emergent Thinking**, **Entanglement Thinking**, **Elemental Forces**. A tiny "…so that ___" outcome clause anchors the deliverable without killing the brevity. Example: *Guerrilla Gardening Ideas* → add "…**so you surface where an unsanctioned, low-visibility pilot could prove the idea before anyone can veto it**."
Everything crisp (Five Whys, SCAMPER, First Principles, Crazy 8s) stays untouched.
---
## 4. Quick wins vs structural changes
| Change | Effort | Impact | Type |
|---|---|---|---|
| Goal→technique affinity (`goals` column + recommendation) | Med | **High** | structural |
| "Proven & Professional" lead group + category ordering | Med | **High** (enterprise) | structural |
| Per-category "invent in the spirit" card (§6) | Low | Med | quick win |
| Convergence mini-set (§5) | Low–Med | Med–High | structural (philosophy) |
| `audience` tag + collaborative fix (§3d) | Low | Med | quick win |
| ~12 description anchors (§3e) | Low | Low–Med | quick win |
| New gap-filling methods (§6) | Low | Med | additive |
---
## 5. Divergent vs convergent — the answer, and a recommendation
**What it is.** Divergent = generate (quantity, novelty, breadth). Convergent = evaluate, cluster, prioritize, decide. A complete creative process needs both (cf. the Double Diamond, Osborn-Parnes CPS): diverge wide, *then* converge to a choice.
**Where the catalog stands.** All 100 methods are divergent. `SKILL.md` explicitly enforces divergence ("resist concluding… the urge to organize is the enemy of divergence"), and the only convergent-flavored technique is Quantum → *Superposition Collapse*. Synthesis is deferred entirely to `references/finalize.md` at wrap-up.
**Is that a mistake?** Mostly a *good instinct taken to a defensible extreme.* Separating generation from judgment is the foundational brainstorming rule — premature convergence is the #1 killer of ideas, so a divergence-pure generator is legitimate. But the consequence is that the user has **no technique to pick when they're ready to narrow** — they hit "100 ideas" and the tool's stance is "keep going," with only the wrap-up doing light synthesis. For project/feature/life-decision work especially, people *do* want to land.
**Recommendation — add a small, fenced convergence set, never mixed into the divergent flow.** Keep divergence pure during generation; offer convergence only at wrap-up or on explicit request ("okay, help me narrow"). Concretely: a new `converge` category (4 methods, §6), tagged `mechanism=convergence`, surfaced by `finalize.md` / on demand — not in the default 3–4 sweet-spot batch. This completes the loop while honoring the separate-generation-from-judgment principle. **This is a philosophy decision for you to confirm** — it's the one recommendation that changes what the skill *is*, not just what's in the library.
---
## 6. Proposed new methods (fill the thin cells)
Targeting the under-served mechanisms (§3b), the empty convergence cell (§5), and the goal gaps (§3c). CSV-style (`category, name, description`) so they can drop straight in:
**Feature/product & enterprise gaps (mechanism: questioning/decomposition):**
- `structured, Job to Be Done, "Ask what the user is really hiring this to do; brainstorm around that underlying job, not the feature you assumed"`
- `structured, Empathy Map, "Map what the user says, thinks, does, and feels around the problem; mine each quadrant for the unmet need hiding there"`
- `deep, Follow the Anomaly, "Start from one surprising number or outlier and ideate only from what would explain it or exploit it"`
**Strengths-based (the missing positive frame — Appreciative Inquiry is a glaring classic-tier omission):**
- `deep, Build on What Works, "Name what's already succeeding and why, then ideate how to amplify and extend it instead of fixing what's broken"`
**Convergence set (new `converge` category — only if §5 is adopted):**
- `converge, Impact Effort Triage, "Plot every idea by impact against effort; harvest the high-impact, low-effort quadrant first and quarantine the rest"`
- `converge, Forced Ranking, "Make the ideas fight: each must beat another to survive to a ranked top-N, no ties allowed"`
- `converge, NUF Test, "Score each idea New, Useful, Feasible 1-10; the totals expose the quiet winners and the dazzling dead-ends"`
- `converge, Affinity Clustering, "Group the raw ideas into themes, name each cluster, then ideate fresh at the theme level"`
(Optional, lower priority: `structured, Storyboarding` for sequenced/experience ideation.)
---
## 7. Category roster & ordering recommendations
**Ordering (replace alphabetical with a deliberate progression):** add a `CATEGORY_ORDER` + `GROUP` map in `brain.py` (mirroring the existing `_HUES` map — derived for the shipped set, alphabetical fallback for custom catalogs). Proposed super-groups, in order:
1. **Proven & Professional** — the `classic` lead section (§3a, Option A)
2. **Structured & Analytical** — structured, deep
3. **Creative & Generative** — creative, biomimetic, cultural, speculative_future, quantum
4. **Wild & Playful** — wild, absurdist, theatrical, constraint
5. **Introspective & Personal** — introspective_delight, collaborative
6. **Decide & Converge** — converge *(if §5 adopted)*
**Roster notes:**
- No category should be deleted. The overlap (§3b) is intentional costume variety.
- `quantum` and `cultural` are the most abstract/uneven — a couple of their members (Field Lines, Observer Effect) are the vaguest in the whole set; anchor per §3e rather than cut.
- `constraint` is excellent and tight — leave as is.
---
## 8. Per-category "invent in the spirit of this category"
You asked whether each category should also offer an on-the-fly invented technique in its own spirit. **Yes — but don't add 13 near-duplicate rows to the CSV.** The composer already has a global **Invent N** stepper, and `brain.py` already generates section markup from the catalog. So:
> Have `brain.py` append **one synthetic card per category section** — a dashed "✨ Invent a *{Category}* technique" card. Selecting it emits a paste directive like `invent 1 (in the spirit of {category})`, reused by the existing Inventive-Flow plumbing in `SKILL.md` (which already handles `invent N` and offering keepers to `additional_techniques`).
Benefits: CSV stays a clean library of *real* techniques; behavior is consistent everywhere; it leverages plumbing that already exists; and it gives the user the "surprise me, but on-theme" affordance per category without library bloat.
---
## 9. Open decisions for BMad (in priority order)
1. **Goal-affinity layer** — adopt the `goals` column + recommendation routing? (Highest impact.)
2. **Proven & Professional grouping** — Option A (tag + generated lead section, recommended), B, or C? (§3a)
3. **Convergence** — add the fenced `converge` set, or stay divergence-pure? (§5 — philosophy decision.)
4. **New methods** — approve the §6 set? Which ones?
5. **Per-category invent card** — approve the generated-card approach? (§8)
6. **Description anchoring** — approve the targeted ~12 (incl. collaborative fix), keep everything else terse? (§3e)
7. **Category ordering / super-groups** — adopt §7?
Once you mark these, the implementation is: extend the CSV schema (`provenance`, `good_for`, `audience` columns — additive, backward-compatible with `brain.py`'s `DictReader`), add the ordering/grouping + synthetic-card logic to `brain.py`, regenerate `brain-selector.html`, update the relevant `SKILL.md` / `references/*` flow, and run `scripts/tests/`.
---
## 10. Revised convergence architecture (per BMad direction)
**Decision locked:** convergence is **not** a CSV category of selectable cards. It's a **reference phase**, mirroring `references/finalize.md`. The catalog stays a pure *divergent* library; convergence lives in `references/converge.md`.
**Flow:** diverge (pick & run techniques) → **converge** (`references/converge.md`, on demand or once divergence is spent) → **finalize** (`references/finalize.md`, last). The coach already does ad-hoc convergence implicitly; this makes it an explicit, repeatable phase, and `converge.md` ends by instructing the coach to load `finalize.md` to synthesize and produce artifacts.
`references/converge.md` contents — a tight set of real, established convergence moves (the coach picks what fits, never dumps a menu):
- **Affinity Clustering (KJ method)** — group the raw ideas into themes, name each cluster, surface the through-line.
- **Dot Voting / Multivoting** — heat-map the favorites; discuss why the hot spots are hot.
- **Impact–Effort Matrix** — plot each idea on impact vs effort; harvest high-impact/low-effort first.
- **NUF Test** — score New, Useful, Feasible (1–10 each); totals expose quiet winners and dazzling dead-ends.
- **PMI (Plus / Minus / Interesting)** — de Bono's fast evaluator for pressure-testing a single strong candidate.
- *(optional)* **MoSCoW** (Must/Should/Could/Won't) for product scoping; **Nominal Group Technique** when it's genuinely a group.
`SKILL.md` change: at the point where a divergent batch is spent, offer "keep diverging / converge & decide / wrap up" — "converge & decide" loads `converge.md`; wrap-up still goes to `finalize.md`.
## 11. Researched gap-filling additions (real, established methods)
Web-researched (sources below), chosen to fill the **thin mechanism cells** (questioning, diagnosis, time-shift, empathy) — *not* the over-served spines — and all `classic`-tier, so they also strengthen the "Proven & Professional" group. CSV-style, ready to drop in:
| Category | Technique | Gist (house style) | Fills |
|---|---|---|---|
| structured | **How Might We** | "Reframe the problem as a batch of 'How might we…' opportunity questions first, then ideate against the sharpest one" | questioning / problem-framing (design-thinking staple, currently absent) |
| deep | **TRIZ Contradiction** | "Name the core contradiction — what only improves by making something else worse — then brainstorm ways to win both instead of trading off" | engineering/feature (no systematic technical method today) |
| deep | **Fishbone Diagram** | "Branch the problem's spine into cause categories — people, process, tools, environment — and mine each bone for contributing causes" | diagnosis (named classic complementing Five Whys / Causal Loop) |
| structured | **Backcasting** | "Fix the finished future in vivid detail, then work backward step by step to the one move you'd have to make first" | strategy/planning time-shift (serious counterpart to playful future methods) |
| speculative_future | **Scenario Cross** | "Pick two high-impact uncertainties, cross them into four futures, and ideate the move that wins in every one" | strategy (2×2 scenario planning — the serious sibling of the playful speculative set) |
| structured | **Job to Be Done** | "Ask what the user is really hiring this to do, then ideate around that underlying job, not the feature you assumed" | feature/empathy (enterprise staple) |
| structured | **Empathy Map** | "Map what the user says, thinks, does, and feels around the problem; mine each quadrant for the unmet need" | empathy/feature |
| deep | **Build on What Works** | "Name what's already succeeding and why, then ideate how to amplify and extend it instead of fixing what's broken" | strengths-based (Appreciative Inquiry — a glaring classic-tier omission) |
Deliberately **not** added (would deepen an already over-served spine or duplicate): Synectics (≈ analogy/metaphor), SWOT (analysis, not ideation), Rolestorming (≈ Role Playing), Brainwalking/Braindumping (≈ Brainwriting), Pre-mortem (≈ Failure Analysis).
**Sources:** [IxDF — essential ideation techniques](https://ixdf.org/literature/article/introduction-to-the-essential-ideation-techniques-which-are-the-heart-of-design-thinking) · [Quality Magazine — TRIZ](https://www.qualitymag.com/articles/98566-triz-the-backbone-of-innovation-and-problem-solving) · [ASQ — Fishbone/Ishikawa](https://asq.org/quality-resources/fishbone) · [Futures Platform — 2×2 scenario matrix](https://www.futuresplatform.com/blog/2x2-scenario-planning-matrix-guideline) · [NN/g — Dot Voting](https://www.nngroup.com/articles/dot-voting/) · [Quality Gurus — divergent vs convergent](https://www.qualitygurus.com/divergent-vs-convergent-thinking/)

109
src/core-skills/bmad-brainstorming/analysis/method-matrix.csv Normal file
View File

@ -0,0 +1,109 @@
category,technique,provenance,mechanism_primary,mechanism_secondary,goal_affinity,audience
collaborative,Yes And Building,classic,combination,perspective,novel|unstuck|planning,group
collaborative,Brain Writing Round Robin,classic,combination,decomposition,novel|feature,group
collaborative,Random Stimulation,classic,analogy,,unstuck|novel,either
collaborative,Role Playing,classic,perspective,,strategy|personal|feature,either
collaborative,Ideation Relay Race,playful,combination,,unstuck,group
collaborative,Idea Hot Potato,playful,combination,,unstuck,group
collaborative,Steal And Upgrade,signature,combination,analogy,novel|unstuck,group
collaborative,Fold The Paper,playful,combination,,unstuck|novel,group
creative,What If Scenarios,signature,constraint,,novel|strategy|unstuck,either
creative,Analogical Thinking,signature,analogy,,feature|novel|diagnosis,either
creative,First Principles Thinking,classic,decomposition,,feature|novel|diagnosis|strategy,either
creative,Forced Relationships,signature,combination,analogy,novel|unstuck,either
creative,Time Shifting,signature,time-shift,perspective,novel|unstuck,either
creative,Metaphor Mapping,signature,analogy,,novel|diagnosis,either
creative,Cross-Pollination,signature,analogy,,novel|feature|strategy,either
creative,Concept Blending,signature,combination,,novel,either
creative,Reverse Brainstorming,classic,inversion,,diagnosis|feature|unstuck,either
creative,Sensory Exploration,signature,sensory,,novel|unstuck,either
deep,Five Whys,classic,questioning,,diagnosis,either
deep,Provocation Technique,classic,provocation,inversion,unstuck|novel,either
deep,Assumption Reversal,classic,inversion,,novel|diagnosis|strategy,either
deep,Question Storming,classic,questioning,,diagnosis|strategy|unstuck,either
deep,Constraint Mapping,signature,constraint,decomposition,feature|strategy|diagnosis,either
deep,Failure Analysis,signature,inversion,diagnosis,diagnosis|strategy|feature,either
deep,Emergent Thinking,signature,systems,,strategy|novel,either
deep,Causal Loop Mapping,classic,systems,,diagnosis|strategy,either
deep,Morphological Analysis,classic,decomposition,combination,feature|novel|planning,either
deep,Laddering,classic,questioning,decomposition,personal|strategy|diagnosis,either
introspective_delight,Inner Child Conference,signature,perspective,sensory,personal|unstuck,solo
introspective_delight,Shadow Work Mining,signature,sensory,,personal|diagnosis,solo
introspective_delight,Values Archaeology,signature,questioning,,personal|strategy,solo
introspective_delight,Future Self Interview,signature,perspective,time-shift,personal,solo
introspective_delight,Body Wisdom Dialogue,signature,sensory,,personal,solo
introspective_delight,Permission Giving,signature,provocation,constraint,personal|unstuck,solo
introspective_delight,Secret Wish Confession,signature,sensory,,personal,solo
introspective_delight,Mood Weather Report,signature,sensory,,personal|unstuck,solo
structured,SCAMPER Method,classic,combination,decomposition,feature|novel,either
structured,Six Thinking Hats,classic,perspective,,strategy|diagnosis|planning|personal,either
structured,Decision Tree Mapping,signature,decomposition,,planning|strategy|diagnosis,either
structured,Solution Matrix,signature,decomposition,,feature|planning,either
structured,Trait Transfer,signature,analogy,,novel|feature,either
structured,Lotus Blossom,classic,decomposition,,feature|planning|novel,either
structured,Worst Possible Idea,classic,inversion,,unstuck|novel,either
structured,Disney Method,classic,perspective,,feature|strategy|planning,either
structured,Starbursting,classic,questioning,,feature|planning|diagnosis,either
structured,Mind Mapping,classic,decomposition,,planning|novel|feature,either
structured,Crazy 8s,classic,combination,,feature|novel|unstuck,either
theatrical,Time Travel Talk Show,playful,perspective,time-shift,novel|personal,either
theatrical,Alien Anthropologist,playful,perspective,,diagnosis|unstuck|strategy,either
theatrical,Dream Fusion Laboratory,signature,constraint,time-shift,novel|unstuck,either
theatrical,Emotion Orchestra,playful,sensory,perspective,personal|strategy,either
theatrical,Parallel Universe Cafe,playful,constraint,,novel|unstuck,either
theatrical,Persona Journey,signature,perspective,,feature|strategy,either
theatrical,Devil's Advocate Courtroom,signature,inversion,perspective,strategy|diagnosis,group
wild,Chaos Engineering,signature,inversion,constraint,feature|diagnosis|strategy,either
wild,Guerrilla Gardening Ideas,playful,analogy,,strategy|unstuck,either
wild,Pirate Code Brainstorm,playful,combination,analogy,novel|unstuck,either
wild,Zombie Apocalypse Planning,playful,constraint,,feature|strategy|unstuck,either
wild,Drunk History Retelling,playful,perspective,,unstuck|diagnosis,either
wild,Anti-Solution,signature,inversion,,diagnosis|unstuck,either
wild,Elemental Forces,playful,perspective,analogy,novel|unstuck,either
biomimetic,Nature's Solutions,signature,analogy,,feature|novel,either
biomimetic,Ecosystem Thinking,signature,systems,,strategy|diagnosis,either
biomimetic,Evolutionary Pressure,signature,systems,,feature|novel,either
biomimetic,Predator & Prey,signature,perspective,inversion,strategy|feature,either
biomimetic,Metamorphosis Stages,signature,time-shift,decomposition,novel|strategy,either
biomimetic,Swarm Logic,signature,systems,,feature|strategy,either
quantum,Observer Effect,signature,systems,perspective,strategy|diagnosis,either
quantum,Entanglement Thinking,signature,systems,,diagnosis|strategy,either
quantum,Superposition Collapse,signature,convergence,decomposition,strategy|diagnosis,either
quantum,Relativity Frame Shift,signature,perspective,,strategy|novel,either
quantum,Field Lines,signature,systems,,strategy,either
quantum,Quantum Tunneling,signature,constraint,,unstuck|novel,either
cultural,Indigenous Wisdom,signature,perspective,analogy,personal|strategy|novel,either
cultural,Fusion Cuisine,signature,combination,analogy,novel,either
cultural,Ritual Innovation,signature,analogy,,novel|personal,either
cultural,Mythic Frameworks,signature,analogy,perspective,strategy|personal|novel,either
cultural,Proverb Mining,signature,analogy,,personal|strategy,either
cultural,Ancestor Council,signature,perspective,,personal|strategy,either
cultural,Trickster's Gambit,playful,inversion,provocation,unstuck|strategy,either
absurdist,Villain's Monologue,playful,inversion,perspective,diagnosis|strategy|unstuck,either
absurdist,Explain It to a Golden Retriever,playful,perspective,,unstuck|diagnosis|feature,either
absurdist,Infomercial at 3AM,playful,perspective,,strategy|novel,either
absurdist,Drunk Uncle at Thanksgiving,playful,perspective,,unstuck|diagnosis,either
absurdist,Cursed Genie,playful,inversion,,diagnosis|feature,either
absurdist,Three Rounds of Stupid,playful,provocation,,unstuck|novel,either
constraint,Kill the Crown Jewel,signature,constraint,,feature|strategy|unstuck,either
constraint,1000x Budget,signature,constraint,,novel|strategy,either
constraint,Ship in 60 Minutes,signature,constraint,,feature|planning|unstuck,either
constraint,The $0 Mandate,signature,constraint,,planning|strategy|feature,either
constraint,One Feature Only,signature,constraint,,feature|strategy,either
constraint,Crank the Dial to 11,signature,constraint,,novel|unstuck,either
constraint,Constraint Roulette,signature,constraint,,unstuck|feature,either
speculative_future,Time Horizon Ladder,signature,time-shift,,strategy|planning|novel,either
speculative_future,Post-Scarcity Test,signature,constraint,,novel|strategy,either
speculative_future,Utopia vs Dystopia Split-Screen,signature,perspective,inversion,strategy|diagnosis,either
speculative_future,Sci-Fi Artifact From the Future,signature,time-shift,perspective,novel|feature,either
speculative_future,Emerging Tech Collision,signature,combination,,novel|feature|strategy,either
speculative_future,What-If-The-World-Changed Card Flip,signature,constraint,,novel|unstuck,either
speculative_future,Future Anthropologist Dig,signature,time-shift,perspective,strategy|novel,either
structured,How Might We,classic,questioning,,feature|novel|strategy|diagnosis,either
structured,Job to Be Done,classic,perspective,questioning,feature|strategy|novel,either
structured,Empathy Map,classic,perspective,,feature|personal,either
structured,Backcasting,classic,time-shift,,strategy|planning|novel,either
deep,TRIZ Contradiction,classic,inversion,decomposition,feature|novel|diagnosis,either
deep,Fishbone Diagram,classic,decomposition,systems,diagnosis,either
deep,Build on What Works,classic,perspective,systems,personal|strategy,either
speculative_future,Scenario Cross,classic,constraint,systems,strategy|planning,either
1 category technique provenance mechanism_primary mechanism_secondary goal_affinity audience
2 collaborative Yes And Building classic combination perspective novel|unstuck|planning group
3 collaborative Brain Writing Round Robin classic combination decomposition novel|feature group
4 collaborative Random Stimulation classic analogy unstuck|novel either
5 collaborative Role Playing classic perspective strategy|personal|feature either
6 collaborative Ideation Relay Race playful combination unstuck group
7 collaborative Idea Hot Potato playful combination unstuck group
8 collaborative Steal And Upgrade signature combination analogy novel|unstuck group
9 collaborative Fold The Paper playful combination unstuck|novel group
10 creative What If Scenarios signature constraint novel|strategy|unstuck either
11 creative Analogical Thinking signature analogy feature|novel|diagnosis either
12 creative First Principles Thinking classic decomposition feature|novel|diagnosis|strategy either
13 creative Forced Relationships signature combination analogy novel|unstuck either
14 creative Time Shifting signature time-shift perspective novel|unstuck either
15 creative Metaphor Mapping signature analogy novel|diagnosis either
16 creative Cross-Pollination signature analogy novel|feature|strategy either
17 creative Concept Blending signature combination novel either
18 creative Reverse Brainstorming classic inversion diagnosis|feature|unstuck either
19 creative Sensory Exploration signature sensory novel|unstuck either
20 deep Five Whys classic questioning diagnosis either
21 deep Provocation Technique classic provocation inversion unstuck|novel either
22 deep Assumption Reversal classic inversion novel|diagnosis|strategy either
23 deep Question Storming classic questioning diagnosis|strategy|unstuck either
24 deep Constraint Mapping signature constraint decomposition feature|strategy|diagnosis either
25 deep Failure Analysis signature inversion diagnosis diagnosis|strategy|feature either
26 deep Emergent Thinking signature systems strategy|novel either
27 deep Causal Loop Mapping classic systems diagnosis|strategy either
28 deep Morphological Analysis classic decomposition combination feature|novel|planning either
29 deep Laddering classic questioning decomposition personal|strategy|diagnosis either
30 introspective_delight Inner Child Conference signature perspective sensory personal|unstuck solo
31 introspective_delight Shadow Work Mining signature sensory personal|diagnosis solo
32 introspective_delight Values Archaeology signature questioning personal|strategy solo
33 introspective_delight Future Self Interview signature perspective time-shift personal solo
34 introspective_delight Body Wisdom Dialogue signature sensory personal solo
35 introspective_delight Permission Giving signature provocation constraint personal|unstuck solo
36 introspective_delight Secret Wish Confession signature sensory personal solo
37 introspective_delight Mood Weather Report signature sensory personal|unstuck solo
38 structured SCAMPER Method classic combination decomposition feature|novel either
39 structured Six Thinking Hats classic perspective strategy|diagnosis|planning|personal either
40 structured Decision Tree Mapping signature decomposition planning|strategy|diagnosis either
41 structured Solution Matrix signature decomposition feature|planning either
42 structured Trait Transfer signature analogy novel|feature either
43 structured Lotus Blossom classic decomposition feature|planning|novel either
44 structured Worst Possible Idea classic inversion unstuck|novel either
45 structured Disney Method classic perspective feature|strategy|planning either
46 structured Starbursting classic questioning feature|planning|diagnosis either
47 structured Mind Mapping classic decomposition planning|novel|feature either
48 structured Crazy 8s classic combination feature|novel|unstuck either
49 theatrical Time Travel Talk Show playful perspective time-shift novel|personal either
50 theatrical Alien Anthropologist playful perspective diagnosis|unstuck|strategy either
51 theatrical Dream Fusion Laboratory signature constraint time-shift novel|unstuck either
52 theatrical Emotion Orchestra playful sensory perspective personal|strategy either
53 theatrical Parallel Universe Cafe playful constraint novel|unstuck either
54 theatrical Persona Journey signature perspective feature|strategy either
55 theatrical Devil's Advocate Courtroom signature inversion perspective strategy|diagnosis group
56 wild Chaos Engineering signature inversion constraint feature|diagnosis|strategy either
57 wild Guerrilla Gardening Ideas playful analogy strategy|unstuck either
58 wild Pirate Code Brainstorm playful combination analogy novel|unstuck either
59 wild Zombie Apocalypse Planning playful constraint feature|strategy|unstuck either
60 wild Drunk History Retelling playful perspective unstuck|diagnosis either
61 wild Anti-Solution signature inversion diagnosis|unstuck either
62 wild Elemental Forces playful perspective analogy novel|unstuck either
63 biomimetic Nature's Solutions signature analogy feature|novel either
64 biomimetic Ecosystem Thinking signature systems strategy|diagnosis either
65 biomimetic Evolutionary Pressure signature systems feature|novel either
66 biomimetic Predator & Prey signature perspective inversion strategy|feature either
67 biomimetic Metamorphosis Stages signature time-shift decomposition novel|strategy either
68 biomimetic Swarm Logic signature systems feature|strategy either
69 quantum Observer Effect signature systems perspective strategy|diagnosis either
70 quantum Entanglement Thinking signature systems diagnosis|strategy either
71 quantum Superposition Collapse signature convergence decomposition strategy|diagnosis either
72 quantum Relativity Frame Shift signature perspective strategy|novel either
73 quantum Field Lines signature systems strategy either
74 quantum Quantum Tunneling signature constraint unstuck|novel either
75 cultural Indigenous Wisdom signature perspective analogy personal|strategy|novel either
76 cultural Fusion Cuisine signature combination analogy novel either
77 cultural Ritual Innovation signature analogy novel|personal either
78 cultural Mythic Frameworks signature analogy perspective strategy|personal|novel either
79 cultural Proverb Mining signature analogy personal|strategy either
80 cultural Ancestor Council signature perspective personal|strategy either
81 cultural Trickster's Gambit playful inversion provocation unstuck|strategy either
82 absurdist Villain's Monologue playful inversion perspective diagnosis|strategy|unstuck either
83 absurdist Explain It to a Golden Retriever playful perspective unstuck|diagnosis|feature either
84 absurdist Infomercial at 3AM playful perspective strategy|novel either
85 absurdist Drunk Uncle at Thanksgiving playful perspective unstuck|diagnosis either
86 absurdist Cursed Genie playful inversion diagnosis|feature either
87 absurdist Three Rounds of Stupid playful provocation unstuck|novel either
88 constraint Kill the Crown Jewel signature constraint feature|strategy|unstuck either
89 constraint 1000x Budget signature constraint novel|strategy either
90 constraint Ship in 60 Minutes signature constraint feature|planning|unstuck either
91 constraint The $0 Mandate signature constraint planning|strategy|feature either
92 constraint One Feature Only signature constraint feature|strategy either
93 constraint Crank the Dial to 11 signature constraint novel|unstuck either
94 constraint Constraint Roulette signature constraint unstuck|feature either
95 speculative_future Time Horizon Ladder signature time-shift strategy|planning|novel either
96 speculative_future Post-Scarcity Test signature constraint novel|strategy either
97 speculative_future Utopia vs Dystopia Split-Screen signature perspective inversion strategy|diagnosis either
98 speculative_future Sci-Fi Artifact From the Future signature time-shift perspective novel|feature either
99 speculative_future Emerging Tech Collision signature combination novel|feature|strategy either
100 speculative_future What-If-The-World-Changed Card Flip signature constraint novel|unstuck either
101 speculative_future Future Anthropologist Dig signature time-shift perspective strategy|novel either
102 structured How Might We classic questioning feature|novel|strategy|diagnosis either
103 structured Job to Be Done classic perspective questioning feature|strategy|novel either
104 structured Empathy Map classic perspective feature|personal either
105 structured Backcasting classic time-shift strategy|planning|novel either
106 deep TRIZ Contradiction classic inversion decomposition feature|novel|diagnosis either
107 deep Fishbone Diagram classic decomposition systems diagnosis either
108 deep Build on What Works classic perspective systems personal|strategy either
109 speculative_future Scenario Cross classic constraint systems strategy|planning either

166
src/core-skills/bmad-brainstorming/assets/brain-icons.json Normal file
View File

@ -0,0 +1,166 @@
{
"categories": {
"creative": {
"hue": "#6d5cf0",
"glyph": "<g stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"><line x1=\"22\" y1=\"6.5\" x2=\"22\" y2=\"12.5\"/><line x1=\"22\" y1=\"31.5\" x2=\"22\" y2=\"37.5\"/><line x1=\"6.5\" y1=\"22\" x2=\"12.5\" y2=\"22\"/><line x1=\"31.5\" y1=\"22\" x2=\"37.5\" y2=\"22\"/><line x1=\"11.3\" y1=\"11.3\" x2=\"15.5\" y2=\"15.5\"/><line x1=\"28.5\" y1=\"28.5\" x2=\"32.7\" y2=\"32.7\"/><line x1=\"32.7\" y1=\"11.3\" x2=\"28.5\" y2=\"15.5\"/><line x1=\"15.5\" y1=\"28.5\" x2=\"11.3\" y2=\"32.7\"/></g><circle cx=\"22\" cy=\"22\" r=\"6.6\" fill=\"currentColor\" fill-opacity=\"0.25\"/><circle cx=\"22\" cy=\"22\" r=\"3.6\" fill=\"currentColor\"/>"
},
"deep": {
"hue": "#4658c9",
"glyph": "<g fill=\"none\" stroke=\"currentColor\"><circle cx=\"22\" cy=\"22\" r=\"13\" stroke-width=\"1.5\" stroke-opacity=\"0.4\"/><circle cx=\"22\" cy=\"22\" r=\"9\" stroke-width=\"1.7\" stroke-opacity=\"0.7\"/><circle cx=\"22\" cy=\"22\" r=\"5\" stroke-width=\"1.9\"/></g><circle cx=\"22\" cy=\"22\" r=\"2.4\" fill=\"currentColor\"/>"
},
"structured": {
"hue": "#3b6ea5",
"glyph": "<g fill=\"currentColor\"><rect x=\"11\" y=\"11\" width=\"9.5\" height=\"9.5\" rx=\"2\"/><rect x=\"23.5\" y=\"11\" width=\"9.5\" height=\"9.5\" rx=\"2\" fill-opacity=\"0.25\"/><rect x=\"11\" y=\"23.5\" width=\"9.5\" height=\"9.5\" rx=\"2\" fill-opacity=\"0.25\"/><rect x=\"23.5\" y=\"23.5\" width=\"9.5\" height=\"9.5\" rx=\"2\"/></g>"
},
"quantum": {
"hue": "#2b86d9",
"glyph": "<g stroke=\"currentColor\" stroke-width=\"1.8\" fill=\"none\"><ellipse cx=\"22\" cy=\"22\" rx=\"14.5\" ry=\"6\" transform=\"rotate(28 22 22)\"/><ellipse cx=\"22\" cy=\"22\" rx=\"14.5\" ry=\"6\" transform=\"rotate(-28 22 22)\"/></g><circle cx=\"22\" cy=\"22\" r=\"6.6\" fill=\"currentColor\" fill-opacity=\"0.18\"/><circle cx=\"22\" cy=\"22\" r=\"3.4\" fill=\"currentColor\"/><circle cx=\"33.2\" cy=\"17.4\" r=\"2\" fill=\"currentColor\"/>"
},
"speculative_future": {
"hue": "#0fb5c9",
"glyph": "<g stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" fill=\"none\"><path d=\"M11 31 L 26.5 15.5\"/><path d=\"M20 14.5 H 28 V 22.5\"/></g><circle cx=\"31\" cy=\"12\" r=\"2.8\" fill=\"currentColor\"/><g stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\"><line x1=\"31\" y1=\"6.5\" x2=\"31\" y2=\"8.4\"/><line x1=\"31\" y1=\"15.6\" x2=\"31\" y2=\"17.5\"/><line x1=\"25.5\" y1=\"12\" x2=\"27.4\" y2=\"12\"/><line x1=\"34.6\" y1=\"12\" x2=\"36.5\" y2=\"12\"/></g>"
},
"collaborative": {
"hue": "#15a3a3",
"glyph": "<g stroke=\"currentColor\" stroke-width=\"1.8\"><line x1=\"14\" y1=\"16\" x2=\"30\" y2=\"16\"/><line x1=\"14\" y1=\"16\" x2=\"22\" y2=\"30\"/><line x1=\"30\" y1=\"16\" x2=\"22\" y2=\"30\"/></g><g fill=\"currentColor\" fill-opacity=\"0.22\"><circle cx=\"14\" cy=\"16\" r=\"4.6\"/><circle cx=\"30\" cy=\"16\" r=\"4.6\"/><circle cx=\"22\" cy=\"30\" r=\"4.6\"/></g><g fill=\"currentColor\"><circle cx=\"14\" cy=\"16\" r=\"2.4\"/><circle cx=\"30\" cy=\"16\" r=\"2.4\"/><circle cx=\"22\" cy=\"30\" r=\"2.4\"/></g>"
},
"biomimetic": {
"hue": "#1f9d6b",
"glyph": "<path d=\"M22 7.5 C 31.5 12.5, 31.5 29, 22 36.5 C 12.5 29, 12.5 12.5, 22 7.5 Z\" fill=\"currentColor\" fill-opacity=\"0.22\"/><path d=\"M22 9 V 35.5\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" fill=\"none\"/><g stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"><path d=\"M22 16 l5.6 -2.6\"/><path d=\"M22 16 l-5.6 -2.6\"/><path d=\"M22 22 l6.6 -2.6\"/><path d=\"M22 22 l-6.6 -2.6\"/><path d=\"M22 28 l5.6 -2.6\"/><path d=\"M22 28 l-5.6 -2.6\"/></g>"
},
"constraint": {
"hue": "#d9882b",
"glyph": "<g stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" fill=\"none\"><path d=\"M17 11 H 11 V 17\"/><path d=\"M27 11 H 33 V 17\"/><path d=\"M17 33 H 11 V 27\"/><path d=\"M27 33 H 33 V 27\"/></g><circle cx=\"22\" cy=\"22\" r=\"5\" fill=\"currentColor\" fill-opacity=\"0.25\"/><circle cx=\"22\" cy=\"22\" r=\"2.6\" fill=\"currentColor\"/>"
},
"wild": {
"hue": "#e2562f",
"glyph": "<path d=\"M24.5 6.5 L 12.5 24 H 19.5 L 17.5 37.5 L 31.5 18.5 H 24 L 24.5 6.5 Z\" fill=\"currentColor\"/>"
},
"cultural": {
"hue": "#c75b39",
"glyph": "<circle cx=\"22\" cy=\"22\" r=\"13.5\" fill=\"currentColor\" fill-opacity=\"0.14\"/><g stroke=\"currentColor\" stroke-width=\"1.6\" fill=\"none\"><circle cx=\"22\" cy=\"22\" r=\"13.5\"/><ellipse cx=\"22\" cy=\"22\" rx=\"6\" ry=\"13.5\"/><line x1=\"8.5\" y1=\"22\" x2=\"35.5\" y2=\"22\"/><path d=\"M11 15 H 33\" stroke-opacity=\"0.55\"/><path d=\"M11 29 H 33\" stroke-opacity=\"0.55\"/></g>"
},
"theatrical": {
"hue": "#cf4d6f",
"glyph": "<path d=\"M13 12 H 31 V 22 C 31 30, 27 35, 22 35 C 17 35, 13 30, 13 22 Z\" fill=\"currentColor\" fill-opacity=\"0.18\"/><path d=\"M13 12 H 31 V 22 C 31 30, 27 35, 22 35 C 17 35, 13 30, 13 22 Z\" stroke=\"currentColor\" stroke-width=\"1.8\" fill=\"none\"/><g fill=\"currentColor\"><circle cx=\"18.5\" cy=\"21\" r=\"1.7\"/><circle cx=\"25.5\" cy=\"21\" r=\"1.7\"/></g><path d=\"M18 27 C 20 29.5, 24 29.5, 26 27\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" fill=\"none\"/>"
},
"absurdist": {
"hue": "#e0529c",
"glyph": "<g transform=\"rotate(-12 22 22)\"><circle cx=\"22\" cy=\"22\" r=\"13\" fill=\"currentColor\" fill-opacity=\"0.14\"/><circle cx=\"22\" cy=\"22\" r=\"13\" stroke=\"currentColor\" stroke-width=\"1.6\" fill=\"none\"/><path d=\"M16 19 q 2 -2.4 4 0\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" fill=\"none\"/><circle cx=\"26.5\" cy=\"18.8\" r=\"1.8\" fill=\"currentColor\"/><path d=\"M16.5 26 C 19 30, 25 30, 28 24.5\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\" fill=\"none\"/></g>"
},
"introspective_delight": {
"hue": "#b15ad6",
"glyph": "<circle cx=\"22\" cy=\"13.5\" r=\"4\" fill=\"currentColor\"/><path d=\"M10.5 31 C 12.5 23, 31.5 23, 33.5 31 Z\" fill=\"currentColor\" fill-opacity=\"0.22\"/><path d=\"M10.5 31 C 12.5 23, 31.5 23, 33.5 31\" stroke=\"currentColor\" stroke-width=\"1.7\" fill=\"none\"/><path d=\"M13.5 30 C 16 26.5, 20 25.5, 22 25.5 C 24 25.5, 28 26.5, 30.5 30\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-opacity=\"0.6\"/>"
}
},
"techniques": {
"Yes And Building": "<g fill=\"currentColor\"><rect x=\"8\" y=\"27\" width=\"12\" height=\"8\" rx=\"1.5\" fill-opacity=\".8\"/><rect x=\"14\" y=\"19\" width=\"12\" height=\"8\" rx=\"1.5\" fill-opacity=\".5\"/><rect x=\"20\" y=\"11\" width=\"12\" height=\"8\" rx=\"1.5\"/></g>",
"Brain Writing Round Robin": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M31 16 A10 10 0 1 0 32.5 22\"/><path d=\"M31 10 L31.5 16.3 L25 16.5\"/></g>",
"Random Stimulation": "<rect x=\"11\" y=\"11\" width=\"22\" height=\"22\" rx=\"4\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><g fill=\"currentColor\"><circle cx=\"17\" cy=\"17\" r=\"1.8\"/><circle cx=\"27\" cy=\"17\" r=\"1.8\"/><circle cx=\"22\" cy=\"22\" r=\"1.8\"/><circle cx=\"17\" cy=\"27\" r=\"1.8\"/><circle cx=\"27\" cy=\"27\" r=\"1.8\"/></g>",
"Role Playing": "<rect x=\"11\" y=\"9\" width=\"22\" height=\"26\" rx=\"3\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><circle cx=\"22\" cy=\"19\" r=\"4\" fill=\"currentColor\"/><path d=\"M15.5 30 c2 -4.5 11 -4.5 13 0\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>",
"Ideation Relay Race": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><line x1=\"12\" y1=\"31\" x2=\"27\" y2=\"16\"/><line x1=\"8\" y1=\"22\" x2=\"14\" y2=\"22\" stroke-opacity=\".5\"/><line x1=\"8\" y1=\"27\" x2=\"13\" y2=\"27\" stroke-opacity=\".35\"/></g><circle cx=\"29\" cy=\"14\" r=\"3.4\" fill=\"currentColor\"/>",
"Idea Hot Potato": "<path d=\"M11 31 Q22 8 33 31\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-dasharray=\"2 3.5\" stroke-linecap=\"round\"/><circle cx=\"22\" cy=\"12.5\" r=\"4.2\" fill=\"currentColor\"/>",
"Steal And Upgrade": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M20 33 V14\"/><path d=\"M13 21 L20 14 L27 21\"/></g><path d=\"M30 27 l1 2.6 2.6 1 -2.6 1 -1 2.6 -1 -2.6 -2.6 -1 2.6 -1 z\" fill=\"currentColor\"/>",
"Fold The Paper": "<path d=\"M13 16 L21 12 V28 L13 32 Z\" fill=\"currentColor\" fill-opacity=\".22\"/><path d=\"M21 12 L29 16 V32 L21 28 Z\" fill=\"currentColor\" fill-opacity=\".45\"/><path d=\"M13 16 L21 12 L29 16 M21 12 V28\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linejoin=\"round\"/>",
"What If Scenarios": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M18 17 a4 4 0 1 1 4 4 v3\"/></g><circle cx=\"22\" cy=\"30\" r=\"1.6\" fill=\"currentColor\"/>",
"Analogical Thinking": "<circle cx=\"15\" cy=\"22\" r=\"6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><rect x=\"25\" y=\"16\" width=\"12\" height=\"12\" rx=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M19 20 q2 2 0 4 M23 20 q-2 2 0 4\" stroke=\"currentColor\" stroke-width=\"1.6\" fill=\"none\"/>",
"First Principles Thinking": "<g fill=\"currentColor\"><rect x=\"10\" y=\"28\" width=\"8\" height=\"6\" rx=\"1\"/><rect x=\"18.5\" y=\"28\" width=\"8\" height=\"6\" rx=\"1\"/><rect x=\"27\" y=\"28\" width=\"7\" height=\"6\" rx=\"1\"/></g><path d=\"M22 25 L22 11 M16 17 L22 11 L28 17\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>",
"Forced Relationships": "<circle cx=\"12\" cy=\"22\" r=\"3.4\" fill=\"currentColor\"/><circle cx=\"32\" cy=\"22\" r=\"3.4\" fill=\"currentColor\"/><path d=\"M15 22 q7 -9 14 0\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-dasharray=\"1.5 3\"/>",
"Time Shifting": "<circle cx=\"22\" cy=\"22\" r=\"12\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 15 V22 L27 25\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>",
"Metaphor Mapping": "<rect x=\"10\" y=\"14\" width=\"14\" height=\"14\" rx=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><circle cx=\"28\" cy=\"25\" r=\"7\" fill=\"currentColor\" fill-opacity=\".22\"/><circle cx=\"28\" cy=\"25\" r=\"7\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/>",
"Cross-Pollination": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M13 14 H27 a4 4 0 0 1 0 8 H17 a4 4 0 0 0 0 8 H31\"/><path d=\"M28 11 L31.5 14 L28 17 M16 27 L12.5 30 L16 33\"/></g>",
"Concept Blending": "<circle cx=\"18\" cy=\"22\" r=\"8\" fill=\"currentColor\" fill-opacity=\".25\"/><circle cx=\"26\" cy=\"22\" r=\"8\" fill=\"currentColor\" fill-opacity=\".25\"/><g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><circle cx=\"18\" cy=\"22\" r=\"8\"/><circle cx=\"26\" cy=\"22\" r=\"8\"/></g>",
"Reverse Brainstorming": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M13 18 H28 a4 4 0 0 1 0 8 H16\"/><path d=\"M19 15 L13 18 L19 21 M22 23 L16 26 L22 29\"/></g>",
"Sensory Exploration": "<path d=\"M10 22 q12 -10 24 0 q-12 10 -24 0 z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/><circle cx=\"22\" cy=\"22\" r=\"4\" fill=\"currentColor\"/>",
"Five Whys": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"14\" cy=\"13\" r=\"2.4\"/><circle cx=\"22\" cy=\"22\" r=\"2.4\"/><circle cx=\"30\" cy=\"31\" r=\"2.4\"/><path d=\"M15.6 14.8 L20.4 20.2 M23.6 23.8 L28.4 29.2\"/></g>",
"Provocation Technique": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M24 9 L13 24 H21 L19 35 L31 19 H23 Z\"/></g>",
"Assumption Reversal": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M16 14 V30\"/><path d=\"M11.5 25 L16 30 L20.5 25\"/><path d=\"M28 30 V14\"/><path d=\"M23.5 19 L28 14 L32.5 19\"/></g>",
"Question Storming": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M14 16 a3.2 3.2 0 1 1 3.2 3.2 v2\"/><path d=\"M26 13 a3.6 3.6 0 1 1 3.6 3.6 v2.4\"/></g><circle cx=\"17.2\" cy=\"27\" r=\"1.5\" fill=\"currentColor\"/><circle cx=\"29.6\" cy=\"25.6\" r=\"1.6\" fill=\"currentColor\"/>",
"Constraint Mapping": "<path d=\"M11 14 L18 12 L26 14 L33 12 V30 L26 32 L18 30 L11 32 Z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/><path d=\"M18 12 V30 M26 14 V32\" stroke=\"currentColor\" stroke-width=\"1.6\"/>",
"Failure Analysis": "<circle cx=\"20\" cy=\"20\" r=\"8\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><line x1=\"26\" y1=\"26\" x2=\"33\" y2=\"33\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"/><path d=\"M20 16 V21 M20 24 V24\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>",
"Emergent Thinking": "<g fill=\"currentColor\"><circle cx=\"11\" cy=\"31\" r=\"1.6\"/><circle cx=\"17\" cy=\"29\" r=\"1.6\"/><circle cx=\"16\" cy=\"23\" r=\"1.6\"/><circle cx=\"22\" cy=\"24\" r=\"1.8\"/><circle cx=\"23\" cy=\"17\" r=\"1.9\"/><circle cx=\"29\" cy=\"18\" r=\"1.7\"/><circle cx=\"28\" cy=\"12\" r=\"2.1\"/></g>",
"Causal Loop Mapping": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M16 16 a9 9 0 1 1 -2 12\"/><path d=\"M16 10.5 L16.5 16.5 L10.5 17\"/><path d=\"M30 28.5 L29.5 22.5 L35 22\"/></g>",
"Morphological Analysis": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\"><rect x=\"11\" y=\"11\" width=\"22\" height=\"22\" rx=\"2\"/><path d=\"M11 18.3 H33 M11 25.6 H33 M18.3 11 V33 M25.6 11 V33\"/></g><rect x=\"18.5\" y=\"18.5\" width=\"7\" height=\"7\" fill=\"currentColor\" fill-opacity=\".4\"/>",
"Laddering": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M16 9 V35 M28 9 V35 M16 15 H28 M16 22 H28 M16 29 H28\"/></g>",
"Inner Child Conference": "<circle cx=\"22\" cy=\"16\" r=\"6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 22 V31\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/><path d=\"M19 34 q3 -3 6 0\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\"/><g fill=\"currentColor\"><circle cx=\"20\" cy=\"15\" r=\"1\"/><circle cx=\"24\" cy=\"15\" r=\"1\"/></g>",
"Shadow Work Mining": "<circle cx=\"22\" cy=\"22\" r=\"12\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 10 a12 12 0 0 1 0 24 z\" fill=\"currentColor\" fill-opacity=\".85\"/>",
"Values Archaeology": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><path d=\"M10 16 h24\" stroke-opacity=\".4\"/><path d=\"M10 22 h24\" stroke-opacity=\".6\"/></g><path d=\"M22 24 L16 30 L22 36 L28 30 Z\" fill=\"currentColor\"/>",
"Future Self Interview": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M14 10 H30 L24 22 L30 34 H14 L20 22 Z\"/></g><path d=\"M18 14 H26\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>",
"Body Wisdom Dialogue": "<path d=\"M22 33 C12 26 9 19 13.5 15 C17 12 21 14 22 17 C23 14 27 12 30.5 15 C35 19 32 26 22 33 Z\" fill=\"currentColor\" fill-opacity=\".22\"/><path d=\"M22 33 C12 26 9 19 13.5 15 C17 12 21 14 22 17 C23 14 27 12 30.5 15 C35 19 32 26 22 33 Z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/>",
"Permission Giving": "<rect x=\"10\" y=\"14\" width=\"24\" height=\"16\" rx=\"2.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M15 23 L19 27 L28 17\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>",
"Secret Wish Confession": "<rect x=\"13\" y=\"20\" width=\"18\" height=\"14\" rx=\"2.5\" fill=\"currentColor\" fill-opacity=\".22\"/><rect x=\"13\" y=\"20\" width=\"18\" height=\"14\" rx=\"2.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M16.5 20 v-3 a5.5 5.5 0 0 1 11 0 v3\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/>",
"Mood Weather Report": "<circle cx=\"17\" cy=\"17\" r=\"4.5\" fill=\"currentColor\" fill-opacity=\".5\"/><path d=\"M22 30 a5 5 0 0 1 0.5 -10 a6 6 0 0 1 11 2.5 a4 4 0 0 1 -1.5 7.5 z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/>",
"SCAMPER Method": "<circle cx=\"22\" cy=\"22\" r=\"5.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><g stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"><path d=\"M22 9 V13.5 M22 30.5 V35 M9 22 H13.5 M30.5 22 H35 M12.8 12.8 L16 16 M28 28 L31.2 31.2 M31.2 12.8 L28 16 M16 28 L12.8 31.2\"/></g>",
"Six Thinking Hats": "<path d=\"M14 26 q8 -5 16 0\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/><path d=\"M17 26 q-6 1 -8 3 q13 4 26 0 q-2 -2 -8 -3\" fill=\"currentColor\" fill-opacity=\".22\"/><path d=\"M17 26 c-1 -8 11 -8 10 0\" fill=\"currentColor\" fill-opacity=\".5\"/>",
"Decision Tree Mapping": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"22\" cy=\"12\" r=\"2.6\"/><circle cx=\"14\" cy=\"32\" r=\"2.6\"/><circle cx=\"30\" cy=\"32\" r=\"2.6\"/><path d=\"M22 14.5 L22 20 M22 20 L14 29.4 M22 20 L30 29.4\"/></g>",
"Solution Matrix": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\"><rect x=\"11\" y=\"11\" width=\"22\" height=\"22\" rx=\"2\"/><path d=\"M11 22 H33 M22 11 V33\"/></g><path d=\"M24.5 14.5 L26.5 16.5 L30.5 12.5\" stroke=\"currentColor\" stroke-width=\"2\" fill=\"none\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>",
"Trait Transfer": "<path d=\"M12 16 l1.6 3.4 3.6 .4 -2.7 2.5 .7 3.6 -3.2 -1.8 -3.2 1.8 .7 -3.6 -2.7 -2.5 3.6 -.4 z\" fill=\"currentColor\"/><rect x=\"25\" y=\"23\" width=\"9\" height=\"9\" rx=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M17 22 L25 27\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-dasharray=\"1.5 2.5\"/>",
"Lotus Blossom": "<g fill=\"currentColor\"><circle cx=\"22\" cy=\"22\" r=\"3.4\"/></g><g fill=\"currentColor\" fill-opacity=\".4\"><circle cx=\"22\" cy=\"13\" r=\"2.8\"/><circle cx=\"22\" cy=\"31\" r=\"2.8\"/><circle cx=\"13\" cy=\"22\" r=\"2.8\"/><circle cx=\"31\" cy=\"22\" r=\"2.8\"/><circle cx=\"15.5\" cy=\"15.5\" r=\"2.5\"/><circle cx=\"28.5\" cy=\"15.5\" r=\"2.5\"/><circle cx=\"15.5\" cy=\"28.5\" r=\"2.5\"/><circle cx=\"28.5\" cy=\"28.5\" r=\"2.5\"/></g>",
"Worst Possible Idea": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M17 11 v10 h-5 l10 12 10 -12 h-5 v-10 z\"/></g>",
"Disney Method": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><circle cx=\"14\" cy=\"22\" r=\"4.5\"/><circle cx=\"22\" cy=\"22\" r=\"4.5\"/><circle cx=\"30\" cy=\"22\" r=\"4.5\"/></g>",
"Starbursting": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 8 V15 M22 29 V36 M8 22 H15 M29 22 H36 M12 12 L17 17 M27 27 L32 32 M32 12 L27 17 M12 32 L17 27\"/></g><path d=\"M19.5 19 a3.2 3.2 0 1 1 3 4 v1.2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\"/>",
"Mind Mapping": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"22\" cy=\"22\" r=\"4\"/><circle cx=\"11\" cy=\"13\" r=\"2.2\"/><circle cx=\"33\" cy=\"13\" r=\"2.2\"/><circle cx=\"10\" cy=\"28\" r=\"2.2\"/><circle cx=\"32\" cy=\"31\" r=\"2.2\"/><path d=\"M19 19.5 L12.5 14.5 M25 19.5 L31.5 14.5 M19 24.5 L11.5 27 M25.5 24 L30.5 29.5\"/></g>",
"Crazy 8s": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.7\"><rect x=\"9\" y=\"12\" width=\"8\" height=\"9\" rx=\"1.5\"/><rect x=\"18\" y=\"12\" width=\"8\" height=\"9\" rx=\"1.5\"/><rect x=\"27\" y=\"12\" width=\"8\" height=\"9\" rx=\"1.5\"/><rect x=\"9\" y=\"23\" width=\"8\" height=\"9\" rx=\"1.5\"/><rect x=\"18\" y=\"23\" width=\"8\" height=\"9\" rx=\"1.5\"/><rect x=\"27\" y=\"23\" width=\"8\" height=\"9\" rx=\"1.5\"/></g>",
"Time Travel Talk Show": "<rect x=\"18\" y=\"9\" width=\"8\" height=\"15\" rx=\"4\" fill=\"currentColor\" fill-opacity=\".25\"/><rect x=\"18\" y=\"9\" width=\"8\" height=\"15\" rx=\"4\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M14 21 a8 8 0 0 0 16 0 M22 29 V34 M17 34 H27\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>",
"Alien Anthropologist": "<ellipse cx=\"22\" cy=\"30\" rx=\"13\" ry=\"4.5\" fill=\"currentColor\" fill-opacity=\".25\"/><path d=\"M22 11 c7 0 10 6 10 11 c0 5 -5 7 -10 7 c-5 0 -10 -2 -10 -7 c0 -5 3 -11 10 -11 z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><g fill=\"currentColor\"><ellipse cx=\"18\" cy=\"22\" rx=\"1.6\" ry=\"2.4\"/><ellipse cx=\"26\" cy=\"22\" rx=\"1.6\" ry=\"2.4\"/></g>",
"Dream Fusion Laboratory": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M18 9 H26 M19.5 9 V18 L13 30 a2 2 0 0 0 2 3 H29 a2 2 0 0 0 2 -3 L24.5 18 V9\"/></g><path d=\"M16.5 26 H27.5\" stroke=\"currentColor\" stroke-width=\"2\"/><circle cx=\"20\" cy=\"29\" r=\"1.4\" fill=\"currentColor\"/><circle cx=\"25\" cy=\"28\" r=\"1.1\" fill=\"currentColor\"/>",
"Emotion Orchestra": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M17 30 V15 L31 12 V27\"/><circle cx=\"14\" cy=\"30\" r=\"3\"/><circle cx=\"28\" cy=\"27\" r=\"3\"/></g>",
"Parallel Universe Cafe": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><circle cx=\"18\" cy=\"22\" r=\"9\"/><circle cx=\"26\" cy=\"22\" r=\"9\" stroke-dasharray=\"2.5 2.5\"/></g>",
"Persona Journey": "<path d=\"M14 33 q-2 -8 6 -9 q8 -1 6 -8\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-dasharray=\"0.1 4\"/><circle cx=\"14\" cy=\"33\" r=\"2.4\" fill=\"currentColor\"/><path d=\"M26 16 l3 -5 3 5 z\" fill=\"currentColor\"/>",
"Devil's Advocate Courtroom": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 10 V32 M14 32 H30\"/><path d=\"M11 16 H33 M11 16 L8 23 H14 Z M33 16 L30 23 H36 Z\"/></g>",
"Chaos Engineering": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 9 L25 18 L34 18 L27 24 L30 33 L22 27 L14 33 L17 24 L10 18 L19 18 Z\"/></g>",
"Guerrilla Gardening Ideas": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 33 V21\"/><path d=\"M22 22 c-7 0 -9 -6 -9 -9 c6 0 9 3 9 9 z\"/><path d=\"M22 24 c6 0 8 -4 8 -7 c-5 0 -8 2 -8 7 z\"/></g>",
"Pirate Code Brainstorm": "<path d=\"M22 10 c-7 0 -11 5 -11 11 c0 4 2 6 4 7 v4 h3 v-2 h2 v2 h4 v-2 h2 v2 h3 v-4 c2 -1 4 -3 4 -7 c0 -6 -4 -11 -11 -11 z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/><g fill=\"currentColor\"><circle cx=\"17.5\" cy=\"21\" r=\"2.2\"/><circle cx=\"26.5\" cy=\"21\" r=\"2.2\"/></g>",
"Zombie Apocalypse Planning": "<circle cx=\"22\" cy=\"22\" r=\"4\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><path d=\"M22 10 a12 12 0 0 1 6 3.5 M32 16 a12 12 0 0 1 0 12 M28 33.5 a12 12 0 0 1 -12 0 M12 28 a12 12 0 0 1 0 -12 M16 10.5 a12 12 0 0 1 6 -0.5\" stroke-dasharray=\"0.1 5.5\"/></g><g fill=\"currentColor\"><circle cx=\"22\" cy=\"11\" r=\"2\"/><circle cx=\"11\" cy=\"22\" r=\"2\"/><circle cx=\"33\" cy=\"22\" r=\"2\"/></g>",
"Drunk History Retelling": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M13 12 H31 L25 23 V31 H19 V23 Z\"/><path d=\"M19 31 H25\" /></g><circle cx=\"29\" cy=\"14\" r=\"1.4\" fill=\"currentColor\"/>",
"Anti-Solution": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M14 18 a8 8 0 1 1 -1 8\"/><path d=\"M14 12 L14 18.5 L20 18\"/></g>",
"Elemental Forces": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 8 L30 22 H14 Z\"/><path d=\"M14 30 L22 36 L30 30\"/><path d=\"M14 26 H30\"/></g>",
"Nature's Solutions": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M16 32 C12 24 12 20 16 12 M28 32 C32 24 32 20 28 12\"/><path d=\"M16 16 L28 14 M16 22 L28 20 M16 28 L28 26\"/></g>",
"Ecosystem Thinking": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"22\" cy=\"13\" r=\"2.4\"/><circle cx=\"12\" cy=\"27\" r=\"2.4\"/><circle cx=\"32\" cy=\"27\" r=\"2.4\"/><circle cx=\"22\" cy=\"24\" r=\"2.4\"/><path d=\"M22 15.4 V21.6 M14 26 L20 24.5 M30 26 L24 24.5 M13.6 25.2 L30.4 25.2\"/></g>",
"Evolutionary Pressure": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M11 31 H17 M19 31 a6 6 0 0 1 6 -6 M25 25 a5 5 0 0 1 5 -5 M30 20 H33\"/><circle cx=\"11\" cy=\"31\" r=\"2\" fill=\"currentColor\"/><circle cx=\"33\" cy=\"20\" r=\"2.6\" fill=\"currentColor\"/></g>",
"Predator & Prey": "<path d=\"M22 9 L33 14 V23 C33 30 28 34 22 36 C16 34 11 30 11 23 V14 Z\" fill=\"currentColor\" fill-opacity=\".18\"/><path d=\"M22 9 L33 14 V23 C33 30 28 34 22 36 C16 34 11 30 11 23 V14 Z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/>",
"Metamorphosis Stages": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 12 V32\"/><path d=\"M22 16 C14 12 10 18 14 22 C10 26 14 32 22 28 C30 32 34 26 30 22 C34 18 30 12 22 16\"/></g>",
"Swarm Logic": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 10 L29 14 V22 L22 26 L15 22 V14 Z\"/><path d=\"M15 24 L18 33 M29 24 L26 33 M22 28 V35\" stroke-opacity=\".6\"/></g>",
"Observer Effect": "<path d=\"M9 22 q13 -10 26 0 q-13 10 -26 0 z\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/><circle cx=\"22\" cy=\"22\" r=\"4.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><circle cx=\"22\" cy=\"22\" r=\"1.8\" fill=\"currentColor\"/>",
"Entanglement Thinking": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><circle cx=\"15\" cy=\"22\" r=\"6\"/><circle cx=\"29\" cy=\"22\" r=\"6\"/></g><path d=\"M15 22 h14\" stroke=\"currentColor\" stroke-width=\"2\" stroke-dasharray=\"1.5 2.5\"/><g fill=\"currentColor\"><circle cx=\"15\" cy=\"22\" r=\"1.8\"/><circle cx=\"29\" cy=\"22\" r=\"1.8\"/></g>",
"Superposition Collapse": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M11 12 C20 16 24 16 33 12 M11 18 C20 22 24 22 33 18 M11 24 C20 28 24 28 33 24\"/><path d=\"M22 26 V34\"/></g><circle cx=\"22\" cy=\"34\" r=\"2\" fill=\"currentColor\"/>",
"Relativity Frame Shift": "<rect x=\"11\" y=\"11\" width=\"22\" height=\"22\" rx=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-opacity=\".4\"/><rect x=\"15\" y=\"15\" width=\"18\" height=\"18\" rx=\"2\" transform=\"rotate(-14 22 22)\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/>",
"Field Lines": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M12 13 V31 M16 13 C24 18 24 26 16 31 M22 13 C32 18 32 26 22 31\"/></g><circle cx=\"11\" cy=\"22\" r=\"2\" fill=\"currentColor\"/>",
"Quantum Tunneling": "<rect x=\"20\" y=\"9\" width=\"5\" height=\"26\" rx=\"1.5\" fill=\"currentColor\" fill-opacity=\".3\"/><path d=\"M10 22 H34\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\"/><path d=\"M28 17 L34 22 L28 27\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>",
"Indigenous Wisdom": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M26 11 C18 16 14 24 13 33 M26 11 C28 18 26 25 20 29\"/><path d=\"M26 11 C24 13 22 14 19 15 M24 16 C22 18 20 19 17 20 M22 21 C20 23 18 24 15 25\"/></g>",
"Fusion Cuisine": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M10 19 a12 7 0 0 0 24 0 Z\"/><path d=\"M22 19 V32 M16 32 H28\"/></g>",
"Ritual Innovation": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M12 33 V17 a10 10 0 0 1 20 0 V33\"/><path d=\"M12 33 H32 M22 33 V21\"/></g>",
"Mythic Frameworks": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M14 12 h13 a3 3 0 0 1 3 3 v17 l-3 -2 -3 2 -3 -2 -3 2 V15 a3 3 0 0 0 -3 -3 z\"/><path d=\"M14 12 a3 3 0 0 0 -3 3 h6\"/><path d=\"M20 18 H26 M20 23 H26\"/></g>",
"Proverb Mining": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 14 C17 10 11 11 11 11 V30 s6 -1 11 3 c5 -4 11 -3 11 -3 V11 s-6 -1 -11 3 z\"/><path d=\"M22 14 V31\"/></g>",
"Ancestor Council": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><circle cx=\"22\" cy=\"14\" r=\"3.5\"/><circle cx=\"13\" cy=\"19\" r=\"3\"/><circle cx=\"31\" cy=\"19\" r=\"3\"/></g><g fill=\"currentColor\" fill-opacity=\".25\"><path d=\"M16 31 c0 -5 12 -5 12 0 z\"/><path d=\"M8 31 c0 -4 9 -4.5 9 0 z\"/><path d=\"M27 31 c0 -4.5 9 -4 9 0 z\"/></g>",
"Trickster's Gambit": "<rect x=\"11\" y=\"12\" width=\"13\" height=\"18\" rx=\"2\" transform=\"rotate(-10 17.5 21)\" fill=\"currentColor\" fill-opacity=\".2\" stroke=\"currentColor\" stroke-width=\"2\"/><rect x=\"20\" y=\"14\" width=\"13\" height=\"18\" rx=\"2\" transform=\"rotate(10 26.5 23)\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M26.5 19 l1.4 3 1.4 -3 -1.4 -1 z\" fill=\"currentColor\"/>",
"Villain's Monologue": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M12 20 C16 18 19 18 22 21 C25 18 28 18 32 20 C30 24 26 24 22 21 C18 24 14 24 12 20 Z\"/></g><circle cx=\"22\" cy=\"14\" r=\"2.4\" fill=\"currentColor\"/>",
"Explain It to a Golden Retriever": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M14 18 C12 12 17 13 18 17 M30 18 C32 12 27 13 26 17\"/><path d=\"M15 19 C13 28 18 33 22 33 C26 33 31 28 29 19 C26 16 18 16 15 19 Z\"/></g><g fill=\"currentColor\"><circle cx=\"19\" cy=\"24\" r=\"1.4\"/><circle cx=\"25\" cy=\"24\" r=\"1.4\"/><circle cx=\"22\" cy=\"28\" r=\"1.6\"/></g>",
"Infomercial at 3AM": "<rect x=\"9\" y=\"14\" width=\"26\" height=\"18\" rx=\"2.5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M18 9 L22 14 L26 9\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M22 19 l1 2.6 2.8 .2 -2.1 1.9 .7 2.7 -2.4 -1.5 -2.4 1.5 .7 -2.7 -2.1 -1.9 2.8 -.2 z\" fill=\"currentColor\"/>",
"Drunk Uncle at Thanksgiving": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M11 16 L20 16 L27 11 V29 L20 24 L11 24 Z\"/><path d=\"M30 16 q3 4 0 8 M33 13 q5 7 0 14\"/></g>",
"Cursed Genie": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M10 30 h18 a2 2 0 0 0 2 -2 c0 -5 -6 -5 -8 -8 c5 -1 8 -3 8 -3 c-4 -2 -12 -2 -16 1 c-4 3 -5 9 -4 12 z\"/><path d=\"M30 17 L33 14 M31 21 L35 20\" stroke-opacity=\".6\"/></g>",
"Three Rounds of Stupid": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M13 30 V20 M9 24 L13 20 L17 24 M22 30 V15 M18 19 L22 15 L26 19 M31 30 V11 M27 15 L31 11 L35 15\"/></g>",
"Kill the Crown Jewel": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M11 28 L13 15 L19 22 L22 12 L25 22 L31 15 L33 28 Z\"/><path d=\"M11 28 H33\"/></g><path d=\"M14 12 L30 32\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\"/>",
"1000x Budget": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><ellipse cx=\"22\" cy=\"14\" rx=\"9\" ry=\"3.5\"/><path d=\"M13 14 V22 a9 3.5 0 0 0 18 0 V14\"/><path d=\"M13 22 V30 a9 3.5 0 0 0 18 0 V22\"/></g>",
"Ship in 60 Minutes": "<circle cx=\"22\" cy=\"24\" r=\"11\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 24 V17 M22 24 L27 27\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/><path d=\"M18 8 H26 M22 8 V13\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/>",
"The $0 Mandate": "<circle cx=\"22\" cy=\"22\" r=\"11\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 14 V30 M18 18 a4 3 0 0 1 8 0 a4 3 0 0 1 -8 4 a4 3 0 0 0 8 0\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\"/><path d=\"M14 30 L30 14\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\"/>",
"One Feature Only": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><circle cx=\"22\" cy=\"22\" r=\"4.5\"/><path d=\"M22 9 V13 M22 31 V35 M9 22 H13 M31 22 H35\" stroke-opacity=\".35\"/></g><circle cx=\"22\" cy=\"22\" r=\"2\" fill=\"currentColor\"/>",
"Crank the Dial to 11": "<path d=\"M11 28 A12 12 0 0 1 33 28\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/><path d=\"M22 28 L31 17\" stroke=\"currentColor\" stroke-width=\"2.2\" stroke-linecap=\"round\"/><circle cx=\"22\" cy=\"28\" r=\"2.6\" fill=\"currentColor\"/>",
"Constraint Roulette": "<circle cx=\"22\" cy=\"22\" r=\"12\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><circle cx=\"22\" cy=\"22\" r=\"12\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-dasharray=\"3 3.7\" stroke-opacity=\".5\"/><circle cx=\"22\" cy=\"22\" r=\"3\" fill=\"currentColor\"/><path d=\"M22 7 L25 12 H19 Z\" fill=\"currentColor\"/>",
"Time Horizon Ladder": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M9 30 H35\"/><path d=\"M14 30 V24 M22 30 V18 M30 30 V12\"/></g><g fill=\"currentColor\"><circle cx=\"14\" cy=\"24\" r=\"2\"/><circle cx=\"22\" cy=\"18\" r=\"2\"/><circle cx=\"30\" cy=\"12\" r=\"2\"/></g>",
"Post-Scarcity Test": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M15 22 a4.5 4.5 0 1 1 4.5 4.5 C16 26.5 14 18 11 18 a3.5 3.5 0 0 0 0 7 c4 0 5 -8 11 -8 a4.5 4.5 0 0 1 0 9 c-3 0 -4 -4.5 -7 -4.5\"/></g>",
"Utopia vs Dystopia Split-Screen": "<rect x=\"11\" y=\"11\" width=\"22\" height=\"22\" rx=\"3\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 11 V33\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 11 H33 a0 0 0 0 1 0 0 V33 H22 Z\" fill=\"currentColor\" fill-opacity=\".8\"/>",
"Sci-Fi Artifact From the Future": "<path d=\"M22 9 L33 15 V28 L22 35 L11 28 V15 Z\" fill=\"currentColor\" fill-opacity=\".15\"/><path d=\"M22 9 L33 15 V28 L22 35 L11 28 V15 Z M11 15 L22 21 L33 15 M22 21 V35\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"/>",
"Emerging Tech Collision": "<rect x=\"15\" y=\"15\" width=\"14\" height=\"14\" rx=\"2\" fill=\"currentColor\" fill-opacity=\".22\"/><rect x=\"15\" y=\"15\" width=\"14\" height=\"14\" rx=\"2\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"/><g stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"><path d=\"M19 15 V10 M25 15 V10 M19 29 V34 M25 29 V34 M15 19 H10 M15 25 H10 M29 19 H34 M29 25 H34\"/></g>",
"What-If-The-World-Changed Card Flip": "<rect x=\"13\" y=\"10\" width=\"18\" height=\"24\" rx=\"2.5\" fill=\"currentColor\" fill-opacity=\".18\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M22 10 V34\" stroke=\"currentColor\" stroke-width=\"1.6\" stroke-dasharray=\"2 2.5\"/><path d=\"M27 16 a4 4 0 1 1 4 4\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\"/>",
"Future Anthropologist Dig": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M22 27 a6 6 0 1 1 0.1 0 z\"/><path d=\"M22 23 a2.5 2.5 0 1 0 0.1 0 M19 30 a5 5 0 0 0 6 0\"/></g><path d=\"M12 16 L17 13 M32 16 L27 13\" stroke=\"currentColor\" stroke-width=\"1.6\" stroke-opacity=\".5\"/>",
"How Might We": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M11 13 H33 a2 2 0 0 1 2 2 V27 a2 2 0 0 1 -2 2 H24 L19 34 V29 H11 a2 2 0 0 1 -2 -2 V15 a2 2 0 0 1 2 -2 Z\"/></g><path d=\"M19 19 a3.2 3.2 0 1 1 3.4 3.4 v1.6\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linecap=\"round\"/><circle cx=\"22.4\" cy=\"27\" r=\"1.4\" fill=\"currentColor\"/>",
"Job to Be Done": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\"><rect x=\"9\" y=\"16\" width=\"26\" height=\"16\" rx=\"2.5\"/><path d=\"M17 16 v-3 a2 2 0 0 1 2 -2 h6 a2 2 0 0 1 2 2 v3\"/><path d=\"M9 23 H35\"/></g><circle cx=\"22\" cy=\"23\" r=\"1.8\" fill=\"currentColor\"/>",
"Empathy Map": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\"><rect x=\"11\" y=\"11\" width=\"22\" height=\"22\" rx=\"2\"/><path d=\"M11 22 H33 M22 11 V33\"/></g><path d=\"M22 27 c-2.6 -2.1 -4.2 -3.4 -4.2 -5.2 a2.1 2.1 0 0 1 4.2 -1 a2.1 2.1 0 0 1 4.2 1 c0 1.8 -1.6 3.1 -4.2 5.2 z\" fill=\"currentColor\"/>",
"Backcasting": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M30 11 V33\"/></g><path d=\"M30 13 L20 16.5 L30 20 Z\" fill=\"currentColor\"/><path d=\"M28 27 H14\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-dasharray=\"1.5 3\"/><path d=\"M18 23 L14 27 L18 31\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>",
"Scenario Cross": "<g stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"><path d=\"M22 9 V35 M9 22 H35\"/></g><g fill=\"currentColor\"><circle cx=\"15\" cy=\"15\" r=\"2\"/><circle cx=\"29\" cy=\"15\" r=\"2\"/><circle cx=\"15\" cy=\"29\" r=\"2\"/><circle cx=\"29\" cy=\"29\" r=\"2\"/></g>",
"TRIZ Contradiction": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M9 15 H18 M14.5 11.5 L18 15 L14.5 18.5\"/><path d=\"M35 29 H26 M29.5 25.5 L26 29 L29.5 32.5\"/></g><path d=\"M22 17.5 l1.5 3.4 3.7 .3 -2.8 2.4 .9 3.6 -3.3 -1.9 -3.3 1.9 .9 -3.6 -2.8 -2.4 3.7 -.3 z\" fill=\"currentColor\"/>",
"Fishbone Diagram": "<g fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M9 22 H33\"/><path d=\"M33 22 L36 18.5 M33 22 L36 25.5\"/><path d=\"M14 22 L18 15 M14 22 L18 29 M23 22 L27 15 M23 22 L27 29\"/></g><circle cx=\"9\" cy=\"22\" r=\"1.9\" fill=\"currentColor\"/>",
"Build on What Works": "<g fill=\"currentColor\"><rect x=\"11\" y=\"24\" width=\"6\" height=\"9\" rx=\"1\"/><rect x=\"19\" y=\"19\" width=\"6\" height=\"14\" rx=\"1\"/><rect x=\"27\" y=\"13\" width=\"6\" height=\"20\" rx=\"1\"/></g><path d=\"M11 19 L18 13 L24 16 L33 8\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M28 8 H33 V13\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>"
}
}

109
src/core-skills/bmad-brainstorming/assets/brain-methods.csv Normal file
View File

@ -0,0 +1,109 @@
category,technique_name,description,detail,provenance,good_for,audience
collaborative,Yes And Building,"Never negate; each person opens with ""Yes, and..."" and adds to the last idea, stacking a chain of accepted additions",,classic,novel|unstuck|planning,group
collaborative,Brain Writing Round Robin,"Everyone writes ideas silently, then passes their sheet; you build on whatever lands in front of you, round after round",,classic,novel|feature,group
collaborative,Random Stimulation,"Pull a random word or image and force a link to the problem: ""how does THIS spark a solution?""",,classic,unstuck|novel,either
collaborative,Role Playing,"Each person speaks as a different stakeholder, voicing what that role wants, fears, and would demand of the idea",,classic,strategy|personal|feature,either
collaborative,Ideation Relay Race,"30-second turns, no pausing: add one idea, slap it to the next person, keep the baton moving before anyone overthinks",,playful,unstuck,group
collaborative,Idea Hot Potato,"One idea gets tossed around the circle; each catcher must mutate it in 10 seconds before passing, no repeats allowed",,playful,unstuck,group
collaborative,Steal And Upgrade,"Pick a neighbor's idea you envy, claim it out loud, then make it visibly better before handing it back improved",,signature,novel|unstuck,group
collaborative,Fold The Paper,"Each person adds one line to a hidden drawing or sentence, sees only the previous fragment, then unfold the surreal whole",,playful,unstuck|novel,group
creative,What If Scenarios,"Detonate one constraint at a time — unlimited budget, opposite is true, problem vanished — and chase what rushes in",,signature,novel|strategy|unstuck,either
creative,Analogical Thinking,Ask 'this is like what?' and steal the solution pattern from the domain that answers,,signature,feature|novel|diagnosis,either
creative,First Principles Thinking,"Strip every assumption to bedrock facts, then rebuild the solution from scratch on truth alone",,classic,feature|novel|diagnosis|strategy,either
creative,Forced Relationships,Grab two unrelated things at random and force a bridge between them until an idea falls out,,signature,novel|unstuck,either
creative,Time Shifting,"Solve the problem as a 1900s artisan, then a 2150 colonist — harvest the era-bound constraints and tricks",,signature,novel|unstuck,either
creative,Metaphor Mapping,"Declare the problem IS a chosen metaphor, extend the metaphor fully, map each part back to find insights",,signature,novel|diagnosis,either
creative,Cross-Pollination,"Ask how a wildly different industry — casinos, ERs, beekeeping — would crack this, then adapt their move",,signature,novel|feature|strategy,either
creative,Concept Blending,"Fuse two concepts into one new hybrid category and name what the merger becomes, not just combines",,signature,novel,either
creative,Reverse Brainstorming,Generate problems instead of solutions — 'how could we make this fail?' — then mine each for its inverse,,classic,diagnosis|feature|unstuck,either
creative,Sensory Exploration,"Interrogate the idea through each sense — its taste, smell, sound, texture — to surface non-analytical angles",,signature,novel|unstuck,either
deep,Five Whys,"Ask ""why?"" five times in a chain, each answer feeding the next, until you hit the root cause beneath the symptom",,classic,diagnosis,either
deep,Provocation Technique,"State something deliberately absurd, then mine it: ""how could this be useful?"" Extract the usable principle hiding inside",,classic,unstuck|novel,either
deep,Assumption Reversal,"List every assumption baked into the problem, flip each to its opposite, then rebuild a solution on the inverted foundation",,classic,novel|diagnosis|strategy,either
deep,Question Storming,"Generate only questions about the problem, zero answers allowed, until the real problem worth solving comes into focus",,classic,diagnosis|strategy|unstuck,either
deep,Constraint Mapping,"Map every constraint, sort real from imagined, then attack each: dissolve it, route around it, or turn it into an asset",,signature,feature|strategy|diagnosis,either
deep,Failure Analysis,"Dissect a relevant failure: what broke, why it broke, what lesson it leaves, and how to apply that wisdom here",,signature,diagnosis|strategy|feature,either
deep,Emergent Thinking,Stop forcing a solution; watch what patterns the system keeps producing and name what's trying to emerge on its own,,signature,strategy|novel,either
deep,Causal Loop Mapping,"Diagram the feedback loops linking causes and effects, find the reinforcing and balancing cycles, and target the leverage point",,classic,diagnosis|strategy,either
deep,Morphological Analysis,"List the problem's independent parameters, generate options for each, then combine across them to surface untried configurations",,classic,feature|novel|planning,either
deep,Laddering,"Ask 'and what would that give you?' up the chain until you reach the real underlying need, then ideate fresh at that level",,classic,personal|strategy|diagnosis,either
introspective_delight,Inner Child Conference,"Answer as your 7-year-old self: ask naive 'why why why' questions, chase wonder, ban every boring adult thought",,signature,personal|unstuck,solo
introspective_delight,Shadow Work Mining,"Name what you're avoiding, resisting, or scared of about this — then dig there for the buried insight",,signature,personal|diagnosis,solo
introspective_delight,Values Archaeology,Keep asking 'why do I care?' until you hit bedrock: the non-negotiable value secretly steering the choice,,signature,personal|strategy,solo
introspective_delight,Future Self Interview,Interview your wise 80-year-old self about this problem and write down the advice they give you,,signature,personal,solo
introspective_delight,Body Wisdom Dialogue,"Scan for the tension, flutter, or gut pull each option triggers; let the body's yes/no drive the ideas",,signature,personal,solo
introspective_delight,Permission Giving,"Write yourself an explicit permission slip to think the forbidden, impossible thought — then think it out loud",,signature,personal|unstuck,solo
introspective_delight,Secret Wish Confession,"Whisper the embarrassing thing you secretly want here but won't admit, then build the idea honoring it",,signature,personal,solo
introspective_delight,Mood Weather Report,"Name the inner weather right now (fog, storm, sun) and let that exact emotional climate generate the ideas",,signature,personal|unstuck,solo
structured,SCAMPER Method,"Run your idea through seven lenses: Substitute, Combine, Adapt, Modify, Put-to-other-use, Eliminate, Reverse",,classic,feature|novel,either
structured,Six Thinking Hats,"Examine the problem six ways one at a time: facts, feelings, benefits, risks, new ideas, process",,classic,strategy|diagnosis|planning|personal,either
structured,Decision Tree Mapping,"Chart every choice point and the paths it forks into, following each branch to its outcome and risk",,signature,planning|strategy|diagnosis,either
structured,Solution Matrix,"Grid problem variables against solution approaches, score every cell, hunt the best pairings and empty gaps",,signature,feature|planning,either
structured,Trait Transfer,"Name what makes an unrelated success work, then graft those winning traits onto your own problem",,signature,novel|feature,either
structured,Lotus Blossom,"Put the theme at the center of a 3x3 grid, fill the 8 cells around it, then promote each of those to the center of its own new 3x3",,classic,feature|planning|novel,either
structured,Worst Possible Idea,"Deliberately generate the most terrible solutions you can, then flip each into what it teaches you to do right",,classic,unstuck|novel,either
structured,Disney Method,"Cycle the idea through three rooms: Dreamer (anything goes), Realist (how we'd build it), Critic (what breaks)",,classic,feature|strategy|planning,either
structured,Starbursting,"Interrogate the idea with only questions — who, what, where, when, why, how — exhaust each before answering any",,classic,feature|planning|diagnosis,either
structured,Mind Mapping,"Branch the central topic outward, each node spawning children; follow tangents wherever they pull and let the web sprawl",,classic,planning|novel|feature,either
structured,Crazy 8s,"Eight ideas in eight minutes, one per box, no editing — speed outruns your inner critic",,classic,feature|novel|unstuck,either
theatrical,Time Travel Talk Show,"Host a talk show interviewing your past, present, and future selves to mine each era for advice on the problem",,playful,novel|personal,either
theatrical,Alien Anthropologist,"Become a baffled alien studying the problem and narrate aloud what seems strange, arbitrary, or insane about it",,playful,diagnosis|unstuck|strategy,either
theatrical,Dream Fusion Laboratory,"Voice the impossible fantasy solution first, then reverse-engineer the bridging steps back to reality",,signature,novel|unstuck,either
theatrical,Emotion Orchestra,"Run a separate ideation round led by each emotion (rage, joy, fear, hope), then harmonize their conflicting ideas",,playful,personal|strategy,either
theatrical,Parallel Universe Cafe,"Rewrite one fundamental rule of reality (physics, economics, social norms) and solve the problem under those laws",,playful,novel|unstuck,either
theatrical,Persona Journey,"Embody an archetype and solve the problem in-character, naming what that persona sees that you normally miss",,signature,feature|strategy,either
theatrical,Devil's Advocate Courtroom,"Stage a trial: prosecute the idea, defend it, then deliver the jury verdict, each role argued fully in character",,signature,strategy|diagnosis,group
wild,Chaos Engineering,"Deliberately break your idea every way it could fail, then rebuild only the parts that survive the wreckage",,signature,feature|diagnosis|strategy,either
wild,Guerrilla Gardening Ideas,Plant your solution in the least expected place and let it grow underground until it surprises everyone,,playful,strategy|unstuck,either
wild,Pirate Code Brainstorm,"Steal the best bits from anywhere, remix without asking permission, grab what works and run",,playful,novel|unstuck,either
wild,Zombie Apocalypse Planning,"Society just collapsed — strip your idea to only what survives with no power, no rules, no backup",,playful,feature|strategy|unstuck,either
wild,Drunk History Retelling,"Explain it like you're three drinks in: no filter, no jargon, just the raw stupid-simple truth",,playful,unstuck|diagnosis,either
wild,Anti-Solution,"Brainstorm how to make the problem spectacularly worse, then invert every sabotage into a fix",,signature,diagnosis|unstuck,either
wild,Elemental Forces,"Let fire, water, earth, and air each sculpt your idea their own brutal way and see what survives",,playful,novel|unstuck,either
biomimetic,Nature's Solutions,"Name an organism that already solved your problem, then copy its mechanism into your design",,signature,feature|novel,either
biomimetic,Ecosystem Thinking,"Map your problem as an ecosystem: who eats whom, who partners, what decays, what fills the gaps",,signature,strategy|diagnosis,either
biomimetic,Evolutionary Pressure,"Spawn many ugly variants, apply a brutal selection rule, breed the survivors, repeat until it adapts",,signature,feature|novel,either
biomimetic,Predator & Prey,"Pick a threat to your idea, then design the defense, camouflage, or escape an animal would evolve against it",,signature,strategy|feature,either
biomimetic,Metamorphosis Stages,"Force your idea through egg, larva, pupa, adult: a radically different form and purpose at each life stage",,signature,novel|strategy,either
biomimetic,Swarm Logic,Forbid the master plan: solve it with dumb local rules each agent follows so order emerges from the bottom up,,signature,feature|strategy,either
quantum,Observer Effect,"Ask how the act of watching, measuring, or shipping this idea changes the very thing you're trying to capture",,signature,strategy|diagnosis,either
quantum,Entanglement Thinking,Pair two distant parts of the problem and insist a change in one instantly flips the other — surface the hidden linkage,,signature,diagnosis|strategy,either
quantum,Superposition Collapse,"Hold all rival solutions alive at once, then name the one constraint that collapses them to a single winner",,signature,strategy|diagnosis,either
quantum,Relativity Frame Shift,"Re-run the idea from a wildly different observer's reference frame — the slow user, the rival, future-you — and see what warps",,signature,strategy|novel,either
quantum,Field Lines,Treat the goal as a charge and map the invisible forces pulling every stakeholder toward or away from it,,signature,strategy,either
quantum,Quantum Tunneling,"Assume the idea can pass straight through the 'impossible' barrier instead of over it — what's on the other side, reached cheaply",,signature,unstuck|novel,either
cultural,Indigenous Wisdom,"Ask how an indigenous or traditional knowledge system would approach this — name the culture, channel its ancestral problem-solving",,signature,personal|strategy|novel,either
cultural,Fusion Cuisine,Pick two unrelated cultures and force-blend their approaches; harvest the hybrid that neither alone would invent,,signature,novel,either
cultural,Ritual Innovation,"Redesign the idea as a ceremony — define the threshold, the gestures, the transformation participants undergo",,signature,novel|personal,either
cultural,Mythic Frameworks,"Map the problem onto a myth: name the archetypes, find the parallel tale, let its structure dictate the resolution",,signature,strategy|personal|novel,either
cultural,Proverb Mining,"Collect proverbs from many cultures on this theme, then build the solution from the one that clashes hardest with your assumptions",,signature,personal|strategy,either
cultural,Ancestor Council,"Convene three ancestors or elders from different traditions, voice each one's verdict on your idea, reconcile their disagreement",,signature,personal|strategy,either
cultural,Trickster's Gambit,"Channel the trickster figure — coyote, Anansi, Loki — and solve it by cheating, inverting, or breaking the sacred rule",,playful,unstuck|strategy,either
absurdist,Villain's Monologue,Pitch your problem as an evil mastermind gloating about their scheme; the diabolical plan reveals the real solution,,playful,diagnosis|strategy|unstuck,either
absurdist,Explain It to a Golden Retriever,"Re-pitch the idea to an excitable dog who only cares about treats, balls, and naps; keep only what survives",,playful,unstuck|diagnosis|feature,either
absurdist,Infomercial at 3AM,"Sell your half-baked idea as a desperate late-night infomercial: 'But wait, there's more!' until features fall out",,playful,strategy|novel,either
absurdist,Drunk Uncle at Thanksgiving,"Have your loudest, least-filtered relative rant about the problem; mine the unhinged hot takes for buried truth",,playful,unstuck|diagnosis,either
absurdist,Cursed Genie,"Make a wish, then let a malicious genie grant it in the most technically-correct disastrous way; patch each loophole",,playful,diagnosis|feature,either
absurdist,Three Rounds of Stupid,"Round 1 absurd ideas, Round 2 make each MORE absurd, Round 3 find the smallest serious thing hiding in the silliest",,playful,unstuck|novel,either
constraint,Kill the Crown Jewel,"Delete the single best, most beloved feature — now redesign the whole thing to win without it",,signature,feature|strategy|unstuck,either
constraint,1000x Budget,"Pretend money, time, and people are infinite — design the absurd version, then mine it for ideas you can actually steal",,signature,novel|strategy,either
constraint,Ship in 60 Minutes,"You launch in one hour with what's already on hand — name what you cut, fake, or borrow to make it real",,signature,feature|planning|unstuck,either
constraint,The $0 Mandate,"Achieve the goal spending literally nothing — no tools, hires, or ads; only people, favors, and what you own",,signature,planning|strategy|feature,either
constraint,One Feature Only,"You may keep exactly ONE capability and nothing else — pick it, then make that single thing unbelievably good",,signature,feature|strategy,either
constraint,Crank the Dial to 11,"Pick one dimension and exaggerate it to a ludicrous extreme — fastest, biggest, cheapest, weirdest — and see what breaks open",,signature,novel|unstuck,either
constraint,Constraint Roulette,"Each round draw a brutal random limit (no screens, half the team, one day) and re-solve under it; survivors become real ideas",,signature,unstuck|feature,either
speculative_future,Time Horizon Ladder,"Solve the idea for 1 year out, then 10, then 100 — note what survives, breaks, or becomes absurd at each rung",,signature,strategy|planning|novel,either
speculative_future,Post-Scarcity Test,"Assume the core constraint (money, energy, time, attention) is now infinite and free — what does the idea become",,signature,novel|strategy,either
speculative_future,Utopia vs Dystopia Split-Screen,Write the same future twice: the brochure where it went perfectly and the headline where it went horribly,,signature,strategy|diagnosis,either
speculative_future,Sci-Fi Artifact From the Future,"Describe one physical object, ad, or news clip from the world where this idea already won — reverse-engineer it",,signature,novel|feature,either
speculative_future,Emerging Tech Collision,"Force-marry your idea to a frontier tech (AGI, fusion, neural implants, gene edit) and ask what new thing is born",,signature,novel|feature|strategy,either
speculative_future,What-If-The-World-Changed Card Flip,"Draw a wild world-shift (no privacy, half population, 200-yr lifespans) and redesign the idea to fit that world",,signature,novel|unstuck,either
speculative_future,Future Anthropologist Dig,"A scholar in 2200 unearths your idea as a relic — what do they conclude it reveals about us, and what replaced it",,signature,strategy|novel,either
structured,How Might We,"Reframe the problem as a batch of 'How might we...' opportunity questions first, then ideate against the sharpest one",,classic,feature|novel|strategy|diagnosis,either
structured,Job to Be Done,"Ask what the user is really hiring this to do, then ideate around that underlying job, not the feature you assumed",,classic,feature|strategy|novel,either
structured,Empathy Map,"Map what the user says, thinks, does, and feels around the problem, then mine each quadrant for the unmet need",,classic,feature|personal,either
structured,Backcasting,"Fix the finished future in vivid detail, then work backward step by step to the one move you'd have to make first",,classic,strategy|planning|novel,either
deep,TRIZ Contradiction,"Name the core contradiction (what only improves by making something else worse), then brainstorm ways to win both instead of trading off",,classic,feature|novel|diagnosis,either
deep,Fishbone Diagram,"Branch the problem's spine into cause categories (people, process, tools, environment) and mine each bone for contributing causes",,classic,diagnosis,either
deep,Build on What Works,"Name what's already succeeding and why, then ideate how to amplify and extend it instead of fixing what's broken",,classic,personal|strategy,either
speculative_future,Scenario Cross,"Pick two high-impact uncertainties, cross them into four futures, and ideate the move that wins in every one",,classic,strategy|planning,either
1 category technique_name description detail provenance good_for audience
2 collaborative Yes And Building Never negate; each person opens with "Yes, and..." and adds to the last idea, stacking a chain of accepted additions classic novel|unstuck|planning group
3 collaborative Brain Writing Round Robin Everyone writes ideas silently, then passes their sheet; you build on whatever lands in front of you, round after round classic novel|feature group
4 collaborative Random Stimulation Pull a random word or image and force a link to the problem: "how does THIS spark a solution?" classic unstuck|novel either
5 collaborative Role Playing Each person speaks as a different stakeholder, voicing what that role wants, fears, and would demand of the idea classic strategy|personal|feature either
6 collaborative Ideation Relay Race 30-second turns, no pausing: add one idea, slap it to the next person, keep the baton moving before anyone overthinks playful unstuck group
7 collaborative Idea Hot Potato One idea gets tossed around the circle; each catcher must mutate it in 10 seconds before passing, no repeats allowed playful unstuck group
8 collaborative Steal And Upgrade Pick a neighbor's idea you envy, claim it out loud, then make it visibly better before handing it back improved signature novel|unstuck group
9 collaborative Fold The Paper Each person adds one line to a hidden drawing or sentence, sees only the previous fragment, then unfold the surreal whole playful unstuck|novel group
10 creative What If Scenarios Detonate one constraint at a time — unlimited budget, opposite is true, problem vanished — and chase what rushes in signature novel|strategy|unstuck either
11 creative Analogical Thinking Ask 'this is like what?' and steal the solution pattern from the domain that answers signature feature|novel|diagnosis either
12 creative First Principles Thinking Strip every assumption to bedrock facts, then rebuild the solution from scratch on truth alone classic feature|novel|diagnosis|strategy either
13 creative Forced Relationships Grab two unrelated things at random and force a bridge between them until an idea falls out signature novel|unstuck either
14 creative Time Shifting Solve the problem as a 1900s artisan, then a 2150 colonist — harvest the era-bound constraints and tricks signature novel|unstuck either
15 creative Metaphor Mapping Declare the problem IS a chosen metaphor, extend the metaphor fully, map each part back to find insights signature novel|diagnosis either
16 creative Cross-Pollination Ask how a wildly different industry — casinos, ERs, beekeeping — would crack this, then adapt their move signature novel|feature|strategy either
17 creative Concept Blending Fuse two concepts into one new hybrid category and name what the merger becomes, not just combines signature novel either
18 creative Reverse Brainstorming Generate problems instead of solutions — 'how could we make this fail?' — then mine each for its inverse classic diagnosis|feature|unstuck either
19 creative Sensory Exploration Interrogate the idea through each sense — its taste, smell, sound, texture — to surface non-analytical angles signature novel|unstuck either
20 deep Five Whys Ask "why?" five times in a chain, each answer feeding the next, until you hit the root cause beneath the symptom classic diagnosis either
21 deep Provocation Technique State something deliberately absurd, then mine it: "how could this be useful?" Extract the usable principle hiding inside classic unstuck|novel either
22 deep Assumption Reversal List every assumption baked into the problem, flip each to its opposite, then rebuild a solution on the inverted foundation classic novel|diagnosis|strategy either
23 deep Question Storming Generate only questions about the problem, zero answers allowed, until the real problem worth solving comes into focus classic diagnosis|strategy|unstuck either
24 deep Constraint Mapping Map every constraint, sort real from imagined, then attack each: dissolve it, route around it, or turn it into an asset signature feature|strategy|diagnosis either
25 deep Failure Analysis Dissect a relevant failure: what broke, why it broke, what lesson it leaves, and how to apply that wisdom here signature diagnosis|strategy|feature either
26 deep Emergent Thinking Stop forcing a solution; watch what patterns the system keeps producing and name what's trying to emerge on its own signature strategy|novel either
27 deep Causal Loop Mapping Diagram the feedback loops linking causes and effects, find the reinforcing and balancing cycles, and target the leverage point classic diagnosis|strategy either
28 deep Morphological Analysis List the problem's independent parameters, generate options for each, then combine across them to surface untried configurations classic feature|novel|planning either
29 deep Laddering Ask 'and what would that give you?' up the chain until you reach the real underlying need, then ideate fresh at that level classic personal|strategy|diagnosis either
30 introspective_delight Inner Child Conference Answer as your 7-year-old self: ask naive 'why why why' questions, chase wonder, ban every boring adult thought signature personal|unstuck solo
31 introspective_delight Shadow Work Mining Name what you're avoiding, resisting, or scared of about this — then dig there for the buried insight signature personal|diagnosis solo
32 introspective_delight Values Archaeology Keep asking 'why do I care?' until you hit bedrock: the non-negotiable value secretly steering the choice signature personal|strategy solo
33 introspective_delight Future Self Interview Interview your wise 80-year-old self about this problem and write down the advice they give you signature personal solo
34 introspective_delight Body Wisdom Dialogue Scan for the tension, flutter, or gut pull each option triggers; let the body's yes/no drive the ideas signature personal solo
35 introspective_delight Permission Giving Write yourself an explicit permission slip to think the forbidden, impossible thought — then think it out loud signature personal|unstuck solo
36 introspective_delight Secret Wish Confession Whisper the embarrassing thing you secretly want here but won't admit, then build the idea honoring it signature personal solo
37 introspective_delight Mood Weather Report Name the inner weather right now (fog, storm, sun) and let that exact emotional climate generate the ideas signature personal|unstuck solo
38 structured SCAMPER Method Run your idea through seven lenses: Substitute, Combine, Adapt, Modify, Put-to-other-use, Eliminate, Reverse classic feature|novel either
39 structured Six Thinking Hats Examine the problem six ways one at a time: facts, feelings, benefits, risks, new ideas, process classic strategy|diagnosis|planning|personal either
40 structured Decision Tree Mapping Chart every choice point and the paths it forks into, following each branch to its outcome and risk signature planning|strategy|diagnosis either
41 structured Solution Matrix Grid problem variables against solution approaches, score every cell, hunt the best pairings and empty gaps signature feature|planning either
42 structured Trait Transfer Name what makes an unrelated success work, then graft those winning traits onto your own problem signature novel|feature either
43 structured Lotus Blossom Put the theme at the center of a 3x3 grid, fill the 8 cells around it, then promote each of those to the center of its own new 3x3 classic feature|planning|novel either
44 structured Worst Possible Idea Deliberately generate the most terrible solutions you can, then flip each into what it teaches you to do right classic unstuck|novel either
45 structured Disney Method Cycle the idea through three rooms: Dreamer (anything goes), Realist (how we'd build it), Critic (what breaks) classic feature|strategy|planning either
46 structured Starbursting Interrogate the idea with only questions — who, what, where, when, why, how — exhaust each before answering any classic feature|planning|diagnosis either
47 structured Mind Mapping Branch the central topic outward, each node spawning children; follow tangents wherever they pull and let the web sprawl classic planning|novel|feature either
48 structured Crazy 8s Eight ideas in eight minutes, one per box, no editing — speed outruns your inner critic classic feature|novel|unstuck either
49 theatrical Time Travel Talk Show Host a talk show interviewing your past, present, and future selves to mine each era for advice on the problem playful novel|personal either
50 theatrical Alien Anthropologist Become a baffled alien studying the problem and narrate aloud what seems strange, arbitrary, or insane about it playful diagnosis|unstuck|strategy either
51 theatrical Dream Fusion Laboratory Voice the impossible fantasy solution first, then reverse-engineer the bridging steps back to reality signature novel|unstuck either
52 theatrical Emotion Orchestra Run a separate ideation round led by each emotion (rage, joy, fear, hope), then harmonize their conflicting ideas playful personal|strategy either
53 theatrical Parallel Universe Cafe Rewrite one fundamental rule of reality (physics, economics, social norms) and solve the problem under those laws playful novel|unstuck either
54 theatrical Persona Journey Embody an archetype and solve the problem in-character, naming what that persona sees that you normally miss signature feature|strategy either
55 theatrical Devil's Advocate Courtroom Stage a trial: prosecute the idea, defend it, then deliver the jury verdict, each role argued fully in character signature strategy|diagnosis group
56 wild Chaos Engineering Deliberately break your idea every way it could fail, then rebuild only the parts that survive the wreckage signature feature|diagnosis|strategy either
57 wild Guerrilla Gardening Ideas Plant your solution in the least expected place and let it grow underground until it surprises everyone playful strategy|unstuck either
58 wild Pirate Code Brainstorm Steal the best bits from anywhere, remix without asking permission, grab what works and run playful novel|unstuck either
59 wild Zombie Apocalypse Planning Society just collapsed — strip your idea to only what survives with no power, no rules, no backup playful feature|strategy|unstuck either
60 wild Drunk History Retelling Explain it like you're three drinks in: no filter, no jargon, just the raw stupid-simple truth playful unstuck|diagnosis either
61 wild Anti-Solution Brainstorm how to make the problem spectacularly worse, then invert every sabotage into a fix signature diagnosis|unstuck either
62 wild Elemental Forces Let fire, water, earth, and air each sculpt your idea their own brutal way and see what survives playful novel|unstuck either
63 biomimetic Nature's Solutions Name an organism that already solved your problem, then copy its mechanism into your design signature feature|novel either
64 biomimetic Ecosystem Thinking Map your problem as an ecosystem: who eats whom, who partners, what decays, what fills the gaps signature strategy|diagnosis either
65 biomimetic Evolutionary Pressure Spawn many ugly variants, apply a brutal selection rule, breed the survivors, repeat until it adapts signature feature|novel either
66 biomimetic Predator & Prey Pick a threat to your idea, then design the defense, camouflage, or escape an animal would evolve against it signature strategy|feature either
67 biomimetic Metamorphosis Stages Force your idea through egg, larva, pupa, adult: a radically different form and purpose at each life stage signature novel|strategy either
68 biomimetic Swarm Logic Forbid the master plan: solve it with dumb local rules each agent follows so order emerges from the bottom up signature feature|strategy either
69 quantum Observer Effect Ask how the act of watching, measuring, or shipping this idea changes the very thing you're trying to capture signature strategy|diagnosis either
70 quantum Entanglement Thinking Pair two distant parts of the problem and insist a change in one instantly flips the other — surface the hidden linkage signature diagnosis|strategy either
71 quantum Superposition Collapse Hold all rival solutions alive at once, then name the one constraint that collapses them to a single winner signature strategy|diagnosis either
72 quantum Relativity Frame Shift Re-run the idea from a wildly different observer's reference frame — the slow user, the rival, future-you — and see what warps signature strategy|novel either
73 quantum Field Lines Treat the goal as a charge and map the invisible forces pulling every stakeholder toward or away from it signature strategy either
74 quantum Quantum Tunneling Assume the idea can pass straight through the 'impossible' barrier instead of over it — what's on the other side, reached cheaply signature unstuck|novel either
75 cultural Indigenous Wisdom Ask how an indigenous or traditional knowledge system would approach this — name the culture, channel its ancestral problem-solving signature personal|strategy|novel either
76 cultural Fusion Cuisine Pick two unrelated cultures and force-blend their approaches; harvest the hybrid that neither alone would invent signature novel either
77 cultural Ritual Innovation Redesign the idea as a ceremony — define the threshold, the gestures, the transformation participants undergo signature novel|personal either
78 cultural Mythic Frameworks Map the problem onto a myth: name the archetypes, find the parallel tale, let its structure dictate the resolution signature strategy|personal|novel either
79 cultural Proverb Mining Collect proverbs from many cultures on this theme, then build the solution from the one that clashes hardest with your assumptions signature personal|strategy either
80 cultural Ancestor Council Convene three ancestors or elders from different traditions, voice each one's verdict on your idea, reconcile their disagreement signature personal|strategy either
81 cultural Trickster's Gambit Channel the trickster figure — coyote, Anansi, Loki — and solve it by cheating, inverting, or breaking the sacred rule playful unstuck|strategy either
82 absurdist Villain's Monologue Pitch your problem as an evil mastermind gloating about their scheme; the diabolical plan reveals the real solution playful diagnosis|strategy|unstuck either
83 absurdist Explain It to a Golden Retriever Re-pitch the idea to an excitable dog who only cares about treats, balls, and naps; keep only what survives playful unstuck|diagnosis|feature either
84 absurdist Infomercial at 3AM Sell your half-baked idea as a desperate late-night infomercial: 'But wait, there's more!' until features fall out playful strategy|novel either
85 absurdist Drunk Uncle at Thanksgiving Have your loudest, least-filtered relative rant about the problem; mine the unhinged hot takes for buried truth playful unstuck|diagnosis either
86 absurdist Cursed Genie Make a wish, then let a malicious genie grant it in the most technically-correct disastrous way; patch each loophole playful diagnosis|feature either
87 absurdist Three Rounds of Stupid Round 1 absurd ideas, Round 2 make each MORE absurd, Round 3 find the smallest serious thing hiding in the silliest playful unstuck|novel either
88 constraint Kill the Crown Jewel Delete the single best, most beloved feature — now redesign the whole thing to win without it signature feature|strategy|unstuck either
89 constraint 1000x Budget Pretend money, time, and people are infinite — design the absurd version, then mine it for ideas you can actually steal signature novel|strategy either
90 constraint Ship in 60 Minutes You launch in one hour with what's already on hand — name what you cut, fake, or borrow to make it real signature feature|planning|unstuck either
91 constraint The $0 Mandate Achieve the goal spending literally nothing — no tools, hires, or ads; only people, favors, and what you own signature planning|strategy|feature either
92 constraint One Feature Only You may keep exactly ONE capability and nothing else — pick it, then make that single thing unbelievably good signature feature|strategy either
93 constraint Crank the Dial to 11 Pick one dimension and exaggerate it to a ludicrous extreme — fastest, biggest, cheapest, weirdest — and see what breaks open signature novel|unstuck either
94 constraint Constraint Roulette Each round draw a brutal random limit (no screens, half the team, one day) and re-solve under it; survivors become real ideas signature unstuck|feature either
95 speculative_future Time Horizon Ladder Solve the idea for 1 year out, then 10, then 100 — note what survives, breaks, or becomes absurd at each rung signature strategy|planning|novel either
96 speculative_future Post-Scarcity Test Assume the core constraint (money, energy, time, attention) is now infinite and free — what does the idea become signature novel|strategy either
97 speculative_future Utopia vs Dystopia Split-Screen Write the same future twice: the brochure where it went perfectly and the headline where it went horribly signature strategy|diagnosis either
98 speculative_future Sci-Fi Artifact From the Future Describe one physical object, ad, or news clip from the world where this idea already won — reverse-engineer it signature novel|feature either
99 speculative_future Emerging Tech Collision Force-marry your idea to a frontier tech (AGI, fusion, neural implants, gene edit) and ask what new thing is born signature novel|feature|strategy either
100 speculative_future What-If-The-World-Changed Card Flip Draw a wild world-shift (no privacy, half population, 200-yr lifespans) and redesign the idea to fit that world signature novel|unstuck either
101 speculative_future Future Anthropologist Dig A scholar in 2200 unearths your idea as a relic — what do they conclude it reveals about us, and what replaced it signature strategy|novel either
102 structured How Might We Reframe the problem as a batch of 'How might we...' opportunity questions first, then ideate against the sharpest one classic feature|novel|strategy|diagnosis either
103 structured Job to Be Done Ask what the user is really hiring this to do, then ideate around that underlying job, not the feature you assumed classic feature|strategy|novel either
104 structured Empathy Map Map what the user says, thinks, does, and feels around the problem, then mine each quadrant for the unmet need classic feature|personal either
105 structured Backcasting Fix the finished future in vivid detail, then work backward step by step to the one move you'd have to make first classic strategy|planning|novel either
106 deep TRIZ Contradiction Name the core contradiction (what only improves by making something else worse), then brainstorm ways to win both instead of trading off classic feature|novel|diagnosis either
107 deep Fishbone Diagram Branch the problem's spine into cause categories (people, process, tools, environment) and mine each bone for contributing causes classic diagnosis either
108 deep Build on What Works Name what's already succeeding and why, then ideate how to amplify and extend it instead of fixing what's broken classic personal|strategy either
109 speculative_future Scenario Cross Pick two high-impact uncertainties, cross them into four futures, and ideate the move that wins in every one classic strategy|planning either

326
src/core-skills/bmad-brainstorming/assets/brain-selector.html Normal file
View File

File diff suppressed because one or more lines are too long

62
src/core-skills/bmad-brainstorming/brain-methods.csv
View File

@ -1,62 +0,0 @@
category,technique_name,description
collaborative,Yes And Building,"Build momentum through positive additions where each idea becomes a launching pad - use prompts like 'Yes and we could also...' or 'Building on that idea...' to create energetic collaborative flow that builds upon previous contributions"
collaborative,Brain Writing Round Robin,"Silent idea generation followed by building on others' written concepts - gives quieter voices equal contribution while maintaining documentation through the sequence of writing silently, passing ideas, and building on received concepts"
collaborative,Random Stimulation,"Use random words/images as creative catalysts to force unexpected connections - breaks through mental blocks with serendipitous inspiration by asking how random elements relate, what connections exist, and forcing relationships"
collaborative,Role Playing,"Generate solutions from multiple stakeholder perspectives to build empathy while ensuring comprehensive consideration - embody different roles by asking what they want, how they'd approach problems, and what matters most to them"
collaborative,Ideation Relay Race,"Rapid-fire idea building under time pressure creates urgency and breakthroughs - structure with 30-second additions, quick building on ideas, and fast passing to maintain creative momentum and prevent overthinking"
creative,What If Scenarios,"Explore radical possibilities by questioning all constraints and assumptions - perfect for breaking through stuck thinking using prompts like 'What if we had unlimited resources?' 'What if the opposite were true?' or 'What if this problem didn't exist?'"
creative,Analogical Thinking,"Find creative solutions by drawing parallels to other domains - transfer successful patterns by asking 'This is like what?' 'How is this similar to...' and 'What other examples come to mind?' to connect to existing solutions"
creative,Reversal Inversion,"Deliberately flip problems upside down to reveal hidden assumptions and fresh angles - great when conventional approaches fail by asking 'What if we did the opposite?' 'How could we make this worse?' and 'What's the reverse approach?'"
creative,First Principles Thinking,"Strip away assumptions to rebuild from fundamental truths - essential for breakthrough innovation by asking 'What do we know for certain?' 'What are the fundamental truths?' and 'If we started from scratch?'"
creative,Forced Relationships,"Connect unrelated concepts to spark innovative bridges through creative collision - take two unrelated things, find connections between them, identify bridges, and explore how they could work together to generate unexpected solutions"
creative,Time Shifting,"Explore solutions across different time periods to reveal constraints and opportunities by asking 'How would this work in the past?' 'What about 100 years from now?' 'Different era constraints?' and 'What time-based solutions apply?'"
creative,Metaphor Mapping,"Use extended metaphors as thinking tools to explore problems from new angles - transforms abstract challenges into tangible narratives by asking 'This problem is like a metaphor,' extending the metaphor, and mapping elements to discover insights"
creative,Cross-Pollination,"Transfer solutions from completely different industries or domains to spark breakthrough innovations by asking how industry X would solve this, what patterns work in field Y, and how to adapt solutions from domain Z"
creative,Concept Blending,"Merge two or more existing concepts to create entirely new categories - goes beyond simple combination to genuine innovation by asking what emerges when concepts merge, what new category is created, and how the blend transcends original ideas"
creative,Reverse Brainstorming,"Generate problems instead of solutions to identify hidden opportunities and unexpected pathways by asking 'What could go wrong?' 'How could we make this fail?' and 'What problems could we create?' to reveal solution insights"
creative,Sensory Exploration,"Engage all five senses to discover multi-dimensional solution spaces beyond purely analytical thinking by asking what ideas feel, smell, taste, or sound like, and how different senses engage with the problem space"
deep,Five Whys,"Drill down through layers of causation to uncover root causes - essential for solving problems at source rather than symptoms by asking 'Why did this happen?' repeatedly until reaching fundamental drivers and ultimate causes"
deep,Morphological Analysis,"Systematically explore all possible parameter combinations for complex systems requiring comprehensive solution mapping - identify key parameters, list options for each, try different combinations, and identify emerging patterns"
deep,Provocation Technique,"Use deliberately provocative statements to extract useful ideas from seemingly absurd starting points - catalyzes breakthrough thinking by asking 'What if provocative statement?' 'How could this be useful?' 'What idea triggers?' and 'Extract the principle'"
deep,Assumption Reversal,"Challenge and flip core assumptions to rebuild from new foundations - essential for paradigm shifts by asking 'What assumptions are we making?' 'What if the opposite were true?' 'Challenge each assumption' and 'Rebuild from new assumptions'"
deep,Question Storming,"Generate questions before seeking answers to properly define problem space - ensures solving the right problem by asking only questions, no answers yet, focusing on what we don't know, and identifying what we should be asking"
deep,Constraint Mapping,"Identify and visualize all constraints to find promising pathways around or through limitations - ask what all constraints exist, which are real vs imagined, and how to work around or eliminate barriers to solution space"
deep,Failure Analysis,"Study successful failures to extract valuable insights and avoid common pitfalls - learns from what didn't work by asking what went wrong, why it failed, what lessons emerged, and how to apply failure wisdom to current challenges"
deep,Emergent Thinking,"Allow solutions to emerge organically without forcing linear progression - embraces complexity and natural development by asking what patterns emerge, what wants to happen naturally, and what's trying to emerge from the system"
introspective_delight,Inner Child Conference,"Channel pure childhood curiosity and wonder to rekindle playful exploration - ask what 7-year-old you would ask, use 'why why why' questioning, make it fun again, and forbid boring thinking to access innocent questioning that cuts through adult complications"
introspective_delight,Shadow Work Mining,"Explore what you're actively avoiding or resisting to uncover hidden insights - examine unconscious blocks and resistance patterns by asking what you're avoiding, where's resistance, what scares you, and mining the shadows for buried wisdom"
introspective_delight,Values Archaeology,"Excavate deep personal values driving decisions to clarify authentic priorities - dig to bedrock motivations by asking what really matters, why you care, what's non-negotiable, and what core values guide your choices"
introspective_delight,Future Self Interview,"Seek wisdom from wiser future self for long-term perspective - gain temporal self-mentoring by asking your 80-year-old self what they'd tell younger you, how future wisdom speaks, and what long-term perspective reveals"
introspective_delight,Body Wisdom Dialogue,"Let physical sensations and gut feelings guide ideation - tap somatic intelligence often ignored by mental approaches by asking what your body says, where you feel it, trusting tension, and following physical cues for embodied wisdom"
introspective_delight,Permission Giving,"Grant explicit permission to think impossible thoughts and break self-imposed creative barriers - give yourself permission to explore, try, experiment, and break free from limitations that constrain authentic creative expression"
structured,SCAMPER Method,"Systematic creativity through seven lenses for methodical product improvement and innovation - Substitute (what could you substitute), Combine (what could you combine), Adapt (how could you adapt), Modify (what could you modify), Put to other uses, Eliminate, Reverse"
structured,Six Thinking Hats,"Explore problems through six distinct perspectives without conflict - White Hat (facts), Red Hat (emotions), Yellow Hat (benefits), Black Hat (risks), Green Hat (creativity), Blue Hat (process) to ensure comprehensive analysis from all angles"
structured,Mind Mapping,"Visually branch ideas from central concept to discover connections and expand thinking - perfect for organizing complex thoughts and seeing big picture by putting main idea in center, branching concepts, and identifying sub-branches"
structured,Resource Constraints,"Generate innovative solutions by imposing extreme limitations - forces essential priorities and creative efficiency under pressure by asking what if you had only $1, no technology, one hour to solve, or minimal resources only"
structured,Decision Tree Mapping,"Map out all possible decision paths and outcomes to reveal hidden opportunities and risks - visualizes complex choice architectures by identifying possible paths, decision points, and where different choices lead"
structured,Solution Matrix,"Create systematic grid of problem variables and solution approaches to find optimal combinations and discover gaps - identify key variables, solution approaches, test combinations, and identify most effective pairings"
structured,Trait Transfer,"Borrow attributes from successful solutions in unrelated domains to enhance approach - systematically adapts winning characteristics by asking what traits make success X work, how to transfer these traits, and what they'd look like here"
theatrical,Time Travel Talk Show,"Interview past/present/future selves for temporal wisdom - playful method for gaining perspective across different life stages by interviewing past self, asking what future you'd say, and exploring different timeline perspectives"
theatrical,Alien Anthropologist,"Examine familiar problems through completely foreign eyes - reveals hidden assumptions by adopting outsider's bewildered perspective by becoming alien observer, asking what seems strange, and getting outside perspective insights"
theatrical,Dream Fusion Laboratory,"Start with impossible fantasy solutions then reverse-engineer practical steps - makes ambitious thinking actionable through backwards design by dreaming impossible solutions, working backwards to reality, and identifying bridging steps"
theatrical,Emotion Orchestra,"Let different emotions lead separate brainstorming sessions then harmonize - uses emotional intelligence for comprehensive perspective by exploring angry perspectives, joyful approaches, fearful considerations, hopeful solutions, then harmonizing all voices"
theatrical,Parallel Universe Cafe,"Explore solutions under alternative reality rules - breaks conventional thinking by changing fundamental assumptions about how things work by exploring different physics universes, alternative social norms, changed historical events, and reality rule variations"
theatrical,Persona Journey,"Embody different archetypes or personas to access diverse wisdom through character exploration - become the archetype, ask how persona would solve this, and explore what character sees that normal thinking misses"
wild,Chaos Engineering,"Deliberately break things to discover robust solutions - builds anti-fragility by stress-testing ideas against worst-case scenarios by asking what if everything went wrong, breaking on purpose, how it fails gracefully, and building from rubble"
wild,Guerrilla Gardening Ideas,"Plant unexpected solutions in unlikely places - uses surprise and unconventional placement for stealth innovation by asking where's the least expected place, planting ideas secretly, growing solutions underground, and implementing with surprise"
wild,Pirate Code Brainstorm,"Take what works from anywhere and remix without permission - encourages rule-bending rapid prototyping and maverick thinking by asking what pirates would steal, remixing without asking, taking best and running, and needing no permission"
wild,Zombie Apocalypse Planning,"Design solutions for extreme survival scenarios - strips away all but essential functions to find core value by asking what happens when society collapses, what basics work, building from nothing, and thinking in survival mode"
wild,Drunk History Retelling,"Explain complex ideas with uninhibited simplicity - removes overthinking barriers to find raw truth through simplified expression by explaining like you're tipsy, using no filter, sharing raw thoughts, and simplifying to absurdity"
wild,Anti-Solution,"Generate ways to make the problem worse or more interesting - reveals hidden assumptions through destructive creativity by asking how to sabotage this, what would make it fail spectacularly, and how to create more problems to find solution insights"
wild,Quantum Superposition,"Hold multiple contradictory solutions simultaneously until best emerges through observation and testing - explores how all solutions could be true simultaneously, how contradictions coexist, and what happens when outcomes are observed"
wild,Elemental Forces,"Imagine solutions being sculpted by natural elements to tap into primal creative energies - explore how earth would sculpt this, what fire would forge, how water flows through this, and what air reveals to access elemental wisdom"
biomimetic,Nature's Solutions,"Study how nature solves similar problems and adapt biological strategies to challenge - ask how nature would solve this, what ecosystems provide parallels, and what biological strategies apply to access 3.8 billion years of evolutionary wisdom"
biomimetic,Ecosystem Thinking,"Analyze problem as ecosystem to identify symbiotic relationships, natural succession, and ecological principles - explore symbiotic relationships, natural succession application, and ecological principles for systems thinking"
biomimetic,Evolutionary Pressure,"Apply evolutionary principles to gradually improve solutions through selective pressure and adaptation - ask how evolution would optimize this, what selective pressures apply, and how this adapts over time to harness natural selection wisdom"
quantum,Observer Effect,"Recognize how observing and measuring solutions changes their behavior - uses quantum principles for innovation by asking how observing changes this, what measurement effects matter, and how to use observer effect advantageously"
quantum,Entanglement Thinking,"Explore how different solution elements might be connected regardless of distance - reveals hidden relationships by asking what elements are entangled, how distant parts affect each other, and what hidden connections exist between solution components"
quantum,Superposition Collapse,"Hold multiple potential solutions simultaneously until constraints force single optimal outcome - leverages quantum decision theory by asking what if all options were possible, what constraints force collapse, and which solution emerges when observed"
cultural,Indigenous Wisdom,"Draw upon traditional knowledge systems and indigenous approaches overlooked by modern thinking - ask how specific cultures would approach this, what traditional knowledge applies, and what ancestral wisdom guides us to access overlooked problem-solving methods"
cultural,Fusion Cuisine,"Mix cultural approaches and perspectives like fusion cuisine - creates innovation through cultural cross-pollination by asking what happens when mixing culture A with culture B, what cultural hybrids emerge, and what fusion creates"
cultural,Ritual Innovation,"Apply ritual design principles to create transformative experiences and solutions - uses anthropological insights for human-centered design by asking what ritual would transform this, how to make it ceremonial, and what transformation this needs"
cultural,Mythic Frameworks,"Use myths and archetypal stories as frameworks for understanding and solving problems - taps into collective unconscious by asking what myth parallels this, what archetypes are involved, and how mythic structure informs solution"
1 category technique_name description
2 collaborative Yes And Building Build momentum through positive additions where each idea becomes a launching pad - use prompts like 'Yes and we could also...' or 'Building on that idea...' to create energetic collaborative flow that builds upon previous contributions
3 collaborative Brain Writing Round Robin Silent idea generation followed by building on others' written concepts - gives quieter voices equal contribution while maintaining documentation through the sequence of writing silently, passing ideas, and building on received concepts
4 collaborative Random Stimulation Use random words/images as creative catalysts to force unexpected connections - breaks through mental blocks with serendipitous inspiration by asking how random elements relate, what connections exist, and forcing relationships
5 collaborative Role Playing Generate solutions from multiple stakeholder perspectives to build empathy while ensuring comprehensive consideration - embody different roles by asking what they want, how they'd approach problems, and what matters most to them
6 collaborative Ideation Relay Race Rapid-fire idea building under time pressure creates urgency and breakthroughs - structure with 30-second additions, quick building on ideas, and fast passing to maintain creative momentum and prevent overthinking
7 creative What If Scenarios Explore radical possibilities by questioning all constraints and assumptions - perfect for breaking through stuck thinking using prompts like 'What if we had unlimited resources?' 'What if the opposite were true?' or 'What if this problem didn't exist?'
8 creative Analogical Thinking Find creative solutions by drawing parallels to other domains - transfer successful patterns by asking 'This is like what?' 'How is this similar to...' and 'What other examples come to mind?' to connect to existing solutions
9 creative Reversal Inversion Deliberately flip problems upside down to reveal hidden assumptions and fresh angles - great when conventional approaches fail by asking 'What if we did the opposite?' 'How could we make this worse?' and 'What's the reverse approach?'
10 creative First Principles Thinking Strip away assumptions to rebuild from fundamental truths - essential for breakthrough innovation by asking 'What do we know for certain?' 'What are the fundamental truths?' and 'If we started from scratch?'
11 creative Forced Relationships Connect unrelated concepts to spark innovative bridges through creative collision - take two unrelated things, find connections between them, identify bridges, and explore how they could work together to generate unexpected solutions
12 creative Time Shifting Explore solutions across different time periods to reveal constraints and opportunities by asking 'How would this work in the past?' 'What about 100 years from now?' 'Different era constraints?' and 'What time-based solutions apply?'
13 creative Metaphor Mapping Use extended metaphors as thinking tools to explore problems from new angles - transforms abstract challenges into tangible narratives by asking 'This problem is like a metaphor,' extending the metaphor, and mapping elements to discover insights
14 creative Cross-Pollination Transfer solutions from completely different industries or domains to spark breakthrough innovations by asking how industry X would solve this, what patterns work in field Y, and how to adapt solutions from domain Z
15 creative Concept Blending Merge two or more existing concepts to create entirely new categories - goes beyond simple combination to genuine innovation by asking what emerges when concepts merge, what new category is created, and how the blend transcends original ideas
16 creative Reverse Brainstorming Generate problems instead of solutions to identify hidden opportunities and unexpected pathways by asking 'What could go wrong?' 'How could we make this fail?' and 'What problems could we create?' to reveal solution insights
17 creative Sensory Exploration Engage all five senses to discover multi-dimensional solution spaces beyond purely analytical thinking by asking what ideas feel, smell, taste, or sound like, and how different senses engage with the problem space
18 deep Five Whys Drill down through layers of causation to uncover root causes - essential for solving problems at source rather than symptoms by asking 'Why did this happen?' repeatedly until reaching fundamental drivers and ultimate causes
19 deep Morphological Analysis Systematically explore all possible parameter combinations for complex systems requiring comprehensive solution mapping - identify key parameters, list options for each, try different combinations, and identify emerging patterns
20 deep Provocation Technique Use deliberately provocative statements to extract useful ideas from seemingly absurd starting points - catalyzes breakthrough thinking by asking 'What if provocative statement?' 'How could this be useful?' 'What idea triggers?' and 'Extract the principle'
21 deep Assumption Reversal Challenge and flip core assumptions to rebuild from new foundations - essential for paradigm shifts by asking 'What assumptions are we making?' 'What if the opposite were true?' 'Challenge each assumption' and 'Rebuild from new assumptions'
22 deep Question Storming Generate questions before seeking answers to properly define problem space - ensures solving the right problem by asking only questions, no answers yet, focusing on what we don't know, and identifying what we should be asking
23 deep Constraint Mapping Identify and visualize all constraints to find promising pathways around or through limitations - ask what all constraints exist, which are real vs imagined, and how to work around or eliminate barriers to solution space
24 deep Failure Analysis Study successful failures to extract valuable insights and avoid common pitfalls - learns from what didn't work by asking what went wrong, why it failed, what lessons emerged, and how to apply failure wisdom to current challenges
25 deep Emergent Thinking Allow solutions to emerge organically without forcing linear progression - embraces complexity and natural development by asking what patterns emerge, what wants to happen naturally, and what's trying to emerge from the system
26 introspective_delight Inner Child Conference Channel pure childhood curiosity and wonder to rekindle playful exploration - ask what 7-year-old you would ask, use 'why why why' questioning, make it fun again, and forbid boring thinking to access innocent questioning that cuts through adult complications
27 introspective_delight Shadow Work Mining Explore what you're actively avoiding or resisting to uncover hidden insights - examine unconscious blocks and resistance patterns by asking what you're avoiding, where's resistance, what scares you, and mining the shadows for buried wisdom
28 introspective_delight Values Archaeology Excavate deep personal values driving decisions to clarify authentic priorities - dig to bedrock motivations by asking what really matters, why you care, what's non-negotiable, and what core values guide your choices
29 introspective_delight Future Self Interview Seek wisdom from wiser future self for long-term perspective - gain temporal self-mentoring by asking your 80-year-old self what they'd tell younger you, how future wisdom speaks, and what long-term perspective reveals
30 introspective_delight Body Wisdom Dialogue Let physical sensations and gut feelings guide ideation - tap somatic intelligence often ignored by mental approaches by asking what your body says, where you feel it, trusting tension, and following physical cues for embodied wisdom
31 introspective_delight Permission Giving Grant explicit permission to think impossible thoughts and break self-imposed creative barriers - give yourself permission to explore, try, experiment, and break free from limitations that constrain authentic creative expression
32 structured SCAMPER Method Systematic creativity through seven lenses for methodical product improvement and innovation - Substitute (what could you substitute), Combine (what could you combine), Adapt (how could you adapt), Modify (what could you modify), Put to other uses, Eliminate, Reverse
33 structured Six Thinking Hats Explore problems through six distinct perspectives without conflict - White Hat (facts), Red Hat (emotions), Yellow Hat (benefits), Black Hat (risks), Green Hat (creativity), Blue Hat (process) to ensure comprehensive analysis from all angles
34 structured Mind Mapping Visually branch ideas from central concept to discover connections and expand thinking - perfect for organizing complex thoughts and seeing big picture by putting main idea in center, branching concepts, and identifying sub-branches
35 structured Resource Constraints Generate innovative solutions by imposing extreme limitations - forces essential priorities and creative efficiency under pressure by asking what if you had only $1, no technology, one hour to solve, or minimal resources only
36 structured Decision Tree Mapping Map out all possible decision paths and outcomes to reveal hidden opportunities and risks - visualizes complex choice architectures by identifying possible paths, decision points, and where different choices lead
37 structured Solution Matrix Create systematic grid of problem variables and solution approaches to find optimal combinations and discover gaps - identify key variables, solution approaches, test combinations, and identify most effective pairings
38 structured Trait Transfer Borrow attributes from successful solutions in unrelated domains to enhance approach - systematically adapts winning characteristics by asking what traits make success X work, how to transfer these traits, and what they'd look like here
39 theatrical Time Travel Talk Show Interview past/present/future selves for temporal wisdom - playful method for gaining perspective across different life stages by interviewing past self, asking what future you'd say, and exploring different timeline perspectives
40 theatrical Alien Anthropologist Examine familiar problems through completely foreign eyes - reveals hidden assumptions by adopting outsider's bewildered perspective by becoming alien observer, asking what seems strange, and getting outside perspective insights
41 theatrical Dream Fusion Laboratory Start with impossible fantasy solutions then reverse-engineer practical steps - makes ambitious thinking actionable through backwards design by dreaming impossible solutions, working backwards to reality, and identifying bridging steps
42 theatrical Emotion Orchestra Let different emotions lead separate brainstorming sessions then harmonize - uses emotional intelligence for comprehensive perspective by exploring angry perspectives, joyful approaches, fearful considerations, hopeful solutions, then harmonizing all voices
43 theatrical Parallel Universe Cafe Explore solutions under alternative reality rules - breaks conventional thinking by changing fundamental assumptions about how things work by exploring different physics universes, alternative social norms, changed historical events, and reality rule variations
44 theatrical Persona Journey Embody different archetypes or personas to access diverse wisdom through character exploration - become the archetype, ask how persona would solve this, and explore what character sees that normal thinking misses
45 wild Chaos Engineering Deliberately break things to discover robust solutions - builds anti-fragility by stress-testing ideas against worst-case scenarios by asking what if everything went wrong, breaking on purpose, how it fails gracefully, and building from rubble
46 wild Guerrilla Gardening Ideas Plant unexpected solutions in unlikely places - uses surprise and unconventional placement for stealth innovation by asking where's the least expected place, planting ideas secretly, growing solutions underground, and implementing with surprise
47 wild Pirate Code Brainstorm Take what works from anywhere and remix without permission - encourages rule-bending rapid prototyping and maverick thinking by asking what pirates would steal, remixing without asking, taking best and running, and needing no permission
48 wild Zombie Apocalypse Planning Design solutions for extreme survival scenarios - strips away all but essential functions to find core value by asking what happens when society collapses, what basics work, building from nothing, and thinking in survival mode
49 wild Drunk History Retelling Explain complex ideas with uninhibited simplicity - removes overthinking barriers to find raw truth through simplified expression by explaining like you're tipsy, using no filter, sharing raw thoughts, and simplifying to absurdity
50 wild Anti-Solution Generate ways to make the problem worse or more interesting - reveals hidden assumptions through destructive creativity by asking how to sabotage this, what would make it fail spectacularly, and how to create more problems to find solution insights
51 wild Quantum Superposition Hold multiple contradictory solutions simultaneously until best emerges through observation and testing - explores how all solutions could be true simultaneously, how contradictions coexist, and what happens when outcomes are observed
52 wild Elemental Forces Imagine solutions being sculpted by natural elements to tap into primal creative energies - explore how earth would sculpt this, what fire would forge, how water flows through this, and what air reveals to access elemental wisdom
53 biomimetic Nature's Solutions Study how nature solves similar problems and adapt biological strategies to challenge - ask how nature would solve this, what ecosystems provide parallels, and what biological strategies apply to access 3.8 billion years of evolutionary wisdom
54 biomimetic Ecosystem Thinking Analyze problem as ecosystem to identify symbiotic relationships, natural succession, and ecological principles - explore symbiotic relationships, natural succession application, and ecological principles for systems thinking
55 biomimetic Evolutionary Pressure Apply evolutionary principles to gradually improve solutions through selective pressure and adaptation - ask how evolution would optimize this, what selective pressures apply, and how this adapts over time to harness natural selection wisdom
56 quantum Observer Effect Recognize how observing and measuring solutions changes their behavior - uses quantum principles for innovation by asking how observing changes this, what measurement effects matter, and how to use observer effect advantageously
57 quantum Entanglement Thinking Explore how different solution elements might be connected regardless of distance - reveals hidden relationships by asking what elements are entangled, how distant parts affect each other, and what hidden connections exist between solution components
58 quantum Superposition Collapse Hold multiple potential solutions simultaneously until constraints force single optimal outcome - leverages quantum decision theory by asking what if all options were possible, what constraints force collapse, and which solution emerges when observed
59 cultural Indigenous Wisdom Draw upon traditional knowledge systems and indigenous approaches overlooked by modern thinking - ask how specific cultures would approach this, what traditional knowledge applies, and what ancestral wisdom guides us to access overlooked problem-solving methods
60 cultural Fusion Cuisine Mix cultural approaches and perspectives like fusion cuisine - creates innovation through cultural cross-pollination by asking what happens when mixing culture A with culture B, what cultural hybrids emerge, and what fusion creates
61 cultural Ritual Innovation Apply ritual design principles to create transformative experiences and solutions - uses anthropological insights for human-centered design by asking what ritual would transform this, how to make it ceremonial, and what transformation this needs
62 cultural Mythic Frameworks Use myths and archetypal stories as frameworks for understanding and solving problems - taps into collective unconscious by asking what myth parallels this, what archetypes are involved, and how mythic structure informs solution

84
src/core-skills/bmad-brainstorming/customize.toml Normal file
View File

@ -0,0 +1,84 @@
# DO NOT EDIT -- overwritten on every update.
#
# Workflow customization surface for bmad-brainstorming.
#
# Override files (not edited here):
# {project-root}/_bmad/custom/bmad-brainstorming.toml (team)
# {project-root}/_bmad/custom/bmad-brainstorming.user.toml (personal)
[workflow]
# --- Configurable below. Overrides merge per BMad structural rules: ---
# scalars: override wins • arrays: append
# Steps to run before the standard activation (config load, greet).
# Use for pre-flight loads, compliance checks, etc.
activation_steps_prepend = []
# Steps to run after greet but before facilitation begins.
# Use for context-heavy setup that should happen once the user has been acknowledged.
activation_steps_append = []
# Persistent facts the facilitator keeps in mind for the whole session
# (domain constraints, house rules, stylistic guardrails). Each entry is a
# literal sentence, a skill prefixed with `skill:`, or a `file:`-prefixed
# path/glob whose contents are loaded as facts. Default loads project-context.md
# if bmad-generate-project-context has produced one, giving the facilitator
# persistent awareness of the project's domain without re-asking.
persistent_facts = [
"file:{project-root}/**/project-context.md",
]
# The technique library loaded on demand during the session. Swap the path in
# team/user TOML to ship a different or extended catalog of creative methods.
# Kept `{skill-root}`-anchored so it resolves regardless of the working directory
# (brain.py is always invoked with `--file {workflow.brain_methods}`).
brain_methods = "{skill-root}/assets/brain-methods.csv"
# Techniques the facilitator should reach for first. When proposing a method
# (the AI-led default), it prefers these where they fit the goal before ranging
# wider. Names should match an entry in the library or in additional_techniques.
# Append-merges, so a team list and a personal list both contribute. Empty = no
# preference; the facilitator chooses purely on fit.
#
# Example (set in team/user override TOML):
# favorite_techniques = ["SCAMPER", "Six Thinking Hats", "First Principles"]
favorite_techniques = []
# Extra techniques — and whole new categories — merged into the catalog the
# facilitator chooses from, without editing the shipped CSV. Each entry mirrors
# the library's shape (category, technique_name, description); a new category is
# just a category value the CSV doesn't have. Entries append, so teams and users
# can each grow the library. The facilitator treats these as first-class
# alongside brain_methods across every flow — facilitator-chosen, browse,
# category draws, and inventive.
#
# Example (set in team/user override TOML):
# [[workflow.additional_techniques]]
# category = "domain-specific"
# technique_name = "Regulatory Inversion"
# description = "Start from the compliance constraint and brainstorm what becomes possible only because of it — turn the rule into a generative frame rather than a limit."
additional_techniques = []
# Session output location. The running log and any final artifacts land inside
# `{output_dir}/{output_folder_name}/`. `{topic_slug}` is filled from the session
# topic so each topic gets its own folder — a user can brainstorm several topics
# without collision. The resume check globs `{output_dir}/*/.memlog.md`.
output_dir = "{output_folder}/brainstorming"
output_folder_name = "brainstorm-{topic_slug}-{date}"
# Executed when the session completes (after artifacts are produced and the user
# has the paths). Accepts a string scalar (single instruction) or an array of
# instructions executed in order. Empty for none.
on_complete = ""
# External-handoff routing. Natural-language directives applied after artifacts
# are produced, to route them beyond local files (Confluence, Notion, Drive,
# etc.). Each entry names the MCP tool, the destination, and the fields it needs.
# URLs/IDs returned are surfaced to the user. If a named tool is unavailable at
# runtime, the handoff is skipped and flagged; local files always exist. Empty
# by default.
#
# Example (set in team/user override TOML):
# "After artifacts are produced, upload brainstorm.html to Confluence via corp:confluence_upload (space_key='IDEAS', parent_page='Brainstorms', author={user_name})."
external_handoffs = []

24
src/core-skills/bmad-brainstorming/references/converge.md Normal file
View File

@ -0,0 +1,24 @@
# Converging: Narrow & Decide
Load this when divergence is spent and the user wants to narrow the field — or asks to "decide," "prioritize," "pick," or "make it real." The whole catalog is *divergent* by design (it generates); this is the deliberate opposite phase, and keeping the two apart is the point. Never run convergence while ideas are still flowing, and never let it leak into a generating batch — premature judgment is what kills good ideas. `{doc_workspace}/.memlog.md` is the canonical record; everything here works from it. Communicate in `{communication_language}`.
**Mode holds.** In **Facilitator** you run the convergence *on the user's verdicts* — you structure and prompt, they judge; never rank for them. In **Creative Partner** you weigh in too, each call logged by author. In **Ideate for me** you converge yourself and show the result, then offer to keep going.
## How to run it
First, reflect the field back: pull the live candidates from the memlog (include the odd and buried ones, not just the recent obvious ones) so there's a concrete set to work on. Then pick **one** convergence move that fits the goal — don't hand the user a menu of methods; choose the one that suits *this* decision and name it. Run it to a result, log the outcome, and stop when a clear short-list or single direction emerges.
Pick by what the decision needs:
- **Affinity Clustering** — when there are many scattered ideas: group them into themes, name each cluster, and surface the through-line. Often the right *first* move, to turn a pile into a handful.
- **Impact–Effort** — when the goal is action: place each candidate on impact vs effort; harvest high-impact / low-effort first, park the rest.
- **NUF Test** — when novelty matters: score each New, Useful, Feasible (1–10 each); the totals expose the quiet winners and the dazzling-but-doomed.
- **Forced Ranking / Dot Vote** — when you just need a ranked top-N: make the ideas compete, no ties; (a literal dot-vote when it's genuinely a group).
- **PMI (Plus / Minus / Interesting)** — when one strong candidate needs pressure-testing before commitment: list its pluses, minuses, and the merely-interesting, then judge.
- **MoSCoW** — when scoping a build: sort into Must / Should / Could / Won't-this-time.
Log the surviving directions and the reasoning with `python3 {skill-root}/scripts/memlog.py append --type decision --text "<one-line gist>"` (use `--by` in Creative Partner mode). Two or three convergence moves chained is fine (e.g. cluster → score the clusters); more than that is usually over-processing.
## Then finalize
Once a short-list or direction is settled, **load `references/finalize.md`** and run it last — synthesis, `status: complete`, and artifacts build on the decisions you just logged. Convergence narrows; finalize captures and ships. Do not set `status: complete` here — that belongs to finalize.

26
src/core-skills/bmad-brainstorming/references/finalize.md Normal file
View File

@ -0,0 +1,26 @@
# Wrap-Up: Synthesis & Artifacts
Load this when the user signals they're spent or the topic is mined out. `{doc_workspace}/.memlog.md` is the canonical record of the session — everything here derives from it. Communicate in `{communication_language}`; write any document content in `{document_output_language}`.
## Synthesis
In Facilitator mode this is the one place your own creative contribution is welcome; in Creative Partner and Ideate-for-me you've been contributing all along, so just keep going. Run it in two moves, in order:
1. **Hand them the mirror first.** Reflect a vivid sampling of *their* ideas back — deliberately include the odd, random, or buried ones from earlier, not just the recent obvious ones (in Creative Partner mode the `(... by user)` tags tell you which were theirs). Ask what they see now: conclusions, synergies, themes, the few that actually matter. Let them connect first; their own pattern-recognition is the point.
2. **Then add the connections they would miss.** Lean in creatively — not new raw ideas, but the non-obvious links: this idea from technique one quietly solves that tension from technique four; these three are one idea wearing three hats; this wildcard is the real breakthrough.
Record the insights and chosen directions with `memlog.py append --type insight`. **Then run `python3 {skill-root}/scripts/memlog.py set --workspace {doc_workspace} --key status --value complete`** — the session is done and must stop being offered for resume. Do this even if the user declines every artifact below.
## Artifacts
In **Ideate for me** (and headless), the imaginative HTML keepsake is the deliverable you promised — produce it automatically, no asking; the other artifacts below stay opt-in. In **Facilitator** and **Creative Partner**, every artifact is opt-in: each is a fresh, token-expensive generation, so ask what they want, recommend the HTML keepsake as the default, and generate only what they choose. Everything derives from the log, so nothing is lost by deferring or skipping.
**Delegate each artifact to a subagent.** By now the main context is full of the whole session — but the memlog holds everything, so the subagent doesn't need that context. Spawn one per requested artifact, telling it only: the spec below, the memlog path `{doc_workspace}/.memlog.md` (its sole source — read it in full), the output path, `{document_output_language}`, and "return ONLY the written file path." This keeps the heavy generation out of the main thread and proves the memlog is genuinely the canonical source. (Subagents can't spawn subagents — run these from here.)
- **Imaginative HTML keepsake (recommended default).** A single self-contained `brainstorm.html` in `{doc_workspace}` — a genuine creative artifact, not a report poured into a template. There is no template on purpose: let *this* session's subject, energy, and whimsy drive the visual language (a children's game and a supply-chain session should not look alike). Give each technique its own treatment, invent visualizations that fit the ideas and techniques, and render the synthesis as the climax. Inline all CSS and any JS; no external dependencies. Open it once complete.
- **Intent doc.** A succinct `brainstorm-intent.md` — the chosen and critical discoveries only, structured to drop straight into a downstream skill (`bmad-product-brief`, `bmad-prd`) as clean input, with none of the report's bloat - token usage matters and it must really be on point. Confirm what the user wants to capture as the intent from the overall findings as there may be many divergent discoveries (unless in headless mode, then take your best educated stance).
- **Offer other options they might want from it also based on context** — a pitch, a one-pager, a task list — produced from the same source. These can be slide decks, html, markdown - again be creative and offer really interesting quality options based on perceived user needs while asking them also to offer any other ideas.
If the session used invented techniques, offer to save a keeper into `{workflow.additional_techniques}` via `bmad-customize` user preferences.
After producing what they chose, offer them ideas for deep-dive brainstorming new sessions, offer to fully extrapolate any ideas into an html report (autonomously brainstorm on their behalf), and most importantly: execute each `{workflow.external_handoffs}` instruction. Then share the artifact paths (and any handoff destinations), invoke `bmad-help` to suggest where this leads next in the BMad ecosystem, let them know if they feel a produced intent is detailed enough they could jump right into passing it to bmad-spec or any other analysis tool (outlined from bmad-help) and run `{workflow.on_complete}` if non-empty.

54
src/core-skills/bmad-brainstorming/references/headless.md Normal file
View File

@ -0,0 +1,54 @@
# Headless Mode
Load this file ONLY when bmad-brainstorming is invoked headless. It is quarantined here on purpose: headless is the single context in which you generate ideas yourself, which is the exact inverse of the interactive Stance. Loading it in a normal session would corrupt the facilitation. Follow it for the whole run.
## Detection
**If a human is sending messages in this session, you are interactive — no payload shape or phrasing overrides that.** Headless requires the *absence* of an interactive user. It is in effect only when one of these unambiguous machine signals holds:
- the caller sets a `headless: true` flag (or the equivalent argument the harness exposes),
- the invocation comes from another skill or a non-interactive runner (no TTY, no user message stream),
- `{workflow.activation_steps_prepend}` includes an entry that explicitly declares headless.
When in doubt, you are interactive — a present human asking you to "brainstorm X and give me the HTML" is a normal interactive opening, not a headless trigger. Facilitate them; do not brainstorm for them.
## The inversion
There is no user to draw ideas out of, so you become the brainstormer. Run a real divergent session against the supplied topic: discover techniques with `python3 {skill-root}/scripts/brain.py --file {workflow.brain_methods} list --all` (the whole catalog is fine here — you are generating, not pacing a user; add `show "<name>"` for a technique's full method on demand), plus any `{workflow.additional_techniques}`, preferring `{workflow.favorite_techniques}` where they fit; work them, and **shift the creative domain every ~10 ideas** exactly as the interactive Stance demands — technical, then experiential, then business, then failure modes, then wildcards. Push past the obvious; the same quantity ambition (aim past 100) and anti-clustering discipline apply. The only thing that changes is that the ideas are now yours to generate. This relaxation is scoped entirely to this file — it never applies to interactive sessions.
## Inputs the caller is expected to provide
Free-form structured payload in the first message; provide what applies:
- `topic` — what to brainstorm. Required. If absent and uninferable, halt `blocked`.
- `goal` — desired outcome / framing, if any.
- `techniques` — specific methods to use; otherwise you choose fitting ones from the library.
- `context` — file paths or text to ground the session (problem statement, prior notes, brief).
- `doc_workspace` — a specific run folder; otherwise bind the default `{workflow.output_dir}/{workflow.output_folder_name}/`.
- `artifacts` — which outputs to produce: `html`, `intent`, or both. Default: both.
## Run
1. Bind `{doc_workspace}` and create the memlog with `python3 {skill-root}/scripts/memlog.py init --workspace {doc_workspace} --field topic="<topic>" [--field goal="<goal>"]`. It remains the canonical source every artifact derives from.
2. Run the divergent session per **The inversion**, capturing each idea with `memlog.py append --workspace {doc_workspace} --type idea --text "<idea>"` as it lands, and marking each technique switch with `memlog.py append --type technique --text "started <name>"`.
3. Synthesize: surface the conclusions, connections, and the few directions that matter; record them with `memlog.py append --type insight`, then run `memlog.py set --workspace {doc_workspace} --key status --value complete`.
4. Produce the requested artifacts from the log — `brainstorm.html` (the imaginative, self-contained, no-template report) and/or the succinct `brainstorm-intent.md` — the same artifacts `references/finalize.md` describes, delegating each to a subagent that reads the log as its sole source. (Headless produces the `artifacts` payload directly; it does not ask, unlike the interactive opt-in.)
5. Execute each entry in `{workflow.external_handoffs}` (capture returned URLs/IDs into the JSON `external_handoffs` array; skip and flag unavailable tools — local files always exist). Then run `{workflow.on_complete}` if non-empty.
Do not ask questions; do not greet. Record any assumption you made (a topic you had to infer, a goal you invented to frame the session) in `assumptions[]`.
## Return
End with a JSON status block. Use `complete` when the artifacts stand on their own, `partial` when produced but key inputs were inferred (e.g. topic was thin), `blocked` when no artifact was produced (e.g. no topic). Omit keys for artifacts not produced.
```json
{
"status": "complete",
"intent": "brainstorm",
"memlog": "{doc_workspace}/.memlog.md",
"html": "{doc_workspace}/brainstorm.html",
"intent_doc": "{doc_workspace}/brainstorm-intent.md",
"assumptions": [],
"external_handoffs": []
}
```

18
src/core-skills/bmad-brainstorming/references/in-chat-techniques.md Normal file
View File

@ -0,0 +1,18 @@
# Choosing Techniques In Chat
Loaded only when the user won't use the composer page (no browser, headless, or they declined). Here you pick the batch in conversation. **3–4 is the sweet spot.** Present the four ways below — this is the one allowed menu — and wait for their pick.
- **Facilitator Chosen (default)** — from the goal, your `{workflow.favorite_techniques}`, and the `categories` map, name a batch of 3–4. Confirm exact names with a targeted `list --category` on only the categories you're drawing from; never enumerate the library to choose.
- **Browse** — send them to the composer page after all (`## Run a Session` in `SKILL.md`); they tick techniques and paste the result back, which carries each one's full name/category/description.
- **Category** — the user names 1–n categories; `random --category` draws the batch from them. No listing needed.
- **Inventive Flow** — invent at least 3 techniques, announce the order before the first, touch no script. Log each one's name + description so you can offer to save a keeper to `{workflow.additional_techniques}` (via `bmad-customize`) at wrap-up.
The library is large — never pull it whole into context. The only way in is the helper, always passing `--file {workflow.brain_methods}`. Subcommands of `python3 {skill-root}/scripts/brain.py --file {workflow.brain_methods}`:
- `categories` — names + counts; the cheap survey map.
- `list --category X [--category Y]` — the index (name + gist) for those categories. Bare `list` is refused by the script.
- `random --category X [...] -n 4` — draw a batch blind, listing nothing.
- `show "<name>"` — one technique's full method; call only the moment it is about to run.
- `html --out <path>` — write the composer page to a file (the Browse option above).
Treat `{workflow.additional_techniques}` as first-class entries (including new categories), preferring `{workflow.favorite_techniques}` where they fit. To include the additional techniques in any command, pass `--extra <json>` (a JSON list of `{category, technique_name, description}` objects). The `list` gist usually suffices to propose and run a technique; reach for `show` for deeper mechanics.

10
src/core-skills/bmad-brainstorming/references/mode-autonomous.md Normal file
View File

@ -0,0 +1,10 @@
# Mode: Ideate For Me
The user handed you the topic and wants to see what you come up with on your own, then look at the result. You become the brainstormer — this is the one interactive mode where the ideas are yours to generate.
- **Run a real divergent session yourself.** Pick and run techniques on your own (use `brain.py` as in `## Choosing Techniques`, but *you* choose — no menu for the user), capturing each idea to the memlog with `--type idea --by coach`, marking each technique switch with a `technique` entry, shifting the creative domain every ~10 ideas, aiming past 100. Push past the obvious.
- **Don't pepper the user with questions** — this is your run. One quick confirm of topic and goal up front is plenty.
- **When it's mined out, synthesize and produce the keepsake.** Go to `## Wrap-Up` (`references/finalize.md`): record the insights, mark the memlog complete, and **auto-generate the imaginative HTML keepsake — don't ask first; the keepsake is the result you promised to show them.** Offer the other artifacts (intent doc, etc.) after.
- **Then, because a human is here, offer to keep going together.** They may want to push an idea further or react to what you found — if so, switch into **Facilitator** or **Creative Partner** (load that frame), **record the switch in the memlog** so a resume restores the new stance — `python3 {skill-root}/scripts/memlog.py set --workspace {doc_workspace} --key mode --value <facilitator|partner>` — and continue from the same memlog.
This is the interactive sibling of headless mode (`references/headless.md`): the same self-generation, but a person is present to receive the output and may continue. headless is the no-human, returns-JSON runner; this one greets, presents, and hands off.

11
src/core-skills/bmad-brainstorming/references/mode-facilitator.md Normal file
View File

@ -0,0 +1,11 @@
# Mode: Facilitator
You are a forcing function for the user's creativity, never a source of ideas. The best version of this session ends with the user surprised by what *they* came up with — every idea in the memlog is theirs.
- **You do not supply ideas.** Your moves are questions, provocations, constraints, and reflections that make *the user* generate, while you steer within the chosen technique. When the well looks dry, don't fill it — change the technique, shift the angle, or push harder.
- **The one exception:** if the user *directly asks* for an idea, give exactly one as a spark, then hand the pen back. Reaching for that repeatedly is the signal to change technique, not to keep feeding ideas.
- This holds for the whole generative session; it relaxes only during synthesis at wrap-up (`references/finalize.md`).
Every idea you log is the user's, so no attribution is needed — log with `--type idea` (no `--by`).
Go to `## Choosing Techniques`.

16
src/core-skills/bmad-brainstorming/references/mode-partner.md Normal file
View File

@ -0,0 +1,16 @@
# Mode: Creative Partner
You are still the facilitator — their creativity is the point, and they do the **majority** of the generating. But here you also play: you ride alongside and throw in your own ideas as sparks and yes-and fuel, so the two of you build a chain neither would alone. The energy is collaborative, not extractive — you feed off each other.
**Set it up first.** Before you start, tell the user how this mode works and that they stay in control: they can **reject any idea you offer, ask you to help more or less, and tell you how to brainstorm** — a technique to try, a tone, a direction to chase. You're a partner they can steer, not a script.
Hold the balance:
- **Their fire, your kindling.** After you offer an idea, hand the pen back with a question. Never run a string of your own while they go quiet.
- **"Yes, and" is the default move.** Take what they just said, build it one rung higher, then dare them to top you. Make them *want* to outdo you.
- **Offer real alternatives**, not leading questions — a genuine idea they can mutate or reject, an opening, never a conclusion.
- **Watch the ratio.** If you've contributed more than they have over the last few exchanges, you've slipped toward doing it *for* them — pull back to questions and constraints.
**Attribution is mandatory here.** Every idea entry records who it came from: `--by user` for theirs, `--by coach` for yours (e.g. `append --type idea --by coach --text "..."`). This keeps the record honest and lets the wrap-up hand *them* the mirror of what *they* generated.
Go to `## Choosing Techniques`.

5
src/core-skills/bmad-brainstorming/references/resume.md Normal file
View File

@ -0,0 +1,5 @@
# Resuming a Session
Read the chosen `{doc_workspace}/.memlog.md` **in full** — the one time you read the memlog. Frontmatter restores topic, goal, status, and **mode**: reload that mode's frame (`mode-facilitator.md` / `mode-partner.md` / `mode-autonomous.md`) and hold it again. The body restores everything generated — entries in order, `technique` entries marking which lens was active, `by` tags marking authorship.
Reconstruct the picture, then reflect back where things stand (topic, what's already mined, which threads felt live) to re-establish shared state before continuing. Then continue per the mode's frame (appending to the same memlog) — or, if they're ready to land it, go to Wrap-Up (`references/finalize.md`).

740
src/core-skills/bmad-brainstorming/scripts/brain.py Normal file
View File

@ -0,0 +1,740 @@
#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# ///
"""Serve the brainstorming technique library without loading it all into context.
The library is a CSV (category, technique_name, description, detail). `description`
is a short gist — enough to propose and run most techniques. `detail` is optional:
a path (relative to the CSV's directory) to a fuller instruction file for a technique
complex enough to warrant one. Only `show` resolves detail files, and only for the
technique asked for — so the heavy material never enters context until it is run.
Commands:
categories list category names + counts (the cheap entry point)
list --category C [...] the index (name + gist) for those categories
list --all the whole index at once — deliberate; large, avoid interactively
show NAME [NAME ...] full gist for each, inlining its detail file if it has one
random [--category C] [-n N] pick N at random (optionally within categories)
html --out PATH write the offline 'browse all' selection page to a file
`list` refuses to run with neither --category nor --all, and `html` writes to a file
rather than stdout: dumping the full catalog into context is a footgun, so reaching the
whole library at once must always be an explicit, deliberate choice.
`--extra PATH` merges a JSON overlay of additional techniques (customize.toml's
`additional_techniques`) into every command, so custom techniques and whole new
categories are first-class everywhere — including the browse page and category draws.
Default output is lean text for an LLM to read; pass --json for structured output.
"""
import argparse
import csv
import hashlib
import html
import json
import random
import sys
from pathlib import Path
DEFAULT_FILE = Path(__file__).resolve().parent.parent / "assets" / "brain-methods.csv"
FIELDS = ("category", "technique_name", "description", "detail", "provenance", "good_for", "audience")
# Optional columns beyond the original four — absent in older CSVs and in --extra
# overlays, so always read through .get/setdefault. `provenance` (classic|signature|
# playful) drives the "Proven & Professional" lead group; `good_for` (a |-separated
# list of goal tags) drives the browse page's goal filter; `audience` (solo|group|either)
# is advisory.
OPTIONAL_FIELDS = ("detail", "provenance", "good_for", "audience")
def load(file: Path) -> list[dict]:
with open(file, newline="", encoding="utf-8") as f:
rows = list(csv.DictReader(f))
for r in rows:
for k in OPTIONAL_FIELDS:
r.setdefault(k, "")
r[k] = (r.get(k) or "").strip()
return rows
def load_extra(file: Path) -> list[dict]:
"""Merge-in techniques from a JSON overlay — a list of
{category, technique_name, description[, detail]} objects. This is how
customize.toml's `additional_techniques` become first-class across *every*
subcommand (categories/list/random/show/html), so the browse page and
category draws include them too, not just the in-chat flows."""
data = json.loads(file.read_text(encoding="utf-8"))
rows = []
for item in data:
rows.append({
"category": str(item.get("category", "")).strip(),
"technique_name": str(item.get("technique_name", "")).strip(),
"description": str(item.get("description", "")).strip(),
"detail": str(item.get("detail") or "").strip(),
"provenance": str(item.get("provenance") or "").strip(),
"good_for": str(item.get("good_for") or "").strip(),
"audience": str(item.get("audience") or "").strip(),
})
return rows
def categories(rows: list[dict]) -> list[tuple[str, int]]:
counts: dict[str, int] = {}
for r in rows:
counts[r["category"]] = counts.get(r["category"], 0) + 1
return sorted(counts.items())
def filter_cats(rows: list[dict], cats: list[str] | None) -> list[dict]:
if not cats:
return rows
wanted = {c.lower() for c in cats}
return [r for r in rows if r["category"].lower() in wanted]
def find(rows: list[dict], names: list[str]) -> tuple[list[dict], list[str]]:
by_name = {r["technique_name"].lower(): r for r in rows}
found, missing = [], []
for n in names:
r = by_name.get(n.strip().lower())
(found if r else missing).append(r if r else n)
return found, missing
def resolve_detail(row: dict, csv_dir: Path) -> str | None:
"""Return the contents of a row's detail file, or None if there is no detail
(or the file is missing — a missing file is reported to stderr, not fatal)."""
if not row.get("detail"):
return None
path = (csv_dir / row["detail"]).resolve()
if not path.is_file():
print(f"# detail file not found for {row['technique_name']}: {row['detail']}", file=sys.stderr)
return None
return path.read_text(encoding="utf-8").strip()
def fmt_categories(cats: list[tuple[str, int]], as_json: bool) -> str:
if as_json:
return json.dumps([{"category": c, "count": n} for c, n in cats])
return "\n".join(f"{c}\t{n}" for c, n in cats)
def fmt_list(rows: list[dict], as_json: bool) -> str:
if as_json:
return json.dumps([{k: r[k] for k in ("category", "technique_name", "description")} for r in rows])
return "\n".join(f"{r['category']}\t{r['technique_name']}\t{r['description']}" for r in rows)
def fmt_show(rows: list[dict], csv_dir: Path, as_json: bool) -> str:
if as_json:
out = []
for r in rows:
d = resolve_detail(r, csv_dir)
entry = {k: r[k] for k in ("category", "technique_name", "description")}
if d:
entry["detail"] = d
out.append(entry)
return json.dumps(out)
blocks = []
for r in rows:
block = f"## {r['technique_name']} [{r['category']}]\n{r['description']}"
d = resolve_detail(r, csv_dir)
if d:
block += f"\n\n{d}"
blocks.append(block)
return "\n\n".join(blocks)
def pretty(cat: str) -> str:
"""Turn a category slug (e.g. 'speculative_future') into a display name."""
return cat.replace("_", " ").replace("-", " ").title()
# --- card visuals: a crafted duotone icon + hue per category, plus a per-technique icon ---
# The hues and SVG glyphs are *data*, not logic: they live in the icon sidecar
# (assets/brain-icons.json) so the catalog's visuals can be edited without touching code.
# It maps category slug -> {hue, glyph} and technique name -> svg (inner markup, drawn in
# `currentColor` which the CSS sets to the category hue; the shared CHIP frame is added by
# the renderer). Anything missing falls back here — an unknown category gets a hash-derived
# hue + generic glyph, an unknown/not-yet-iconed technique a neutral mark — so custom
# catalogs always render.
ICON_FILE = DEFAULT_FILE.parent / "brain-icons.json"
CHIP = '<rect x="1.5" y="1.5" width="41" height="41" rx="12" fill="currentColor" fill-opacity="0.12"/>'
_FALLBACK_GLYPH = (
'<circle cx="22" cy="22" r="11" fill="currentColor" fill-opacity="0.16"/>'
'<circle cx="22" cy="22" r="11" stroke="currentColor" stroke-width="1.6" fill="none"/>'
'<circle cx="22" cy="22" r="3.4" fill="currentColor"/>'
)
_FALLBACK_TECH = (
'<rect x="15" y="15" width="14" height="14" rx="2.5" transform="rotate(45 22 22)" '
'fill="none" stroke="currentColor" stroke-width="2"/><circle cx="22" cy="22" r="2.4" fill="currentColor"/>'
)
def _load_icons(file: Path = ICON_FILE) -> tuple[dict, dict]:
"""Read the icon sidecar: (category slug -> {hue, glyph}, technique name -> svg).
A missing or malformed file is non-fatal — everything then uses the fallbacks below."""
try:
data = json.loads(file.read_text(encoding="utf-8"))
except (OSError, ValueError):
return {}, {}
return (data.get("categories") or {}), (data.get("techniques") or {})
_CATEGORY_STYLES, _TECH_ICONS = _load_icons()
def _hsl_hex(deg: int, s: float, lt: float) -> str:
import colorsys
r, g, b = colorsys.hls_to_rgb((deg % 360) / 360, lt, s)
return "#%02x%02x%02x" % (round(r * 255), round(g * 255), round(b * 255))
def category_style(cat: str) -> tuple[str, str]:
"""(hue, glyph markup) for a category — from the sidecar for the shipped set, derived for extras."""
style = _CATEGORY_STYLES.get(cat)
if style and style.get("hue"):
return style["hue"], style.get("glyph") or _FALLBACK_GLYPH
deg = int(hashlib.md5(cat.encode("utf-8")).hexdigest(), 16) % 360
return _hsl_hex(deg, 0.58, 0.52), _FALLBACK_GLYPH
def tech_icon(name: str) -> str:
"""The hand-picked line-icon for a specific technique (neutral mark if unknown)."""
return _TECH_ICONS.get(name, _FALLBACK_TECH)
SELECTOR_TEMPLATE = r"""<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>BMad Method Brainstorming Selection</title>
<script>
/* set the theme before first paint so there's no light-mode flash */
(function(){ try {
var t = localStorage.getItem('bmad-theme');
if (!t) { t = (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) ? 'dark' : 'light'; }
document.documentElement.setAttribute('data-theme', t);
} catch(e){} })();
</script>
<style>
:root {
--bg:#f6f7fb; --surface:#fff; --ink:#1c1e2b; --muted:#6b7080;
--accent:#5b4bdc; --accent-ink:#5b4bdc; --warn:#c0561f;
--line:#e6e8f0; --control:#eef0f7; --control2:#f1f2f8; --raised:#fff;
--cnt:#b9bdce; --foot:#aeb2c4; --shadow:rgba(20,20,50,.06);
}
:root[data-theme="dark"] {
--bg:#0f1117; --surface:#171a23; --ink:#e7e9f2; --muted:#9aa0b4;
--accent:#6d5cf0; --accent-ink:#a99bff; --warn:#e08a4a;
--line:#2a2f3e; --control:#222634; --control2:#1d212d; --raised:#2c3242;
--cnt:#5a6076; --foot:#5a6076; --shadow:rgba(0,0,0,.45);
}
/* lift the category hue toward white on dark surfaces so deep hues stay legible */
:root[data-theme="dark"] section > h2 { color:color-mix(in srgb, var(--c) 62%, #fff); }
:root[data-theme="dark"] .tech .ico { color:color-mix(in srgb, var(--c) 68%, #fff); }
:root[data-theme="dark"] label.tech:has(input:checked) { border-color:color-mix(in srgb, var(--c) 60%, #fff); }
.titlerow { display:flex; align-items:flex-start; justify-content:space-between; gap:12px; }
.themebtn { flex:none; width:36px; height:36px; border-radius:9px; background:var(--control); color:var(--ink); font-size:17px; line-height:1; display:inline-flex; align-items:center; justify-content:center; }
.themebtn:hover { background:var(--raised); }
* { box-sizing:border-box; }
body { margin:0; font:16px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif; background:var(--bg); color:var(--ink); }
header { position:sticky; top:0; z-index:5; background:var(--surface); padding:20px 0 12px; border-bottom:1px solid var(--line); box-shadow:0 2px 12px var(--shadow); }
.hwrap { max-width:1120px; margin:0 auto; padding:0 24px; } /* align header content with the card column on wide screens */
h1 { margin:0 0 4px; font-size:24px; letter-spacing:-.02em; }
.sub { margin:0 0 12px; color:var(--muted); font-size:14px; max-width:74ch; }
button { font:inherit; border:0; border-radius:8px; cursor:pointer; }
.composer { display:flex; flex-direction:column; gap:9px; margin:6px 0 12px; }
.grp { display:flex; gap:8px; align-items:center; flex-wrap:wrap; }
.glabel { font-size:11px; text-transform:uppercase; letter-spacing:.07em; color:var(--muted); min-width:74px; }
.modes { display:inline-flex; background:var(--control); border-radius:9px; padding:3px; gap:2px; }
.mode { padding:7px 13px; font-size:14px; font-weight:600; color:var(--muted); background:transparent; }
.mode.on { background:var(--raised); color:var(--accent-ink); box-shadow:0 1px 3px var(--shadow); }
.modehint { flex:1 1 240px; min-width:0; font-size:13px; color:var(--muted); font-style:italic; }
.pill { font-size:13px; color:var(--muted); background:var(--control); padding:6px 12px; border-radius:20px; }
.pill b { color:var(--accent-ink); }
.step { display:inline-flex; align-items:center; gap:7px; font-size:13px; color:var(--ink); background:var(--control2); padding:4px 6px 4px 12px; border-radius:20px; }
.step b { min-width:12px; text-align:center; font-size:14px; color:var(--ink); }
.step button { width:24px; height:24px; border-radius:50%; background:var(--raised); color:var(--muted); font-size:17px; line-height:22px; text-align:center; box-shadow:0 1px 2px var(--shadow); }
.step button:hover { color:var(--accent-ink); }
.total { font-size:12px; color:var(--muted); }
.total.warn { color:var(--warn); font-weight:600; }
.bar { display:flex; gap:10px 14px; align-items:center; flex-wrap:wrap; }
#copy { margin-left:auto; padding:9px 22px; background:var(--accent); color:#fff; font-size:14px; font-weight:700; }
#copy:hover { filter:brightness(1.07); }
.chips { flex:1 1 320px; min-width:0; display:flex; gap:7px; flex-wrap:wrap; align-items:center; }
.chip { font-size:12px; padding:4px 11px; border-radius:16px; border:0; color:#fff; background:var(--cc); font-weight:600; cursor:pointer; }
.chip:hover { filter:brightness(1.08); }
.banner { max-height:0; overflow:hidden; transition:max-height .25s ease, padding .22s ease, margin .22s ease; background:linear-gradient(90deg,var(--accent),#8275f2); color:#fff; border-radius:10px; font-weight:700; text-align:center; padding:0 14px; }
.banner.show { max-height:64px; padding:13px 14px; margin-top:10px; }
.banner.fail { background:linear-gradient(90deg,var(--warn),#e0894a); }
main { padding:18px 24px 60px; max-width:1120px; margin:0 auto; }
section { margin:0 0 26px; }
section > h2 { font-size:13px; text-transform:uppercase; letter-spacing:.08em; color:var(--c); margin:0 0 10px; border-bottom:1px solid color-mix(in srgb, var(--c) 24%, var(--line)); padding-bottom:6px; }
section > h2 .cnt { color:color-mix(in srgb, var(--c) 45%, var(--cnt)); margin-left:6px; }
.grid { display:grid; grid-template-columns:repeat(auto-fill,minmax(360px,1fr)); gap:10px; }
label.tech { display:flex; gap:12px; align-items:flex-start; background:color-mix(in srgb, var(--c) 5%, var(--surface)); border:1px solid color-mix(in srgb, var(--c) 18%, var(--line)); border-radius:10px; padding:11px 13px; cursor:pointer; transition:border-color .12s, box-shadow .12s, background .12s; }
label.tech:hover { border-color:color-mix(in srgb, var(--c) 45%, var(--surface)); }
label.tech input { margin-top:2px; width:17px; height:17px; accent-color:var(--c); flex:none; }
label.tech:has(input:checked) { border-color:var(--c); background:color-mix(in srgb, var(--c) 12%, var(--surface)); box-shadow:0 0 0 2px color-mix(in srgb, var(--c) 30%, transparent); }
.tech .ic2 { display:flex; gap:5px; flex:none; }
.tech .ico { width:40px; height:40px; flex:none; color:var(--c); }
.tech .n { font-weight:600; display:block; }
.tech .d { color:var(--muted); font-size:13.5px; display:block; margin-top:2px; }
.tech .gf { color:var(--accent-ink); font-size:11px; display:block; margin-top:5px; opacity:.85; }
.grouphdr { margin:30px 0 12px; font-size:12px; text-transform:uppercase; letter-spacing:.14em; font-weight:700; color:var(--c); opacity:.92; border-bottom:1px solid color-mix(in srgb, var(--c) 22%, var(--line)); padding-bottom:7px; }
main > .grouphdr:first-child { margin-top:2px; }
:root[data-theme="dark"] .grouphdr { color:color-mix(in srgb, var(--c) 62%, #fff); }
.goals { display:flex; gap:7px; flex-wrap:wrap; }
.goal { font-size:12px; padding:5px 12px; border-radius:16px; background:var(--control); color:var(--muted); font-weight:600; }
.goal:hover { color:var(--ink); }
.goal.on { background:var(--accent); color:#fff; }
label.tech.invent { border-style:dashed; background:transparent; }
label.tech.invent:hover { border-color:var(--c); }
label.tech.invent .n { color:var(--c); }
label.tech.hidden { display:none; }
footer { text-align:center; color:var(--foot); font-size:12px; padding:24px; }
</style>
</head>
<body>
<header>
<div class="hwrap">
<div class="titlerow">
<h1>BMad Method Brainstorming Selection</h1>
<button id="theme" class="themebtn" type="button" aria-label="Toggle dark mode" title="Toggle dark mode"></button>
</div>
<p class="sub">Compose your session, hit <strong>Copy prompt</strong>, and paste it back into the chat to begin. {{TOTAL}}</p>
<div class="composer">
<div class="grp">
<span class="glabel">Facilitation</span>
<div class="modes" id="modes">
<button type="button" class="mode on" data-mode="Facilitator">Facilitator</button>
<button type="button" class="mode" data-mode="Creative Partner">Creative Partner</button>
<button type="button" class="mode" data-mode="Ideate for me">Ideate for me</button>
</div>
<span class="modehint" id="modehint"></span>
</div>
<div class="grp">
<span class="glabel">Techniques</span>
<span class="pill">Picked <b id="pickN">0</b></span>
<span class="step">Random <button type="button" data-step="rand" data-d="-1">&minus;</button><b id="randN">0</b><button type="button" data-step="rand" data-d="1">+</button></span>
<span class="step">Invent <button type="button" data-step="inv" data-d="-1">&minus;</button><b id="invN">0</b><button type="button" data-step="inv" data-d="1">+</button></span>
<span class="step">AI picks <button type="button" data-step="ai" data-d="-1">&minus;</button><b id="aiN">0</b><button type="button" data-step="ai" data-d="1">+</button></span>
<span class="total" id="total">Total 0 &middot; 3&ndash;4 is the sweet spot</span>
<button id="copy" type="button">Copy prompt</button>
</div>
</div>
{{GOALBAR}}
<div class="bar">
<span class="glabel">Jump to</span>
<div class="chips" id="chips">{{CHIPS}}</div>
</div>
<div class="banner" id="banner">&#10003; Copied! Now paste it into the chat to start your session.</div>
</div>
</header>
<main>
{{BODY}}
</main>
<footer>BMad Method &middot; Brainstorming</footer>
<script>
(function(){
var $ = function(id){ return document.getElementById(id); };
var all = Array.prototype.slice;
var boxes = all.call(document.querySelectorAll('input[type=checkbox]'));
var techBoxes = boxes.filter(function(b){ return b.dataset.name; }); // real technique cards
var inventBoxes = boxes.filter(function(b){ return b.dataset.invent; }); // per-category "invent in the spirit of" cards
var header = document.querySelector('header');
var sections = all.call(document.querySelectorAll('section'));
var state = { mode: 'Facilitator', rand: 0, inv: 0, ai: 0 };
var MODE_HINTS = {
'Facilitator': 'A forcing function for your ideas — I prompt and push, but never supply them.',
'Creative Partner': 'We riff together — I facilitate and add ideas too, each logged as yours or mine.',
'Ideate for me': 'I run the whole session myself, then show you the result and offer to keep going.'
};
function setHint(){ $('modehint').textContent = MODE_HINTS[state.mode] || ''; }
var themeBtn = $('theme');
function setThemeIcon(){ themeBtn.textContent = document.documentElement.getAttribute('data-theme') === 'dark' ? '☀' : '☾'; }
themeBtn.addEventListener('click', function(){
var next = document.documentElement.getAttribute('data-theme') === 'dark' ? 'light' : 'dark';
document.documentElement.setAttribute('data-theme', next);
try { localStorage.setItem('bmad-theme', next); } catch(e){}
setThemeIcon();
});
all.call(document.querySelectorAll('.mode')).forEach(function(b){
b.addEventListener('click', function(){
all.call(document.querySelectorAll('.mode')).forEach(function(m){ m.classList.remove('on'); });
b.classList.add('on');
state.mode = b.dataset.mode;
setHint();
});
});
all.call(document.querySelectorAll('[data-step]')).forEach(function(btn){
btn.addEventListener('click', function(){
var k = btn.dataset.step, d = parseInt(btn.dataset.d, 10);
state[k] = Math.max(0, state[k] + d);
update();
});
});
// Category chips are jump-nav: click one to smooth-scroll its section into view,
// offsetting by the sticky header's height so the heading isn't hidden beneath it.
all.call(document.querySelectorAll('.chip')).forEach(function(chip){
chip.addEventListener('click', function(){
var sec = null;
for (var i = 0; i < sections.length; i++){ if (sections[i].dataset.cat === chip.dataset.cat){ sec = sections[i]; break; } }
if (!sec){ return; }
var top = sec.getBoundingClientRect().top + window.pageYOffset - header.offsetHeight - 8;
window.scrollTo({ top: top, behavior: 'smooth' });
});
});
boxes.forEach(function(b){ b.addEventListener('change', update); });
// A `classic` technique appears twice (lead "Proven & Professional" group + its home
// category), so de-dupe checked picks by name; the lead copy carries data-lead.
function checkedTech(){
var seen = {}, out = [];
techBoxes.forEach(function(b){
if (!b.checked || seen[b.dataset.name]) { return; }
seen[b.dataset.name] = 1;
out.push(b);
});
return out;
}
function checkedInvent(){ return inventBoxes.filter(function(b){ return b.checked; }); }
function update(){
$('pickN').textContent = checkedTech().length;
$('randN').textContent = state.rand;
$('invN').textContent = state.inv;
$('aiN').textContent = state.ai;
var total = checkedTech().length + state.rand + state.inv + checkedInvent().length + state.ai;
var t = $('total');
t.textContent = 'Total ' + total + ' · 3–4 is the sweet spot';
t.classList.toggle('warn', total > 5);
}
// "Great for" goal filter: clicking a goal narrows visible cards to those tagged with it.
var goalBtns = all.call(document.querySelectorAll('.goal'));
function activeGoals(){ return goalBtns.filter(function(b){ return b.classList.contains('on'); }).map(function(b){ return b.dataset.goal; }); }
function applyFilter(){
var act = activeGoals();
all.call(document.querySelectorAll('label.tech')).forEach(function(lab){
var inp = lab.querySelector('input');
if (inp.dataset.invent){ return; } // invent cards aren't goal-tagged — always visible
var good = (inp.dataset.good || '').split('|');
var show = !act.length || act.some(function(g){ return good.indexOf(g) >= 0; });
lab.classList.toggle('hidden', !show);
});
}
goalBtns.forEach(function(b){ b.addEventListener('click', function(){ b.classList.toggle('on'); applyFilter(); }); });
function randomPool(){
var picked = {};
checkedTech().forEach(function(b){ picked[b.dataset.name] = 1; });
// draw from unchecked, non-lead copies, skipping anything already picked
return techBoxes.filter(function(b){ return !b.checked && !b.dataset.lead && !picked[b.dataset.name]; });
}
function sample(arr, n){
var a = arr.slice(), out = [];
while (out.length < n && a.length){ out.push(a.splice(Math.floor(Math.random() * a.length), 1)[0]); }
return out;
}
function compose(){
var picks = checkedTech().map(function(b){ return { n: b.dataset.name, c: b.dataset.cat, d: b.dataset.desc, r: false }; });
var rnd = sample(randomPool(), state.rand).map(function(b){ return { n: b.dataset.name, c: b.dataset.cat, d: b.dataset.desc, r: true }; });
var techs = picks.concat(rnd);
var L = ["Let's run my brainstorming session.", "", 'Facilitation mode: ' + state.mode + '.'];
if (techs.length){
L.push("", 'Techniques to use:');
techs.forEach(function(t, i){
L.push((i + 1) + '.' + (t.r ? ' (random pick)' : '') + ' ' + t.n + ' · ' + t.c);
L.push(' ' + t.d);
});
}
var extra = [];
if (state.inv > 0){ extra.push('invent ' + state.inv + ' brand-new technique' + (state.inv > 1 ? 's' : '') + ' on the fly'); }
checkedInvent().forEach(function(b){ extra.push('invent 1 new technique in the spirit of ' + b.dataset.invent); });
if (state.ai > 0){ extra.push('you choose ' + state.ai + ' more technique' + (state.ai > 1 ? 's' : '') + ' that fit my goal'); }
if (extra.length){ L.push("", 'Then: ' + extra.join('; and ') + '.'); }
if (!techs.length && !extra.length){
L.push("", state.mode === 'Ideate for me'
? 'Run the whole session yourself — pick the techniques, generate the ideas, then show me the result.'
: 'Help me choose 3–4 techniques to start.');
}
return L.join('\n');
}
function fallbackCopy(t){
var ta = document.createElement('textarea');
ta.value = t; ta.style.position = 'fixed'; ta.style.opacity = '0';
document.body.appendChild(ta); ta.focus(); ta.select();
var ok = false;
try { ok = document.execCommand('copy'); } catch(e){ ok = false; }
document.body.removeChild(ta);
return ok;
}
function flash(ok, text){
var b = $('banner');
b.classList.toggle('fail', !ok);
b.innerHTML = ok
? '✓ Copied! Now paste it into the chat to start your session.'
: '⚠ Couldn’t reach the clipboard — copy the text in the box, then paste it into the chat.';
b.classList.add('show');
setTimeout(function(){ b.classList.remove('show'); }, 4500);
// Last resort on a hard failure: a prefilled, selectable prompt so the text is never lost.
if (!ok){ window.prompt('Copy this, then paste it into the chat:', text); }
}
$('copy').addEventListener('click', function(){
var text = compose();
if (navigator.clipboard && navigator.clipboard.writeText){
navigator.clipboard.writeText(text).then(
function(){ flash(true, text); },
function(){ flash(fallbackCopy(text), text); }
);
} else { flash(fallbackCopy(text), text); }
});
setHint();
setThemeIcon();
update();
})();
</script>
</body>
</html>
"""
# --- browse-page layout: a "Proven & Professional" lead group, then super-groups ----------
CLASSIC_GROUP = "Proven & Professional"
LEAD_HUE = "#3d4f73" # a dignified slate for the professional lead group
# Super-group order for the shipped categories. Categories not listed (e.g. user-added
# via --extra) render last under "More", alphabetically — so custom catalogs always show.
CATEGORY_GROUPS = (
("Structured & Analytical", ("structured", "deep")),
("Creative & Generative", ("creative", "biomimetic", "cultural", "speculative_future", "quantum")),
("Wild & Playful", ("wild", "absurdist", "theatrical", "constraint")),
("Introspective & Personal", ("introspective_delight", "collaborative")),
)
# Human labels for the `good_for` goal tags; this dict's order is the filter-bar order.
GOAL_LABELS = {
"feature": "Build a feature",
"novel": "Novel concept",
"strategy": "Strategy",
"planning": "Planning",
"diagnosis": "Diagnose",
"personal": "Personal / life",
"unstuck": "Get unstuck",
}
def _good_for_label(good: str) -> str:
parts = [GOAL_LABELS.get(g, g) for g in good.split("|") if g]
return ("Great for: " + " · ".join(parts)) if parts else ""
def _svg(inner: str) -> str:
return f'<svg class="ico" viewBox="0 0 44 44" xmlns="http://www.w3.org/2000/svg">{CHIP}{inner}</svg>'
def _card(r: dict, lead: bool = False) -> str:
"""One technique card. `lead=True` cards live in the cross-cutting professional group;
they carry their own category hue (inline --c) and data-lead so selection can de-dupe."""
name = html.escape(r["technique_name"])
desc = html.escape(r["description"])
hue, glyph = category_style(r["category"])
disp_cat = html.escape(pretty(r["category"]))
good = html.escape(r.get("good_for", ""))
prov = html.escape(r.get("provenance", ""))
style = f' style="--c:{hue}"' if lead else ""
lead_attr = ' data-lead="1"' if lead else ""
gf = _good_for_label(r.get("good_for", ""))
gf_html = f'<span class="gf">{html.escape(gf)}</span>' if gf else ""
return (
f'<label class="tech"{style}><input type="checkbox" '
f'data-name="{name}" data-cat="{disp_cat}" data-desc="{desc}" data-good="{good}" data-prov="{prov}"{lead_attr}>'
f'<span class="ic2">{_svg(glyph)}{_svg(tech_icon(r["technique_name"]))}</span>'
f'<span><span class="n">{name}</span><span class="d">{desc}</span>{gf_html}</span></label>'
)
def _invent_card(disp_cat: str, glyph: str) -> str:
"""A dashed 'invent on the fly, in this category's spirit' card appended to each section."""
return (
f'<label class="tech invent"><input type="checkbox" data-invent="{disp_cat}">'
f'<span class="ic2">{_svg(glyph)}</span>'
f'<span><span class="n">✨ Invent a {disp_cat} technique</span>'
f'<span class="d">Make up a brand-new technique on the fly, in the spirit of {disp_cat}</span></span></label>'
)
def html_doc(rows: list[dict]) -> str:
"""Render the self-contained 'browse all techniques' selection page from the catalog.
Deterministic ordering so the shipped asset can be snapshot-tested against the CSV:
a cross-cutting "Proven & Professional" lead group (every `classic`-tagged row), then
the categories in fixed super-group order, then any unlisted/custom categories under
"More" alphabetically. Techniques render in file order within a category. A `classic`
row appears both in the lead group and its home category; the page de-dupes on select.
"""
groups: dict[str, list[dict]] = {}
for r in rows:
groups.setdefault(r["category"], []).append(r)
body: list[str] = []
chips: list[str] = []
def add_section(cat: str) -> None:
hue, glyph = category_style(cat)
disp = html.escape(pretty(cat))
cards = [_card(r) for r in groups[cat]]
cards.append(_invent_card(disp, glyph))
chips.append(f'<button type="button" class="chip" data-cat="{disp}" style="--cc:{hue}">{disp}</button>')
body.append(
f'<section data-cat="{disp}" style="--c:{hue}"><h2>{disp}<span class="cnt">{len(groups[cat])}</span></h2>'
f'<div class="grid">{"".join(cards)}</div></section>'
)
# 1) lead group — every classic-tagged technique, cross-category (no invent card here)
classics = [r for r in rows if r.get("provenance", "").lower() == "classic"]
if classics:
disp = html.escape(CLASSIC_GROUP)
lead_cards = "".join(_card(r, lead=True) for r in classics)
chips.append(f'<button type="button" class="chip" data-cat="{disp}" style="--cc:{LEAD_HUE}">{disp}</button>')
body.append(
f'<section data-cat="{disp}" style="--c:{LEAD_HUE}"><h2>{disp}<span class="cnt">{len(classics)}</span></h2>'
f'<div class="grid">{lead_cards}</div></section>'
)
# 2) shipped categories, in super-group order
placed = set()
for group_title, cats in CATEGORY_GROUPS:
present = [c for c in cats if c in groups]
if not present:
continue
hue, _ = category_style(present[0])
body.append(f'<h2 class="grouphdr" style="--c:{hue}">{html.escape(group_title)}</h2>')
for c in present:
add_section(c)
placed.add(c)
# 3) leftover (custom / --extra) categories, alphabetically
leftover = sorted(c for c in groups if c not in placed)
if leftover:
body.append('<h2 class="grouphdr" style="--c:#8a8f9e">More</h2>')
for c in leftover:
add_section(c)
# goal-affinity filter bar — only if the catalog actually carries good_for tags
present_goals: set[str] = set()
for r in rows:
for g in (r.get("good_for", "") or "").split("|"):
if g:
present_goals.add(g)
goalbar = ""
if present_goals:
ordered = [g for g in GOAL_LABELS if g in present_goals] + sorted(present_goals - set(GOAL_LABELS))
gchips = "".join(
f'<button type="button" class="goal" data-goal="{html.escape(g)}">{html.escape(GOAL_LABELS.get(g, g))}</button>'
for g in ordered
)
goalbar = f'<div class="bar"><span class="glabel">Great for</span><div class="goals" id="goals">{gchips}</div></div>'
total = html.escape(f"{len(rows)} techniques across {len(groups)} categories.")
return (
SELECTOR_TEMPLATE.replace("{{BODY}}", "\n".join(body))
.replace("{{CHIPS}}", "".join(chips))
.replace("{{GOALBAR}}", goalbar)
.replace("{{TOTAL}}", total)
)
def main(argv: list[str] | None = None) -> int:
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("--file", type=Path, default=DEFAULT_FILE, help="technique CSV (default: sibling assets/brain-methods.csv)")
p.add_argument("--extra", type=Path, help="JSON overlay of additional techniques (customize.toml additional_techniques), merged into every command")
p.add_argument("--json", action="store_true", help="emit structured JSON instead of lean text")
sub = p.add_subparsers(dest="cmd", required=True)
sub.add_parser("categories", help="list category names + counts")
pl = sub.add_parser("list", help="the index: category/name/gist (needs --category or --all)")
pl.add_argument("--category", action="append", help="filter to a category (repeatable)")
pl.add_argument("--all", action="store_true", help="dump the entire catalog (deliberate; large)")
ps = sub.add_parser("show", help="full gist + detail file for named techniques")
ps.add_argument("names", nargs="+")
pr = sub.add_parser("random", help="pick techniques at random")
pr.add_argument("--category", action="append", help="restrict to a category (repeatable)")
pr.add_argument("-n", type=int, default=1, help="how many (default 1)")
ph = sub.add_parser("html", help="write the offline 'browse all' selection page")
ph.add_argument("--out", help="file to write the page to (required; never prints the catalog)")
args = p.parse_args(argv)
if not args.file.is_file():
print(f"error: technique file not found: {args.file}", file=sys.stderr)
return 2
rows = load(args.file)
if args.extra:
if not args.extra.is_file():
print(f"error: --extra file not found: {args.extra}", file=sys.stderr)
return 2
rows += load_extra(args.extra)
csv_dir = args.file.resolve().parent
if args.cmd == "categories":
print(fmt_categories(categories(rows), args.json))
elif args.cmd == "list":
if not args.category and not args.all:
print(
"error: `list` needs --category (one or more) — or --all to dump the whole "
"catalog on purpose. Use `categories` for the cheap map, or `random` to draw blind.",
file=sys.stderr,
)
return 2
print(fmt_list(filter_cats(rows, args.category), args.json))
elif args.cmd == "show":
found, missing = find(rows, args.names)
for m in missing:
print(f"# not found: {m}", file=sys.stderr)
if not found:
return 1
print(fmt_show(found, csv_dir, args.json))
elif args.cmd == "random":
pool = filter_cats(rows, args.category)
if not pool:
print("# no techniques match", file=sys.stderr)
return 1
n = max(0, min(args.n, len(pool))) # clamp: never crash on a negative or oversized -n
print(fmt_list(random.sample(pool, n), args.json))
elif args.cmd == "html":
if not args.out:
print(
"error: `html` needs --out PATH — it writes the selection page to a file and "
"never prints the catalog to stdout (which would defeat the point).",
file=sys.stderr,
)
return 2
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(html_doc(rows), encoding="utf-8")
print(f"wrote {out} ({len(rows)} techniques, {len(categories(rows))} categories)")
return 0
if __name__ == "__main__":
sys.exit(main())

202
src/core-skills/bmad-brainstorming/scripts/memlog.py Normal file
View File

@ -0,0 +1,202 @@
#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10"
# ///
"""memlog — an append-only memory log: LLM-optimal working memory for a skill.
A memlog is the dense, chronological record of everything that mattered in a piece of
work — every item the user generated or accepted — kept minimal like human memory: only
what's important, never bloated. It persists ACROSS sessions, so a fresh session can
load it and continue. It is NOT a deliverable; downstream artifacts (a brief, a PRD, a
deck, a report) are *derived* from it on demand. The host skill supplies the vocabulary
by how it calls `append` — the tool stays neutral.
It is a FLAT log: there are no sections or grouping. Every entry is one line, recorded
at the END in the order it happened. The chronology itself is the structure — an event
like "started technique X" is just another entry, same as an idea or an insight.
Two invariants make it trustworthy:
1. Append-only, chronological. Entries land at the end, in the order they happen.
Nothing is ever inserted backward, reordered, or grouped.
2. Write-only / blind. Every command is an atomic, context-free write and echoes the
new state as JSON, so the caller never re-reads the file mid-session. The one time
the file is read is on resume — and the caller reads it itself, not via this script.
The file shape (.memlog.md):
---
topic: Onboarding flow for a budgeting app
goal: lift week-1 retention
status: active
updated: 2026-05-30T14:22
---
- (note) user picked techniques: SCAMPER, then Six Thinking Hats
- (technique) started SCAMPER
- (idea) skip the signup wall: let people try with sample data first
- (idea) auto-import one bank account so the first screen shows real numbers
- (question) is open-banking consent too heavy for step one?
- (technique) started Six Thinking Hats
- (idea) black-hat: imported transactions look scary before they're categorized
- (insight) the "scary numbers" risk and the "real numbers" idea are one lever: show real data, pre-categorized
- (direction) user wants to optimize for the anxious first-timer, not the power user
- (decision) lead with one pre-categorized account; defer multi-account import
Each entry may carry an optional `--type` — what KIND it is (idea, insight, question,
decision, technique, …) — and an optional `--by` naming who it came from (e.g. `user`,
`coach`), for sessions where authorship matters. Both render into one short inline tag:
`(idea)`, `(idea by user)`, `(by coach)`. Omit them for a plain note. The host skill
names the vocabulary; the script does not.
Commands:
init --workspace DIR [--field k=v ...] create the memlog (errors if it exists)
append --workspace DIR --text STR [--type T] [--by W] append one entry at the end
set --workspace DIR --key K --value V set/replace a frontmatter field
The workspace is the run folder; the memlog is always {workspace}/.memlog.md.
"""
import argparse
import json
import os
import sys
from datetime import datetime
from pathlib import Path
MEMLOG = ".memlog.md"
def now() -> str:
return datetime.now().strftime("%Y-%m-%dT%H:%M")
def memlog_path(workspace: str) -> Path:
return Path(workspace) / MEMLOG
def split(text: str) -> tuple[dict, str]:
"""Return (frontmatter dict in source order, body str). Frontmatter is plain key: value.
The closing fence is the first line that is *exactly* `---`, so a `---` inside a
field value (topic/goal are free user text) never truncates the frontmatter.
"""
lines = text.splitlines()
if not lines or lines[0] != "---":
raise ValueError(".memlog.md has no frontmatter")
end = next((i for i in range(1, len(lines)) if lines[i] == "---"), None)
if end is None:
raise ValueError(".memlog.md frontmatter is not terminated")
meta: dict[str, str] = {}
for line in lines[1:end]:
if ":" in line:
k, v = line.split(":", 1)
meta[k.strip()] = v.strip()
return meta, "\n".join(lines[end + 1:]).lstrip("\n")
def render(meta: dict, body: str) -> str:
# Neutralize newlines in values so a multi-line field can't break the fence on re-read.
fm = "\n".join(f"{k}: {' '.join(str(v).splitlines())}" for k, v in meta.items())
return "---\n" + fm + "\n---\n\n" + body.rstrip("\n") + "\n"
def touch(meta: dict) -> None:
"""Stamp `updated` and keep it last so the field order stays predictable."""
meta.pop("updated", None)
meta["updated"] = now()
def write_atomic(path: Path, text: str) -> None:
tmp = path.with_suffix(path.suffix + ".tmp")
tmp.write_text(text, encoding="utf-8")
os.replace(tmp, path)
def entry_count(body: str) -> int:
return sum(1 for ln in body.splitlines() if ln.startswith("- "))
def ack(path: Path, meta: dict, body: str) -> None:
"""Echo new state so the caller never re-reads the file to know where it stands."""
print(json.dumps({
"ok": True,
"memlog": str(path),
"status": meta.get("status", ""),
"entries": entry_count(body),
}))
def cmd_init(args) -> int:
path = memlog_path(args.workspace)
if path.exists():
print(f"error: {path} already exists; use append/set to update it", file=sys.stderr)
return 2
path.parent.mkdir(parents=True, exist_ok=True)
meta: dict[str, str] = {}
for pair in args.field or []:
if "=" not in pair:
print(f"error: --field expects key=value, got {pair!r}", file=sys.stderr)
return 2
k, v = pair.split("=", 1)
meta[k.strip()] = v.strip()
meta.setdefault("status", "active")
touch(meta)
write_atomic(path, render(meta, ""))
ack(path, meta, "")
return 0
def cmd_append(args) -> int:
path = memlog_path(args.workspace)
meta, body = split(path.read_text(encoding="utf-8"))
text = " ".join(args.text.split()) # collapse newlines/runs → one-line entry, no prose bloat
label = args.type or ""
if args.by:
label = f"{label} by {args.by}".strip() # attribution: "(idea by user)" / "(by coach)"
tag = f"({label}) " if label else ""
entry = f"- {tag}{text}"
body = (body.rstrip("\n") + "\n" + entry) if body.strip() else entry # always at the end
touch(meta)
write_atomic(path, render(meta, body))
ack(path, meta, body)
return 0
def cmd_set(args) -> int:
path = memlog_path(args.workspace)
meta, body = split(path.read_text(encoding="utf-8"))
meta[args.key] = args.value
touch(meta)
write_atomic(path, render(meta, body))
ack(path, meta, body)
return 0
def main(argv: list[str] | None = None) -> int:
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
sub = p.add_subparsers(dest="cmd", required=True)
pi = sub.add_parser("init", help="create the memlog")
pi.add_argument("--workspace", required=True)
pi.add_argument("--field", action="append", metavar="KEY=VALUE", help="frontmatter field (repeatable)")
pi.set_defaults(func=cmd_init)
pa = sub.add_parser("append", help="append one entry at the end")
pa.add_argument("--workspace", required=True)
pa.add_argument("--text", required=True)
pa.add_argument("--type", help="entry kind, rendered as an inline tag")
pa.add_argument("--by", help="who the entry came from (e.g. user, coach); rendered into the tag")
pa.set_defaults(func=cmd_append)
pset = sub.add_parser("set", help="set a frontmatter field")
pset.add_argument("--workspace", required=True)
pset.add_argument("--key", required=True)
pset.add_argument("--value", required=True)
pset.set_defaults(func=cmd_set)
args = p.parse_args(argv)
return args.func(args)
if __name__ == "__main__":
sys.exit(main())

217
src/core-skills/bmad-brainstorming/scripts/tests/test_brain.py Normal file
View File

@ -0,0 +1,217 @@
# /// script
# requires-python = ">=3.10"
# dependencies = ["pytest>=8.0"]
# ///
"""Tests for brain.py. Run: uv run -m pytest scripts/tests/test_brain.py"""
import sys
from pathlib import Path
import pytest
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
import brain # noqa: E402
CSV = """category,technique_name,description,detail
collaborative,Yes And Building,Build on every idea with "yes and" to keep momentum,
wild,Quantum Superposition,Hold contradictory ideas as simultaneously true,techniques/quantum.md
structured,SCAMPER Method,Run the idea through seven transformation lenses,
wild,Anti-Solution,Brainstorm how to make the problem worse then invert,
"""
DETAIL = "# Quantum Superposition\nFull multi-step instructions for the complex technique."
@pytest.fixture
def lib(tmp_path):
csv_path = tmp_path / "brain-methods.csv"
csv_path.write_text(CSV, encoding="utf-8")
(tmp_path / "techniques").mkdir()
(tmp_path / "techniques" / "quantum.md").write_text(DETAIL, encoding="utf-8")
return csv_path
def test_load_normalizes_detail(lib):
rows = brain.load(lib)
assert len(rows) == 4
assert rows[0]["detail"] == ""
assert rows[1]["detail"] == "techniques/quantum.md"
def test_categories_counts_sorted(lib):
assert brain.categories(brain.load(lib)) == [("collaborative", 1), ("structured", 1), ("wild", 2)]
def test_filter_is_case_insensitive(lib):
rows = brain.filter_cats(brain.load(lib), ["WILD"])
assert {r["technique_name"] for r in rows} == {"Quantum Superposition", "Anti-Solution"}
def test_filter_none_returns_all(lib):
assert len(brain.filter_cats(brain.load(lib), None)) == 4
def test_find_hits_and_misses(lib):
found, missing = brain.find(brain.load(lib), ["scamper method", "Nope"])
assert [r["technique_name"] for r in found] == ["SCAMPER Method"]
assert missing == ["Nope"]
def test_resolve_detail_present(lib):
row = next(r for r in brain.load(lib) if r["detail"])
assert "multi-step instructions" in brain.resolve_detail(row, lib.parent)
def test_resolve_detail_absent_is_none(lib):
row = next(r for r in brain.load(lib) if not r["detail"])
assert brain.resolve_detail(row, lib.parent) is None
def test_resolve_detail_missing_file_warns_not_fatal(lib, capsys):
rows = brain.load(lib)
rows[1]["detail"] = "techniques/gone.md"
assert brain.resolve_detail(rows[1], lib.parent) is None
assert "not found" in capsys.readouterr().err
def test_show_inlines_detail(lib, capsys):
assert brain.main(["--file", str(lib), "show", "Quantum Superposition"]) == 0
out = capsys.readouterr().out
assert "multi-step instructions" in out and "[wild]" in out
def test_show_simple_has_no_detail(lib, capsys):
brain.main(["--file", str(lib), "show", "SCAMPER Method"])
out = capsys.readouterr().out
assert "transformation lenses" in out
def test_show_all_missing_returns_1(lib):
assert brain.main(["--file", str(lib), "show", "Ghost"]) == 1
def test_list_filtered_text(lib, capsys):
brain.main(["--file", str(lib), "list", "--category", "structured"])
out = capsys.readouterr().out.strip().splitlines()
assert len(out) == 1 and out[0].startswith("structured\tSCAMPER Method\t")
def test_list_bare_is_refused(lib, capsys):
# the footgun: bare `list` must NOT dump the catalog into context
assert brain.main(["--file", str(lib), "list"]) == 2
captured = capsys.readouterr()
assert captured.out == "" # nothing leaked to stdout
assert "--category" in captured.err and "--all" in captured.err
def test_list_all_dumps_everything(lib, capsys):
assert brain.main(["--file", str(lib), "list", "--all"]) == 0
out = capsys.readouterr().out.strip().splitlines()
assert len(out) == 4 # the deliberate full-catalog escape hatch
def test_json_output(lib, capsys):
import json
brain.main(["--file", str(lib), "--json", "categories"])
data = json.loads(capsys.readouterr().out)
assert {"category": "wild", "count": 2} in data
def test_random_respects_n_and_category(lib, capsys):
brain.main(["--file", str(lib), "random", "--category", "wild", "-n", "5"])
lines = capsys.readouterr().out.strip().splitlines()
assert len(lines) == 2 # only 2 wild exist, n capped
assert all(line.startswith("wild\t") for line in lines)
def test_random_negative_n_does_not_crash(lib, capsys):
# a negative -n is clamped to 0, not passed to random.sample (which would raise)
assert brain.main(["--file", str(lib), "random", "-n", "-1"]) == 0
assert capsys.readouterr().out.strip() == ""
def test_missing_file_returns_2(tmp_path):
assert brain.main(["--file", str(tmp_path / "nope.csv"), "categories"]) == 2
# --- html selection page ------------------------------------------------
def test_html_requires_out(lib, capsys):
# never dump the catalog to stdout — writing to a file is the whole point
assert brain.main(["--file", str(lib), "html"]) == 2
assert "--out" in capsys.readouterr().err
def test_html_writes_selection_page(lib, tmp_path):
out = tmp_path / "sel.html"
assert brain.main(["--file", str(lib), "html", "--out", str(out)]) == 0
doc = out.read_text(encoding="utf-8")
assert doc.startswith("<!DOCTYPE html>")
assert "BMad Method Brainstorming Selection" in doc
for r in brain.load(lib):
assert r["technique_name"] in doc # every technique is selectable
assert "&quot;yes and&quot;" in doc # quotes in a description are escaped, not raw
def test_html_creates_missing_parent(lib, tmp_path):
out = tmp_path / "nested" / "deep" / "sel.html"
assert brain.main(["--file", str(lib), "html", "--out", str(out)]) == 0
assert out.is_file()
# --- --extra overlay (customize.toml additional_techniques) -------------
EXTRA = (
'[{"category": "domain-specific", "technique_name": "Regulatory Inversion", '
'"description": "Start from the compliance constraint and brainstorm what it unlocks."}, '
'{"category": "wild", "technique_name": "Extra Wild One", "description": "An added wild method."}]'
)
@pytest.fixture
def extra(tmp_path):
p = tmp_path / "extra.json"
p.write_text(EXTRA, encoding="utf-8")
return p
def test_extra_merges_into_categories(lib, extra, capsys):
brain.main(["--file", str(lib), "--extra", str(extra), "categories"])
out = capsys.readouterr().out
assert "domain-specific\t1" in out # a brand-new category appears
assert "wild\t3" in out # the extra wild one is counted alongside the shipped two
def test_extra_appears_in_list_and_random(lib, extra, capsys):
brain.main(["--file", str(lib), "--extra", str(extra), "list", "--category", "domain-specific"])
assert "Regulatory Inversion" in capsys.readouterr().out
def test_extra_is_first_class_in_html(lib, extra, tmp_path):
out = tmp_path / "sel.html"
assert brain.main(["--file", str(lib), "--extra", str(extra), "html", "--out", str(out)]) == 0
doc = out.read_text(encoding="utf-8")
# custom technique is selectable and its new category renders without crashing (fallback glyph/hue)
assert "Regulatory Inversion" in doc
assert "Domain Specific" in doc
def test_extra_missing_file_returns_2(lib, tmp_path):
assert brain.main(["--file", str(lib), "--extra", str(tmp_path / "nope.json"), "categories"]) == 2
def test_unknown_category_style_uses_fallback_glyph():
hue, glyph = brain.category_style("totally-made-up-category")
assert hue.startswith("#") and len(hue) == 7 # valid derived hex
assert glyph == brain._FALLBACK_GLYPH
def test_shipped_selector_is_in_sync_with_catalog():
# foolproofing: if someone edits brain-methods.csv they must regenerate the page.
# Regenerate with: python3 brain.py html --out assets/brain-selector.html
asset = brain.DEFAULT_FILE.parent / "brain-selector.html"
assert asset.is_file(), "missing assets/brain-selector.html — generate it"
expected = brain.html_doc(brain.load(brain.DEFAULT_FILE))
assert asset.read_text(encoding="utf-8") == expected, (
"assets/brain-selector.html is stale; regenerate: "
"python3 brain.py html --out assets/brain-selector.html"
)

265
src/core-skills/bmad-brainstorming/scripts/tests/test_memlog.py Normal file
View File

@ -0,0 +1,265 @@
# /// script
# requires-python = ">=3.10"
# dependencies = ["pytest>=8.0"]
# ///
"""Tests for memlog.py. Run: uv run --with pytest pytest scripts/tests/test_memlog.py
The spine under test is the flat, append-only, chronological invariant: every entry is
one line recorded at the end in the order it happened — no sections, no grouping.
"""
import json
import sys
from pathlib import Path
import pytest
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
import memlog # noqa: E402
MEMLOG = ".memlog.md"
@pytest.fixture
def ws(tmp_path):
return str(tmp_path)
def read(ws):
return (Path(ws) / MEMLOG).read_text(encoding="utf-8")
def body_of(ws):
return memlog.split(read(ws))[1]
def entries(ws):
return [ln for ln in body_of(ws).splitlines() if ln.startswith("- ")]
def init(ws, **fields):
fields = fields or {"topic": "Reinvent the lunchbox", "goal": "ideas for a pitch"}
argv = ["init", "--workspace", ws]
for k, v in fields.items():
argv += ["--field", f"{k}={v}"]
assert memlog.main(argv) == 0
def append(ws, text, entry_type=None, by=None):
argv = ["append", "--workspace", ws, "--text", text]
if entry_type:
argv += ["--type", entry_type]
if by:
argv += ["--by", by]
assert memlog.main(argv) == 0
# --- init ---------------------------------------------------------------
def test_init_writes_frontmatter_fields(ws):
init(ws)
meta, body = memlog.split(read(ws))
assert meta["topic"] == "Reinvent the lunchbox"
assert meta["goal"] == "ideas for a pitch"
assert meta["status"] == "active"
assert "updated" in meta
assert body.strip() == ""
def test_init_arbitrary_fields(ws):
init(ws, topic="T", audience="board")
meta, _ = memlog.split(read(ws))
assert meta["audience"] == "board"
def test_init_refuses_overwrite(ws):
init(ws)
assert memlog.main(["init", "--workspace", ws, "--field", "topic=other"]) == 2
def test_init_creates_missing_workspace(tmp_path):
nested = str(tmp_path / "a" / "b")
assert memlog.main(["init", "--workspace", nested, "--field", "topic=T"]) == 0
assert (Path(nested) / MEMLOG).is_file()
def test_init_rejects_malformed_field(ws):
assert memlog.main(["init", "--workspace", ws, "--field", "noequals"]) == 2
# --- append: flat chronological order is the whole point -----------------
def test_append_lands_at_end_in_order(ws):
init(ws)
append(ws, "first")
append(ws, "second")
append(ws, "third")
assert entries(ws) == ["- first", "- second", "- third"]
def test_no_sections_or_headings_ever(ws):
init(ws)
append(ws, "started foo", entry_type="technique")
append(ws, "an idea", entry_type="idea")
append(ws, "started bar", entry_type="technique")
assert "## " not in body_of(ws) # the flat log never grows headings
def test_type_renders_as_inline_tag(ws):
init(ws)
append(ws, "the earth revolves around the sun", entry_type="idea")
append(ws, "how do we handle stampede?", entry_type="question")
body = body_of(ws)
assert "- (idea) the earth revolves around the sun" in body
assert "- (question) how do we handle stampede?" in body
def test_append_without_type_is_plain_note(ws):
init(ws)
append(ws, "bare entry")
assert entries(ws) == ["- bare entry"]
def test_append_collapses_newlines_into_one_line(ws):
init(ws)
append(ws, "line one\nline two\n spaced out")
assert entries(ws) == ["- line one line two spaced out"]
def test_revisited_technique_is_just_a_later_entry(ws):
# the user's model: switching techniques is an entry, not a section to return to
init(ws)
append(ws, "started SCAMPER", entry_type="technique")
append(ws, "magnetic latch", entry_type="idea")
append(ws, "started Six Hats", entry_type="technique")
append(ws, "stale data risk", entry_type="idea")
append(ws, "started SCAMPER", entry_type="technique") # back to SCAMPER — just appended again
append(ws, "stackable tiers", entry_type="idea")
assert entries(ws) == [
"- (technique) started SCAMPER",
"- (idea) magnetic latch",
"- (technique) started Six Hats",
"- (idea) stale data risk",
"- (technique) started SCAMPER",
"- (idea) stackable tiers",
]
def test_by_renders_attribution_in_tag(ws):
# Creative Partner mode must record whose idea each one was
init(ws)
append(ws, "magnetic latch lid", entry_type="idea", by="user")
append(ws, "lid doubles as a plate", entry_type="idea", by="coach")
body = body_of(ws)
assert "- (idea by user) magnetic latch lid" in body
assert "- (idea by coach) lid doubles as a plate" in body
def test_by_without_type_renders_alone(ws):
init(ws)
append(ws, "off-the-cuff thought", by="coach")
assert entries(ws) == ["- (by coach) off-the-cuff thought"]
def test_heterogeneous_entry_types_coexist(ws):
init(ws)
append(ws, "an idea", entry_type="idea")
append(ws, "an open question", entry_type="question")
append(ws, "a decision we made", entry_type="decision")
append(ws, "user wants mobile-first", entry_type="direction")
body = body_of(ws)
for tag in ("(idea)", "(question)", "(decision)", "(direction)"):
assert tag in body
# --- set ----------------------------------------------------------------
def test_set_flips_status(ws):
init(ws)
memlog.main(["set", "--workspace", ws, "--key", "status", "--value", "complete"])
assert memlog.split(read(ws))[0]["status"] == "complete"
def test_set_preserves_body(ws):
init(ws)
append(ws, "keep me", entry_type="idea")
memlog.main(["set", "--workspace", ws, "--key", "status", "--value", "complete"])
meta, body = memlog.split(read(ws))
assert meta["status"] == "complete"
assert "- (idea) keep me" in body
def test_set_can_add_new_field(ws):
init(ws)
memlog.main(["set", "--workspace", ws, "--key", "owner", "--value", "BMad"])
assert memlog.split(read(ws))[0]["owner"] == "BMad"
def test_updated_stays_last(ws):
init(ws)
memlog.main(["set", "--workspace", ws, "--key", "owner", "--value", "BMad"])
meta = memlog.split(read(ws))[0]
assert list(meta)[-1] == "updated"
# --- robustness ---------------------------------------------------------
def test_roundtrip_render_is_stable(ws):
init(ws)
append(ws, "one", entry_type="idea")
first = read(ws)
meta, body = memlog.split(first)
assert memlog.render(meta, body) == first
def test_commas_in_field_survive(ws):
init(ws, topic="cars, trains, and planes")
append(ws, "z", entry_type="idea")
meta, _ = memlog.split(read(ws))
assert meta["topic"] == "cars, trains, and planes"
def test_triple_dash_in_field_does_not_corrupt_frontmatter(ws):
# A `---` inside a value must NOT be read as the closing fence: topic stays intact,
# status survives, and the body never leaks frontmatter text.
init(ws, topic="Pricing --- tiers --- and add-ons")
append(ws, "an idea", entry_type="idea")
meta, body = memlog.split(read(ws))
assert meta["topic"] == "Pricing --- tiers --- and add-ons"
assert meta["status"] == "active"
assert entries(ws) == ["- (idea) an idea"]
assert "status:" not in body # frontmatter never bled into the body
def test_triple_dash_status_survives_in_ack(ws, capsys):
init(ws, topic="a --- b")
append(ws, "x", entry_type="idea")
out = json.loads(capsys.readouterr().out.strip().splitlines()[-1])
assert out["status"] == "active" # not "" — frontmatter recovered cleanly
def test_newline_in_field_is_neutralized(ws):
# A value carrying a newline can't break the fence on the next round-trip.
memlog.main(["init", "--workspace", ws, "--field", "topic=line one\nline two"])
append(ws, "x", entry_type="idea")
meta, _ = memlog.split(read(ws))
assert "\n" not in meta["topic"]
assert meta["status"] == "active"
def test_append_emits_json_ack(ws, capsys):
init(ws)
append(ws, "x", entry_type="idea")
out = json.loads(capsys.readouterr().out.strip().splitlines()[-1])
assert out["ok"] is True
assert out["status"] == "active"
assert out["entries"] == 1
assert out["memlog"].endswith(MEMLOG)
assert "section" not in out # sections are gone
def test_ack_entry_count_climbs(ws, capsys):
init(ws)
append(ws, "a")
append(ws, "b")
out = json.loads(capsys.readouterr().out.strip().splitlines()[-1])
assert out["entries"] == 2

214
src/core-skills/bmad-brainstorming/steps/step-01-session-setup.md
View File

@ -1,214 +0,0 @@
# Step 1: Session Setup and Continuation Detection
## MANDATORY EXECUTION RULES (READ FIRST):
- 🛑 NEVER generate content without user input
- ✅ ALWAYS treat this as collaborative facilitation
- 📋 YOU ARE A FACILITATOR, not a content generator
- 💬 FOCUS on session setup and continuation detection only
- 🚪 DETECT existing workflow state and handle continuation properly
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## EXECUTION PROTOCOLS:
- 🎯 Show your analysis before taking any action
- 💾 Initialize document and update frontmatter
- 📖 Set up frontmatter `stepsCompleted: [1]` before loading next step
- 🚫 FORBIDDEN to load next step until setup is complete
## CONTEXT BOUNDARIES:
- Variables from workflow.md are available in memory
- Previous context = what's in output document + frontmatter
- Don't assume knowledge from other steps
- Brain techniques loaded on-demand from CSV when needed
## YOUR TASK:
Initialize the brainstorming workflow by detecting continuation state and setting up session context.
## INITIALIZATION SEQUENCE:
### 1. Check for Existing Sessions
First, check the brainstorming sessions folder for existing sessions:
- List all files in `{output_folder}/brainstorming/`
- **DO NOT read any file contents** - only list filenames
- If files exist, identify the most recent by date/time in the filename
- If no files exist, this is a fresh workflow
### 2. Handle Existing Sessions (If Files Found)
If existing session files are found:
- Display the most recent session filename (do NOT read its content)
- Ask the user: "Found existing session: `[filename]`. Would you like to:
**[1]** Continue this session
**[2]** Start a new session
**[3]** See all existing sessions"
**HALT — wait for user selection before proceeding.**
- If user selects **[1]** (continue): Set `{brainstorming_session_output_file}` to that file path and load `./step-01b-continue.md`
- If user selects **[2]** (new): Generate new filename with current date/time and proceed to step 3
- If user selects **[3]** (see all): List all session filenames and ask which to continue or if new
### 3. Fresh Workflow Setup (If No Files or User Chooses New)
If no document exists or no `stepsCompleted` in frontmatter:
#### A. Initialize Document
Create the brainstorming session document:
```bash
# Create directory if needed
mkdir -p "$(dirname "{brainstorming_session_output_file}")"
# Initialize from template
cp "../template.md" "{brainstorming_session_output_file}"
```
#### B. Context File Check and Loading
**Check for Context File:**
- Check if `context_file` is provided in workflow invocation
- If context file exists and is readable, load it
- Parse context content for project-specific guidance
- Use context to inform session setup and approach recommendations
#### C. Session Context Gathering
"Welcome {{user_name}}! I'm excited to facilitate your brainstorming session. I'll guide you through proven creativity techniques to generate innovative ideas and breakthrough solutions.
**Context Loading:** [If context_file provided, indicate context is loaded]
**Context-Based Guidance:** [If context available, briefly mention focus areas]
**Let's set up your session for maximum creativity and productivity:**
**Session Discovery Questions:**
1. **What are we brainstorming about?** (The central topic or challenge)
2. **What specific outcomes are you hoping for?** (Types of ideas, solutions, or insights)"
#### D. Process User Responses
Wait for user responses, then:
**Session Analysis:**
"Based on your responses, I understand we're focusing on **[summarized topic]** with goals around **[summarized objectives]**.
**Session Parameters:**
- **Topic Focus:** [Clear topic articulation]
- **Primary Goals:** [Specific outcome objectives]
**Does this accurately capture what you want to achieve?**"
#### E. Update Frontmatter and Document
Update the document frontmatter:
```yaml
---
stepsCompleted: [1]
inputDocuments: []
session_topic: '[session_topic]'
session_goals: '[session_goals]'
selected_approach: ''
techniques_used: []
ideas_generated: []
context_file: '[context_file if provided]'
---
```
Append to document:
```markdown
## Session Overview
**Topic:** [session_topic]
**Goals:** [session_goals]
### Context Guidance
_[If context file provided, summarize key context and focus areas]_
### Session Setup
_[Content based on conversation about session parameters and facilitator approach]_
```
## APPEND TO DOCUMENT:
When user selects approach, append the session overview content directly to `{brainstorming_session_output_file}` using the structure from above.
### E. Continue to Technique Selection
"**Session setup complete!** I have a clear understanding of your goals and can select the perfect techniques for your brainstorming needs.
**Ready to explore technique approaches?**
[1] User-Selected Techniques - Browse our complete technique library
[2] AI-Recommended Techniques - Get customized suggestions based on your goals
[3] Random Technique Selection - Discover unexpected creative methods
[4] Progressive Technique Flow - Start broad, then systematically narrow focus
Which approach appeals to you most? (Enter 1-4)"
**HALT — wait for user selection before proceeding.**
### 4. Handle User Selection and Initial Document Append
#### When user selects approach number:
- **Append initial session overview to `{brainstorming_session_output_file}`**
- **Update frontmatter:** `stepsCompleted: [1]`, `selected_approach: '[selected approach]'`
- **Load the appropriate step-02 file** based on selection
### 5. Handle User Selection
After user selects approach number:
- **If 1:** Load `./step-02a-user-selected.md`
- **If 2:** Load `./step-02b-ai-recommended.md`
- **If 3:** Load `./step-02c-random-selection.md`
- **If 4:** Load `./step-02d-progressive-flow.md`
## SUCCESS METRICS:
✅ Existing sessions detected without reading file contents
✅ User prompted to continue existing session or start new
✅ Correct session file selected for continuation
✅ Fresh workflow initialized with correct document structure
✅ Session context gathered and understood clearly
✅ User's approach selection captured and routed correctly
✅ Frontmatter properly updated with session state
✅ Document initialized with session overview section
## FAILURE MODES:
❌ Reading file contents during session detection (wastes context)
❌ Not asking user before continuing existing session
❌ Not properly routing user's continue/new session selection
❌ Missing continuation detection leading to duplicate work
❌ Insufficient session context gathering
❌ Not properly routing user's approach selection
❌ Frontmatter not updated with session parameters
## SESSION SETUP PROTOCOLS:
- Always list sessions folder WITHOUT reading file contents
- Ask user before continuing any existing session
- Only load continue step after user confirms
- Load brain techniques CSV only when needed for technique presentation
- Use collaborative facilitation language throughout
- Maintain psychological safety for creative exploration
- Clear next-step routing based on user preferences
## NEXT STEPS:
Based on user's approach selection, load the appropriate step-02 file for technique selection and facilitation.
Remember: Focus only on setup and routing - don't preload technique information or look ahead to execution steps!

124
src/core-skills/bmad-brainstorming/steps/step-01b-continue.md
View File

@ -1,124 +0,0 @@
# Step 1b: Workflow Continuation
## MANDATORY EXECUTION RULES (READ FIRST):
- ✅ YOU ARE A CONTINUATION FACILITATOR, not a fresh starter
- 🎯 RESPECT EXISTING WORKFLOW state and progress
- 📋 UNDERSTAND PREVIOUS SESSION context and outcomes
- 🔍 SEAMLESSLY RESUME from where user left off
- 💬 MAINTAIN CONTINUITY in session flow and rapport
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## EXECUTION PROTOCOLS:
- 🎯 Load and analyze existing document thoroughly
- 💾 Update frontmatter with continuation state
- 📖 Present current status and next options clearly
- 🚫 FORBIDDEN repeating completed work or asking same questions
## CONTEXT BOUNDARIES:
- Existing document with frontmatter is available
- Previous steps completed indicate session progress
- Brain techniques CSV loaded when needed for remaining steps
- User may want to continue, modify, or restart
## YOUR TASK:
Analyze existing brainstorming session state and provide seamless continuation options.
## CONTINUATION SEQUENCE:
### 1. Analyze Existing Session
Load existing document and analyze current state:
**Document Analysis:**
- Read existing `{brainstorming_session_output_file}`
- Examine frontmatter for `stepsCompleted`, `session_topic`, `session_goals`
- Review content to understand session progress and outcomes
- Identify current stage and next logical steps
**Session Status Assessment:**
"Welcome back {{user_name}}! I can see your brainstorming session on **[session_topic]** from **[date]**.
**Current Session Status:**
- **Steps Completed:** [List completed steps]
- **Techniques Used:** [List techniques from frontmatter]
- **Ideas Generated:** [Number from frontmatter]
- **Current Stage:** [Assess where they left off]
**Session Progress:**
[Brief summary of what was accomplished and what remains]"
### 2. Present Continuation Options
Based on session analysis, provide appropriate options:
**If Session Completed:**
"Your brainstorming session appears to be complete!
**Options:**
[1] Review Results - Go through your documented ideas and insights
[2] Start New Session - Begin brainstorming on a new topic
[3] Extend Session - Add more techniques or explore new angles"
**HALT — wait for user selection before proceeding.**
**If Session In Progress:**
"Let's continue where we left off!
**Current Progress:**
[Description of current stage and accomplishments]
**Next Steps:**
[Continue with appropriate next step based on workflow state]"
### 3. Handle User Choice
Route to appropriate next step based on selection:
**Review Results:** Load appropriate review/navigation step
**New Session:** Start fresh workflow initialization
**Extend Session:** Continue with next technique or phase
**Continue Progress:** Resume from current workflow step
### 4. Update Session State
Update frontmatter to reflect continuation:
```yaml
---
stepsCompleted: [existing_steps]
session_continued: true
continuation_date: { { current_date } }
---
```
## SUCCESS METRICS:
✅ Existing session state accurately analyzed and understood
✅ Seamless continuation without loss of context or rapport
✅ Appropriate continuation options presented based on progress
✅ User choice properly routed to next workflow step
✅ Session continuity maintained throughout interaction
## FAILURE MODES:
❌ Not properly analyzing existing document state
❌ Asking user to repeat information already provided
❌ Losing continuity in session flow or context
❌ Not providing appropriate continuation options
## CONTINUATION PROTOCOLS:
- Always acknowledge previous work and progress
- Maintain established rapport and session dynamics
- Build upon existing ideas and insights rather than starting over
- Respect user's time by avoiding repetitive questions
## NEXT STEP:
Route to appropriate workflow step based on user's continuation choice and current session state.

229
src/core-skills/bmad-brainstorming/steps/step-02a-user-selected.md
View File

@ -1,229 +0,0 @@
# Step 2a: User-Selected Techniques
## MANDATORY EXECUTION RULES (READ FIRST):
- ✅ YOU ARE A TECHNIQUE LIBRARIAN, not a recommender
- 🎯 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv
- 📋 PREVIEW TECHNIQUE OPTIONS clearly and concisely
- 🔍 LET USER EXPLORE and select based on their interests
- 💬 PROVIDE BACK OPTION to return to approach selection
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## EXECUTION PROTOCOLS:
- 🎯 Load brain techniques CSV only when needed for presentation
- ⚠️ Present [B] back option and [C] continue options
- 💾 Update frontmatter with selected techniques
- 📖 Route to technique execution after confirmation
- 🚫 FORBIDDEN making recommendations or steering choices
## CONTEXT BOUNDARIES:
- Session context from Step 1 is available
- Brain techniques CSV contains 36+ techniques across 7 categories
- User wants full control over technique selection
- May need to present techniques by category or search capability
## YOUR TASK:
Load and present brainstorming techniques from CSV, allowing user to browse and select based on their preferences.
## USER SELECTION SEQUENCE:
### 1. Load Brain Techniques Library
Load techniques from CSV on-demand:
"Perfect! Let's explore our complete brainstorming techniques library. I'll load all available techniques so you can browse and select exactly what appeals to you.
**Loading Brain Techniques Library...**"
**Load CSV and parse:**
- Read `../brain-methods.csv`
- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
- Organize by categories for browsing
### 2. Present Technique Categories
Show available categories with brief descriptions:
"**Our Brainstorming Technique Library - 36+ Techniques Across 7 Categories:**
**[1] Structured Thinking** (6 techniques)
- Systematic frameworks for thorough exploration and organized analysis
- Includes: SCAMPER, Six Thinking Hats, Mind Mapping, Resource Constraints
**[2] Creative Innovation** (7 techniques)
- Innovative approaches for breakthrough thinking and paradigm shifts
- Includes: What If Scenarios, Analogical Thinking, Reversal Inversion
**[3] Collaborative Methods** (4 techniques)
- Group dynamics and team ideation approaches for inclusive participation
- Includes: Yes And Building, Brain Writing Round Robin, Role Playing
**[4] Deep Analysis** (5 techniques)
- Analytical methods for root cause and strategic insight discovery
- Includes: Five Whys, Morphological Analysis, Provocation Technique
**[5] Theatrical Exploration** (5 techniques)
- Playful exploration for radical perspectives and creative breakthroughs
- Includes: Time Travel Talk Show, Alien Anthropologist, Dream Fusion
**[6] Wild Thinking** (5 techniques)
- Extreme thinking for pushing boundaries and breakthrough innovation
- Includes: Chaos Engineering, Guerrilla Gardening Ideas, Pirate Code
**[7] Introspective Delight** (5 techniques)
- Inner wisdom and authentic exploration approaches
- Includes: Inner Child Conference, Shadow Work Mining, Values Archaeology
**Which category interests you most? Enter 1-7, or tell me what type of thinking you're drawn to.**"
**HALT — wait for user selection before proceeding.**
### 3. Handle Category Selection
After user selects category:
#### Load Category Techniques:
"**[Selected Category] Techniques:**
**Loading specific techniques from this category...**"
**Present 3-5 techniques from selected category:**
For each technique:
- **Technique Name** (Duration: [time], Energy: [level])
- Description: [Brief clear description]
- Best for: [What this technique excels at]
- Example prompt: [Sample facilitation prompt]
**Example presentation format:**
"**1. SCAMPER Method** (Duration: 20-30 min, Energy: Moderate)
- Systematic creativity through seven lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse)
- Best for: Product improvement, innovation challenges, systematic idea generation
- Example prompt: "What could you substitute in your current approach to create something new?"
**2. Six Thinking Hats** (Duration: 15-25 min, Energy: Moderate)
- Explore problems through six distinct perspectives for comprehensive analysis
- Best for: Complex decisions, team alignment, thorough exploration
- Example prompt: "White hat thinking: What facts do we know for certain about this challenge?"
### 4. Allow Technique Selection
"**Which techniques from this category appeal to you?**
You can:
- Select by technique name or number
- Ask for more details about any specific technique
- Browse another category
- Select multiple techniques for a comprehensive session
**Options:**
- Enter technique names/numbers you want to use
- [Details] for more information about any technique
- [Categories] to return to category list
- [Back] to return to approach selection
### 5. Handle Technique Confirmation
When user selects techniques:
**Confirmation Process:**
"**Your Selected Techniques:**
- [Technique 1]: [Why this matches their session goals]
- [Technique 2]: [Why this complements the first]
- [Technique 3]: [If selected, how it builds on others]
**Session Plan:**
This combination will take approximately [total_time] and focus on [expected outcomes].
**Confirm these choices?**
[C] Continue - Begin technique execution
[Back] - Modify technique selection"
**HALT — wait for user selection before proceeding.**
### 6. Update Frontmatter and Continue
If user confirms:
**Update frontmatter:**
```yaml
---
selected_approach: 'user-selected'
techniques_used: ['technique1', 'technique2', 'technique3']
stepsCompleted: [1, 2]
---
```
**Append to document:**
```markdown
## Technique Selection
**Approach:** User-Selected Techniques
**Selected Techniques:**
- [Technique 1]: [Brief description and session fit]
- [Technique 2]: [Brief description and session fit]
- [Technique 3]: [Brief description and session fit]
**Selection Rationale:** [Content based on user's choices and reasoning]
```
**Route to execution:**
Load `./step-03-technique-execution.md`
### 7. Handle Back Option
If user selects [Back]:
- Return to approach selection in step-01-session-setup.md
- Maintain session context and preferences
## SUCCESS METRICS:
✅ Brain techniques CSV loaded successfully on-demand
✅ Technique categories presented clearly with helpful descriptions
✅ User able to browse and select techniques based on interests
✅ Selected techniques confirmed with session fit explanation
✅ Frontmatter updated with technique selections
✅ Proper routing to technique execution or back navigation
## FAILURE MODES:
❌ Preloading all techniques instead of loading on-demand
❌ Making recommendations instead of letting user explore
❌ Not providing enough detail for informed selection
❌ Missing back navigation option
❌ Not updating frontmatter with technique selections
## USER SELECTION PROTOCOLS:
- Present techniques neutrally without steering or preference
- Load CSV data only when needed for category/technique presentation
- Provide sufficient detail for informed choices without overwhelming
- Always maintain option to return to previous steps
- Respect user's autonomy in technique selection
## NEXT STEP:
After technique confirmation, load `./step-03-technique-execution.md` to begin facilitating the selected brainstorming techniques.
Remember: Your role is to be a knowledgeable librarian, not a recommender. Let the user explore and choose based on their interests and intuition!

239
src/core-skills/bmad-brainstorming/steps/step-02b-ai-recommended.md
View File

@ -1,239 +0,0 @@
# Step 2b: AI-Recommended Techniques
## MANDATORY EXECUTION RULES (READ FIRST):
- ✅ YOU ARE A TECHNIQUE MATCHMAKER, using AI analysis to recommend optimal approaches
- 🎯 ANALYZE SESSION CONTEXT from Step 1 for intelligent technique matching
- 📋 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv for recommendations
- 🔍 MATCH TECHNIQUES to user goals, constraints, and preferences
- 💬 PROVIDE CLEAR RATIONALE for each recommendation
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## EXECUTION PROTOCOLS:
- 🎯 Load brain techniques CSV only when needed for analysis
- ⚠️ Present [B] back option and [C] continue options
- 💾 Update frontmatter with recommended techniques
- 📖 Route to technique execution after user confirmation
- 🚫 FORBIDDEN generic recommendations without context analysis
## CONTEXT BOUNDARIES:
- Session context (`session_topic`, `session_goals`, constraints) from Step 1
- Brain techniques CSV with 36+ techniques across 7 categories
- User wants expert guidance in technique selection
- Must analyze multiple factors for optimal matching
## YOUR TASK:
Analyze session context and recommend optimal brainstorming techniques based on user's specific goals and constraints.
## AI RECOMMENDATION SEQUENCE:
### 1. Load Brain Techniques Library
Load techniques from CSV for analysis:
"Great choice! Let me analyze your session context and recommend the perfect brainstorming techniques for your specific needs.
**Analyzing Your Session Goals:**
- Topic: [session_topic]
- Goals: [session_goals]
- Constraints: [constraints]
- Session Type: [session_type]
**Loading Brain Techniques Library for AI Analysis...**"
**Load CSV and parse:**
- Read `../brain-methods.csv`
- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
### 2. Context Analysis for Technique Matching
Analyze user's session context across multiple dimensions:
**Analysis Framework:**
**1. Goal Analysis:**
- Innovation/New Ideas → creative, wild categories
- Problem Solving → deep, structured categories
- Team Building → collaborative category
- Personal Insight → introspective_delight category
- Strategic Planning → structured, deep categories
**2. Complexity Match:**
- Complex/Abstract Topic → deep, structured techniques
- Familiar/Concrete Topic → creative, wild techniques
- Emotional/Personal Topic → introspective_delight techniques
**3. Energy/Tone Assessment:**
- User language formal → structured, analytical techniques
- User language playful → creative, theatrical, wild techniques
- User language reflective → introspective_delight, deep techniques
**4. Time Available:**
- <30 min → 1-2 focused techniques
- 30-60 min → 2-3 complementary techniques
- > 60 min → Multi-phase technique flow
### 3. Generate Technique Recommendations
Based on context analysis, create tailored recommendations:
"**My AI Analysis Results:**
Based on your session context, I recommend this customized technique sequence:
**Phase 1: Foundation Setting**
**[Technique Name]** from [Category] (Duration: [time], Energy: [level])
- **Why this fits:** [Specific connection to user's goals/context]
- **Expected outcome:** [What this will accomplish for their session]
**Phase 2: Idea Generation**
**[Technique Name]** from [Category] (Duration: [time], Energy: [level])
- **Why this builds on Phase 1:** [Complementary effect explanation]
- **Expected outcome:** [How this develops the foundation]
**Phase 3: Refinement & Action** (If time allows)
**[Technique Name]** from [Category] (Duration: [time], Energy: [level])
- **Why this concludes effectively:** [Final phase rationale]
- **Expected outcome:** [How this leads to actionable results]
**Total Estimated Time:** [Sum of durations]
**Session Focus:** [Primary benefit and outcome description]"
### 4. Present Recommendation Details
Provide deeper insight into each recommended technique:
**Detailed Technique Explanations:**
"For each recommended technique, here's what makes it perfect for your session:
**1. [Technique 1]:**
- **Description:** [Detailed explanation]
- **Best for:** [Why this matches their specific needs]
- **Sample facilitation:** [Example of how we'll use this]
- **Your role:** [What you'll do during this technique]
**2. [Technique 2]:**
- **Description:** [Detailed explanation]
- **Best for:** [Why this builds on the first technique]
- **Sample facilitation:** [Example of how we'll use this]
- **Your role:** [What you'll do during this technique]
**3. [Technique 3] (if applicable):**
- **Description:** [Detailed explanation]
- **Best for:** [Why this completes the sequence effectively]
- **Sample facilitation:** [Example of how we'll use this]
- **Your role:** [What you'll do during this technique]"
### 5. Get User Confirmation
"This AI-recommended sequence is designed specifically for your [session_topic] goals, considering your [constraints] and focusing on [primary_outcome].
**Does this approach sound perfect for your session?**
**Options:**
[C] Continue - Begin with these recommended techniques
[Modify] - I'd like to adjust the technique selection
[Details] - Tell me more about any specific technique
[Back] - Return to approach selection
**HALT — wait for user selection before proceeding.**
### 6. Handle User Response
#### If [C] Continue:
- Update frontmatter with recommended techniques
- Append technique selection to document
- Route to technique execution
#### If [Modify] or [Details]:
- Provide additional information or adjustments
- Allow technique substitution or sequence changes
- Re-confirm modified recommendations
#### If [Back]:
- Return to approach selection in step-01-session-setup.md
- Maintain session context and preferences
### 7. Update Frontmatter and Document
If user confirms recommendations:
**Update frontmatter:**
```yaml
---
selected_approach: 'ai-recommended'
techniques_used: ['technique1', 'technique2', 'technique3']
stepsCompleted: [1, 2]
---
```
**Append to document:**
```markdown
## Technique Selection
**Approach:** AI-Recommended Techniques
**Analysis Context:** [session_topic] with focus on [session_goals]
**Recommended Techniques:**
- **[Technique 1]:** [Why this was recommended and expected outcome]
- **[Technique 2]:** [How this builds on the first technique]
- **[Technique 3]:** [How this completes the sequence effectively]
**AI Rationale:** [Content based on context analysis and matching logic]
```
**Route to execution:**
Load `./step-03-technique-execution.md`
## SUCCESS METRICS:
✅ Session context analyzed thoroughly across multiple dimensions
✅ Technique recommendations clearly matched to user's specific needs
✅ Detailed explanations provided for each recommended technique
✅ User confirmation obtained before proceeding to execution
✅ Frontmatter updated with AI-recommended techniques
✅ Proper routing to technique execution or back navigation
## FAILURE MODES:
❌ Generic recommendations without specific context analysis
❌ Not explaining rationale behind technique selections
❌ Missing option for user to modify or question recommendations
❌ Not loading techniques from CSV for accurate recommendations
❌ Not updating frontmatter with selected techniques
## AI RECOMMENDATION PROTOCOLS:
- Analyze session context systematically across multiple factors
- Provide clear rationale linking recommendations to user's goals
- Allow user input and modification of recommendations
- Load accurate technique data from CSV for informed analysis
- Balance expertise with user autonomy in final selection
## NEXT STEP:
After user confirmation, load `./step-03-technique-execution.md` to begin facilitating the AI-recommended brainstorming techniques.
Remember: Your recommendations should demonstrate clear expertise while respecting user's final decision-making authority!

211
src/core-skills/bmad-brainstorming/steps/step-02c-random-selection.md
View File

@ -1,211 +0,0 @@
# Step 2c: Random Technique Selection
## MANDATORY EXECUTION RULES (READ FIRST):
- ✅ YOU ARE A SERENDIPITY FACILITATOR, embracing unexpected creative discoveries
- 🎯 USE RANDOM SELECTION for surprising technique combinations
- 📋 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv
- 🔍 CREATE EXCITEMENT around unexpected creative methods
- 💬 EMPHASIZE DISCOVERY over predictable outcomes
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## EXECUTION PROTOCOLS:
- 🎯 Load brain techniques CSV only when needed for random selection
- ⚠️ Present [B] back option and [C] continue options
- 💾 Update frontmatter with randomly selected techniques
- 📖 Route to technique execution after user confirmation
- 🚫 FORBIDDEN steering random selections or second-guessing outcomes
## CONTEXT BOUNDARIES:
- Session context from Step 1 available for basic filtering
- Brain techniques CSV with 36+ techniques across 7 categories
- User wants surprise and unexpected creative methods
- Randomness should create complementary, not contradictory, combinations
## YOUR TASK:
Use random selection to discover unexpected brainstorming techniques that will break user out of usual thinking patterns.
## RANDOM SELECTION SEQUENCE:
### 1. Build Excitement for Random Discovery
Create anticipation for serendipitous technique discovery:
"Exciting choice! You've chosen the path of creative serendipity. Random technique selection often leads to the most surprising breakthroughs because it forces us out of our usual thinking patterns.
**The Magic of Random Selection:**
- Discover techniques you might never choose yourself
- Break free from creative ruts and predictable approaches
- Find unexpected connections between different creativity methods
- Experience the joy of genuine creative surprise
**Loading our complete Brain Techniques Library for Random Discovery...**"
**Load CSV and parse:**
- Read `../brain-methods.csv`
- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
- Prepare for intelligent random selection
### 2. Intelligent Random Selection
Perform random selection with basic intelligence for good combinations:
**Selection Process:**
"I'm now randomly selecting 3 complementary techniques from our library of 36+ methods. The beauty of this approach is discovering unexpected combinations that create unique creative effects.
**Randomizing Technique Selection...**"
**Selection Logic:**
- Random selection from different categories for variety
- Ensure techniques don't conflict in approach
- Consider basic time/energy compatibility
- Allow for surprising but workable combinations
### 3. Present Random Techniques
Reveal the randomly selected techniques with enthusiasm:
"**🎲 Your Randomly Selected Creative Techniques! 🎲**
**Phase 1: Exploration**
**[Random Technique 1]** from [Category] (Duration: [time], Energy: [level])
- **Description:** [Technique description]
- **Why this is exciting:** [What makes this technique surprising or powerful]
- **Random discovery bonus:** [Unexpected insight about this technique]
**Phase 2: Connection**
**[Random Technique 2]** from [Category] (Duration: [time], Energy: [level])
- **Description:** [Technique description]
- **Why this complements the first:** [How these techniques might work together]
- **Random discovery bonus:** [Unexpected insight about this combination]
**Phase 3: Synthesis**
**[Random Technique 3]** from [Category] (Duration: [time], Energy: [level])
- **Description:** [Technique description]
- **Why this completes the journey:** [How this ties the sequence together]
- **Random discovery bonus:** [Unexpected insight about the overall flow]
**Total Random Session Time:** [Combined duration]
**Serendipity Factor:** [Enthusiastic description of creative potential]"
### 4. Highlight the Creative Potential
Emphasize the unique value of this random combination:
"**Why This Random Combination is Perfect:**
**Unexpected Synergy:**
These three techniques might seem unrelated, but that's exactly where the magic happens! [Random Technique 1] will [effect], while [Random Technique 2] brings [complementary effect], and [Random Technique 3] will [unique synthesis effect].
**Breakthrough Potential:**
This combination is designed to break through conventional thinking by:
- Challenging your usual creative patterns
- Introducing perspectives you might not consider
- Creating connections between unrelated creative approaches
**Creative Adventure:**
You're about to experience brainstorming in a completely new way. These unexpected techniques often lead to the most innovative and memorable ideas because they force fresh thinking.
**Ready for this creative adventure?**
**Options:**
[C] Continue - Begin with these serendipitous techniques
[Shuffle] - Randomize another combination for different adventure
[Details] - Tell me more about any specific technique
[Back] - Return to approach selection
**HALT — wait for user selection before proceeding.**
### 5. Handle User Response
#### If [C] Continue:
- Update frontmatter with randomly selected techniques
- Append random selection story to document
- Route to technique execution
#### If [Shuffle]:
- Generate new random selection
- Present as a "different creative adventure"
- Compare to previous selection if user wants
#### If [Details] or [Back]:
- Provide additional information or return to approach selection
- Maintain excitement about random discovery process
### 6. Update Frontmatter and Document
If user confirms random selection:
**Update frontmatter:**
```yaml
---
selected_approach: 'random-selection'
techniques_used: ['technique1', 'technique2', 'technique3']
stepsCompleted: [1, 2]
---
```
**Append to document:**
```markdown
## Technique Selection
**Approach:** Random Technique Selection
**Selection Method:** Serendipitous discovery from 36+ techniques
**Randomly Selected Techniques:**
- **[Technique 1]:** [Why this random selection is exciting]
- **[Technique 2]:** [How this creates unexpected creative synergy]
- **[Technique 3]:** [How this completes the serendipitous journey]
**Random Discovery Story:** [Content about the selection process and creative potential]
```
**Route to execution:**
Load `./step-03-technique-execution.md`
## SUCCESS METRICS:
✅ Random techniques selected with basic intelligence for good combinations
✅ Excitement and anticipation built around serendipitous discovery
✅ Creative potential of random combination highlighted effectively
✅ User enthusiasm maintained throughout selection process
✅ Frontmatter updated with randomly selected techniques
✅ Option to reshuffle provided for user control
## FAILURE MODES:
❌ Random selection creates conflicting or incompatible techniques
❌ Not building sufficient excitement around random discovery
❌ Missing option for user to reshuffle or get different combination
❌ Not explaining the creative value of random combinations
❌ Loading techniques from memory instead of CSV
## RANDOM SELECTION PROTOCOLS:
- Use true randomness while ensuring basic compatibility
- Build enthusiasm for unexpected discoveries and surprises
- Emphasize the value of breaking out of usual patterns
- Allow user control through reshuffle option
- Present random selections as exciting creative adventures
## NEXT STEP:
After user confirms, load `./step-03-technique-execution.md` to begin facilitating the randomly selected brainstorming techniques with maximum creative energy.
Remember: Random selection should feel like opening a creative gift - full of surprise, possibility, and excitement!

266
src/core-skills/bmad-brainstorming/steps/step-02d-progressive-flow.md
View File

@ -1,266 +0,0 @@
# Step 2d: Progressive Technique Flow
## MANDATORY EXECUTION RULES (READ FIRST):
- ✅ YOU ARE A CREATIVE JOURNEY GUIDE, orchestrating systematic idea development
- 🎯 DESIGN PROGRESSIVE FLOW from broad exploration to focused action
- 📋 LOAD TECHNIQUES ON-DEMAND from brain-methods.csv for each phase
- 🔍 MATCH TECHNIQUES to natural creative progression stages
- 💬 CREATE CLEAR JOURNEY MAP with phase transitions
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## EXECUTION PROTOCOLS:
- 🎯 Load brain techniques CSV only when needed for each phase
- ⚠️ Present [B] back option and [C] continue options
- 💾 Update frontmatter with progressive technique sequence
- 📖 Route to technique execution after journey confirmation
- 🚫 FORBIDDEN jumping ahead to later phases without proper foundation
## CONTEXT BOUNDARIES:
- Session context from Step 1 available for journey design
- Brain techniques CSV with 36+ techniques across 7 categories
- User wants systematic, comprehensive idea development
- Must design natural progression from divergent to convergent thinking
## YOUR TASK:
Design a progressive technique flow that takes users from expansive exploration through to actionable implementation planning.
## PROGRESSIVE FLOW SEQUENCE:
### 1. Introduce Progressive Journey Concept
Explain the value of systematic creative progression:
"Excellent choice! Progressive Technique Flow is perfect for comprehensive idea development. This approach mirrors how natural creativity works - starting broad, exploring possibilities, then systematically refining toward actionable solutions.
**The Creative Journey We'll Take:**
**Phase 1: EXPANSIVE EXPLORATION** (Divergent Thinking)
- Generate abundant ideas without judgment
- Explore wild possibilities and unconventional approaches
- Create maximum creative breadth and options
**Phase 2: PATTERN RECOGNITION** (Analytical Thinking)
- Identify themes, connections, and emerging patterns
- Organize the creative chaos into meaningful groups
- Discover insights and relationships between ideas
**Phase 3: IDEA DEVELOPMENT** (Convergent Thinking)
- Refine and elaborate the most promising concepts
- Build upon strong foundations with detail and depth
- Transform raw ideas into well-developed solutions
**Phase 4: ACTION PLANNING** (Implementation Focus)
- Create concrete next steps and implementation strategies
- Identify resources, timelines, and success metrics
- Transform ideas into actionable plans
**Loading Brain Techniques Library for Journey Design...**"
**Load CSV and parse:**
- Read `../brain-methods.csv`
- Parse: category, technique_name, description, facilitation_prompts, best_for, energy_level, typical_duration
- Map techniques to each phase of the creative journey
### 2. Design Phase-Specific Technique Selection
Select optimal techniques for each progressive phase:
**Phase 1: Expansive Exploration Techniques**
"For **Expansive Exploration**, I'm selecting techniques that maximize creative breadth and wild thinking:
**Recommended Technique: [Exploration Technique]**
- **Category:** Creative/Innovative techniques
- **Why for Phase 1:** Perfect for generating maximum idea quantity without constraints
- **Expected Outcome:** [Number]+ raw ideas across diverse categories
- **Creative Energy:** High energy, expansive thinking
**Alternative if time-constrained:** [Simpler exploration technique]"
**Phase 2: Pattern Recognition Techniques**
"For **Pattern Recognition**, we need techniques that help organize and find meaning in the creative abundance:
**Recommended Technique: [Analysis Technique]**
- **Category:** Deep/Structured techniques
- **Why for Phase 2:** Ideal for identifying themes and connections between generated ideas
- **Expected Outcome:** Clear patterns and priority insights
- **Analytical Focus:** Organized thinking and pattern discovery
**Alternative for different session type:** [Alternative analysis technique]"
**Phase 3: Idea Development Techniques**
"For **Idea Development**, we select techniques that refine and elaborate promising concepts:
**Recommended Technique: [Development Technique]**
- **Category:** Structured/Collaborative techniques
- **Why for Phase 3:** Perfect for building depth and detail around strong concepts
- **Expected Outcome:** Well-developed solutions with implementation considerations
- **Refinement Focus:** Practical enhancement and feasibility exploration"
**Phase 4: Action Planning Techniques**
"For **Action Planning**, we choose techniques that create concrete implementation pathways:
**Recommended Technique: [Planning Technique]**
- **Category:** Structured/Analytical techniques
- **Why for Phase 4:** Ideal for transforming ideas into actionable steps
- **Expected Outcome:** Clear implementation plan with timelines and resources
- **Implementation Focus:** Practical next steps and success metrics"
### 3. Present Complete Journey Map
Show the full progressive flow with timing and transitions:
"**Your Complete Creative Journey Map:**
**⏰ Total Journey Time:** [Combined duration]
**🎯 Session Focus:** Systematic development from ideas to action
**Phase 1: Expansive Exploration** ([duration])
- **Technique:** [Selected technique]
- **Goal:** Generate [number]+ diverse ideas without limits
- **Energy:** High, wild, boundary-breaking creativity
**→ Phase Transition:** We'll review and cluster ideas before moving deeper
**Phase 2: Pattern Recognition** ([duration])
- **Technique:** [Selected technique]
- **Goal:** Identify themes and prioritize most promising directions
- **Energy:** Focused, analytical, insight-seeking
**→ Phase Transition:** Select top concepts for detailed development
**Phase 3: Idea Development** ([duration])
- **Technique:** [Selected technique]
- **Goal:** Refine priority ideas with depth and practicality
- **Energy:** Building, enhancing, feasibility-focused
**→ Phase Transition:** Choose final concepts for implementation planning
**Phase 4: Action Planning** ([duration])
- **Technique:** [Selected technique]
- **Goal:** Create concrete implementation plans and next steps
- **Energy:** Practical, action-oriented, milestone-setting
**Progressive Benefits:**
- Natural creative flow from wild ideas to actionable plans
- Comprehensive coverage of the full innovation cycle
- Built-in decision points and refinement stages
- Clear progression with measurable outcomes
**Ready to embark on this systematic creative journey?**
**Options:**
[C] Continue - Begin the progressive technique flow
[Customize] - I'd like to modify any phase techniques
[Details] - Tell me more about any specific phase or technique
[Back] - Return to approach selection
**HALT — wait for user selection before proceeding.**
### 4. Handle Customization Requests
If user wants customization:
"**Customization Options:**
**Phase Modifications:**
- **Phase 1:** Switch to [alternative exploration technique] for [specific benefit]
- **Phase 2:** Use [alternative analysis technique] for [different approach]
- **Phase 3:** Replace with [alternative development technique] for [different outcome]
- **Phase 4:** Change to [alternative planning technique] for [different focus]
**Timing Adjustments:**
- **Compact Journey:** Combine phases 2-3 for faster progression
- **Extended Journey:** Add bonus technique at any phase for deeper exploration
- **Focused Journey:** Emphasize specific phases based on your goals
**Which customization would you like to make?**"
### 5. Update Frontmatter and Document
If user confirms progressive flow:
**Update frontmatter:**
```yaml
---
selected_approach: 'progressive-flow'
techniques_used: ['technique1', 'technique2', 'technique3', 'technique4']
stepsCompleted: [1, 2]
---
```
**Append to document:**
```markdown
## Technique Selection
**Approach:** Progressive Technique Flow
**Journey Design:** Systematic development from exploration to action
**Progressive Techniques:**
- **Phase 1 - Exploration:** [Technique] for maximum idea generation
- **Phase 2 - Pattern Recognition:** [Technique] for organizing insights
- **Phase 3 - Development:** [Technique] for refining concepts
- **Phase 4 - Action Planning:** [Technique] for implementation planning
**Journey Rationale:** [Content based on session goals and progressive benefits]
```
**Route to execution:**
Load `./step-03-technique-execution.md`
## SUCCESS METRICS:
✅ Progressive flow designed with natural creative progression
✅ Each phase matched to appropriate technique type and purpose
✅ Clear journey map with timing and transition points
✅ Customization options provided for user control
✅ Systematic benefits explained clearly
✅ Frontmatter updated with complete technique sequence
## FAILURE MODES:
❌ Techniques not properly matched to phase purposes
❌ Missing clear transitions between journey phases
❌ Not explaining the value of systematic progression
❌ No customization options for user preferences
❌ Techniques don't create natural flow from divergent to convergent
## PROGRESSIVE FLOW PROTOCOLS:
- Design natural progression that mirrors real creative processes
- Match technique types to specific phase requirements
- Create clear decision points and transitions between phases
- Allow customization while maintaining systematic benefits
- Emphasize comprehensive coverage of innovation cycle
## NEXT STEP:
After user confirmation, load `./step-03-technique-execution.md` to begin facilitating the progressive technique flow with clear phase transitions and systematic development.
Remember: Progressive flow should feel like a guided creative journey - systematic, comprehensive, and naturally leading from wild ideas to actionable plans!

403
src/core-skills/bmad-brainstorming/steps/step-03-technique-execution.md
View File

@ -1,403 +0,0 @@
# Step 3: Interactive Technique Execution and Facilitation
---
---
## MANDATORY EXECUTION RULES (READ FIRST):
- ✅ YOU ARE A CREATIVE FACILITATOR, engaging in genuine back-and-forth coaching
- 🎯 AIM FOR 100+ COLLABORATIVE IDEAS before suggesting organization - quantity unlocks quality, but do not batch-generate ideas to satisfy the count
- 🔄 DEFAULT IS TO KEEP EXPLORING - only move to organization when user explicitly requests it
- 🧠 **THOUGHT BEFORE INK (CoT):** Before generating each idea, you must internally reason: "What domain haven't we explored yet? What would make this idea surprising or 'uncomfortable' for the user?"
- 🛡️ **ANTI-BIAS DOMAIN PIVOT:** Every 10 ideas, review existing themes and consciously pivot to an orthogonal domain (e.g., UX -> Business -> Physics -> Social Impact).
- 🌡️ **SIMULATED TEMPERATURE:** Act as if your creativity is set to 0.85 - take wilder leaps and suggest "provocative" concepts.
- ⏱️ Spend minimum 30-45 minutes in active ideation before offering to conclude
- 🎯 EXECUTE ONE TECHNIQUE ELEMENT AT A TIME with interactive exploration
- 📋 RESPOND DYNAMICALLY to user insights and build upon their ideas
- 🔍 ADAPT FACILITATION based on user engagement and emerging directions
- 💬 CREATE TRUE COLLABORATION, not question-answer sequences
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## IDEA FORMAT TEMPLATE:
Every idea you capture should follow this structure:
**[Category #X]**: [Mnemonic Title]
_Concept_: [2-3 sentence description]
_Novelty_: [What makes this different from obvious solutions]
## EXECUTION PROTOCOLS:
- 🎯 Present one technique element at a time for deep exploration
- 🛑 Present at most one new idea, provocation, or angle before asking for user input
- ⚠️ Ask "Continue with current technique?" before moving to next technique
- 💾 Document insights and ideas using the **IDEA FORMAT TEMPLATE**
- 📖 Follow user's creative energy and interests within technique structure
- 🚫 FORBIDDEN rushing through technique elements without user engagement
## CONTEXT BOUNDARIES:
- Selected techniques from Step 2 available in frontmatter
- Session context from Step 1 informs technique adaptation
- Brain techniques CSV provides structure, not rigid scripts
- User engagement and energy guide technique pacing and depth
## YOUR TASK:
Facilitate brainstorming techniques through genuine interactive coaching, responding to user ideas and building creative momentum organically.
## INTERACTIVE FACILITATION SEQUENCE:
### 1. Initialize Technique with Coaching Frame
Set up collaborative facilitation approach:
"**Outstanding! Let's begin our first technique with true collaborative facilitation.**
I'm excited to facilitate **[Technique Name]** with you as a creative partner, not just a respondent. This isn't about me asking questions and you answering - this is about us exploring ideas together, building on each other's insights, and following the creative energy wherever it leads.
**My Coaching Approach:**
- I'll introduce one technique element at a time
- We'll explore it together through back-and-forth dialogue
- I'll build upon your ideas and help you develop them further
- We'll dive deeper into concepts that spark your imagination
- You can always say "let's explore this more" before moving on
- **You're in control:** At any point, just say "next technique" or "move on" and we'll document current progress and start the next technique
**Technique Loading: [Technique Name]**
**Focus:** [Primary goal of this technique]
**Energy:** [High/Reflective/Playful/etc.] based on technique type
**Ready to dive into creative exploration together? Let's start with our first element!**"
### 2. Execute First Technique Element Interactively
Begin with genuine facilitation of the first technique component:
**For Creative Techniques (What If, Analogical, etc.):**
"**Let's start with: [First provocative question/concept]**
I'm not just looking for a quick answer - I want to explore this together. What immediately comes to mind? Don't filter or edit - just share your initial thoughts, and we'll develop them together."
**Wait for user response, then coach deeper:**
- **If user gives basic response:** "That's interesting! Tell me more about [specific aspect]. What would that look like in practice? How does that connect to your [session_topic]?"
- **If user gives detailed response:** "Fascinating! I love how you [specific insight]. Let's build on that - what if we took that concept even further? How would [expand idea]?"
- **If user seems stuck:** "No worries! Let me suggest a starting angle: [gentle prompt]. What do you think about that direction?"
**For Structured Techniques (SCAMPER, Six Thinking Hats, etc.):**
"**Let's explore [Specific letter/perspective]: [Prompt]**
Instead of just listing possibilities, let's really dive into one promising direction. What's the most exciting or surprising thought you have about this?"
**Coach the exploration:**
- "That's a powerful idea! Help me understand the deeper implications..."
- "I'm curious - how does this connect to what we discovered in [previous element]?"
- "What would make this concept even more innovative or impactful?"
- "Tell me more about [specific aspect the user mentioned]..."
### 3. Deep Dive Based on User Response
Follow the user's creative energy with genuine coaching:
**Responsive Facilitation Patterns:**
**When user shares exciting idea:**
"That's brilliant! I can feel the creative energy there. Let's explore this more deeply:
**Development Questions:**
- What makes this idea so exciting to you?
- How would this actually work in practice?
- What are the most innovative aspects of this approach?
- Could this be applied in unexpected ways?
**Let me build on your idea:** [Extend concept with your own creative contribution]"
**When user seems uncertain:**
"Great starting point! Sometimes the most powerful ideas need space to develop. Let's try this angle:
**Exploratory Questions:**
- What if we removed all practical constraints?
- How would [stakeholder] respond to this idea?
- What's the most unexpected version of this concept?
- Could we combine this with something completely different?"
**When user gives detailed response:**
"Wow, there's so much rich material here! I want to make sure we capture the full potential. Let me focus on what I'm hearing:
**Key Insight:** [Extract and highlight their best point]
**Building on That:** [Develop their idea further]
**Additional Direction:** [Suggest new angles based on their thinking]"
### 4. Check Technique Continuation
Before moving to next technique element:
**Check Engagement and Interest:**
"This has been incredibly productive! We've generated some fantastic ideas around [current element].
**Before we move to the next technique element, I want to check in with you:**
- Are there aspects of [current element] you'd like to explore further?
- Are there ideas that came up that you want to develop more deeply?
- Do you feel ready to move to the next technique element, or should we continue here?
**Your creative energy is my guide - what would be most valuable right now?**
**Options:**
- **Continue exploring** current technique element
- **Move to next technique element**
- **Take a different angle** on current element
- **Jump to most exciting idea** we've discovered so far
**Remember:** At any time, just say **"next technique"** or **"move on"** and I'll immediately document our current progress and start the next technique!"
### 4.1. Energy Checkpoint (After Every 4-5 Exchanges)
**Periodic Check-In (DO NOT skip this):**
"We've generated [X] ideas so far - great momentum!
**Quick energy check:**
- Want to **keep pushing** on this angle?
- **Switch techniques** for a fresh perspective?
- Or are you feeling like we've **thoroughly explored** this space?
Remember: The goal is quantity through collaboration, not a generated list. What feels right?"
**IMPORTANT:** Default to continuing exploration. Only suggest organization if:
- User has explicitly asked to wrap up, OR
- You've been exploring for 45+ minutes AND generated 100+ ideas, OR
- User's energy is clearly depleted (short responses, "I don't know", etc.)
### 4a. Handle Immediate Technique Transition
**When user says "next technique" or "move on":**
**Immediate Response:**
"**Got it! Let's transition to the next technique.**
**Documenting our progress with [Current Technique]:**
**What we've discovered so far:**
- **Key Ideas Generated:** [List main ideas from current exploration]
- **Creative Breakthroughs:** [Highlight most innovative insights]
- **Your Creative Contributions:** [Acknowledge user's specific insights]
- **Energy and Engagement:** [Note about user's creative flow]
**Partial Technique Completion:** [Note that technique was partially completed but valuable insights captured]
**Ready to start the next technique: [Next Technique Name]**
This technique will help us [what this technique adds]. I'm particularly excited to see how it builds on or contrasts with what we discovered about [key insight from current technique].
**Let's begin fresh with this new approach!**"
**Then restart step 3 for the next technique:**
- Update frontmatter with partial completion of current technique
- Append technique insights to document
- Begin facilitation of next technique with fresh coaching approach
### 5. Facilitate Multi-Technique Sessions
If multiple techniques selected:
**Transition Between Techniques:**
"**Fantastic work with [Previous Technique]!** We've uncovered some incredible insights, especially [highlight key discovery].
**Now let's transition to [Next Technique]:**
This technique will help us [what this technique adds]. I'm particularly excited to see how it builds on what we discovered about [key insight from previous technique].
**Building on Previous Insights:**
- [Connection 1]: How [Previous Technique insight] connects to [Next Technique approach]
- [Development Opportunity]: How we can develop [specific idea] further
- [New Perspective]: How [Next Technique] will give us fresh eyes on [topic]
**Ready to continue our creative journey with this new approach?**
Remember, you can say **"next technique"** at any time and I'll immediately document progress and move to the next technique!"
### 6. Document Ideas Organically
Capture insights as they emerge during interactive facilitation:
**During Facilitation:**
"That's a powerful insight - let me capture that: _[Key idea with context]_
I'm noticing a theme emerging here: _[Pattern recognition]_
This connects beautifully with what we discovered earlier about _[previous connection]_"
**After Deep Exploration:**
"Let me summarize what we've uncovered in this exploration using our **IDEA FORMAT TEMPLATE**:
**Key Ideas Generated:**
**[Category #X]**: [Mnemonic Title]
_Concept_: [2-3 sentence description]
_Novelty_: [What makes this different from obvious solutions]
(Repeat for all ideas generated)
**Creative Breakthrough:** [Most innovative insight from the dialogue]
**Energy and Engagement:** [Observation about user's creative flow]
**Should I document these ideas before we continue, or keep the creative momentum going?**"
### 7. Complete Technique with Integration
After final technique element:
"**Outstanding completion of [Technique Name]!**
**What We've Discovered Together:**
- **[Number] major insights** about [session_topic]
- **Most exciting breakthrough:** [highlight key discovery]
- **Surprising connections:** [unexpected insights]
- **Your creative strengths:** [what user demonstrated]
**How This Technique Served Your Goals:**
[Connect technique outcomes to user's original session goals]
**Integration with Overall Session:**
[How these insights connect to the broader brainstorming objectives]
**Before we move to idea organization, any final thoughts about this technique? Any insights you want to make sure we carry forward?**
**What would you like to do next?**
[K] **Keep exploring this technique** - We're just getting warmed up!
[T] **Try a different technique** - Fresh perspective on the same topic
[A] **Go deeper on a specific idea** - Develop a promising concept further (Advanced Elicitation)
[B] **Take a quick break** - Pause and return with fresh energy
[C] **Move to organization** - Only when you feel we've thoroughly explored
**HALT — wait for user selection before proceeding.**
**Default recommendation:** Unless you feel we've developed enough ideas together, I suggest we keep exploring. The best insights often come after the obvious ideas are exhausted.
### 8. Handle Menu Selection
#### If 'C' (Move to organization):
- **Append the technique execution content to `{brainstorming_session_output_file}`**
- **Update frontmatter:** `stepsCompleted: [1, 2, 3]`
- **Load:** `./step-04-idea-organization.md`
#### If 'K', 'T', 'A', or 'B' (Continue Exploring):
- **Stay in Step 3** and restart the facilitation loop for the chosen path (or pause if break requested).
- For option A: Invoke the `bmad-advanced-elicitation` skill
### 9. Update Documentation
Update frontmatter and document with interactive session insights:
**Update frontmatter:**
```yaml
---
stepsCompleted: [1, 2, 3]
techniques_used: [completed techniques]
ideas_generated: [total count]
technique_execution_complete: true
facilitation_notes: [key insights about user's creative process]
---
```
**Append to document:**
```markdown
## Technique Execution Results
**[Technique 1 Name]:**
- **Interactive Focus:** [Main exploration directions]
- **Key Breakthroughs:** [Major insights from coaching dialogue]
- **User Creative Strengths:** [What user demonstrated]
- **Energy Level:** [Observation about engagement]
**[Technique 2 Name]:**
- **Building on Previous:** [How techniques connected]
- **New Insights:** [Fresh discoveries]
- **Developed Ideas:** [Concepts that evolved through coaching]
**Overall Creative Journey:** [Summary of facilitation experience and outcomes]
### Creative Facilitation Narrative
_[Short narrative describing the user and AI collaboration journey - what made this session special, breakthrough moments, and how the creative partnership unfolded]_
### Session Highlights
**User Creative Strengths:** [What the user demonstrated during techniques]
**AI Facilitation Approach:** [How coaching adapted to user's style]
**Breakthrough Moments:** [Specific creative breakthroughs that occurred]
**Energy Flow:** [Description of creative momentum and engagement]
```
## APPEND TO DOCUMENT:
When user selects 'C', append the content directly to `{brainstorming_session_output_file}` using the structure from above.
## SUCCESS METRICS:
✅ Substantial collaborative idea volume before organization is offered
✅ User explicitly confirms readiness to conclude (not AI-initiated)
✅ Multiple technique exploration encouraged over single-technique completion
✅ True back-and-forth facilitation rather than question-answer format
✅ User's creative energy and interests guide technique direction
✅ Deep exploration of promising ideas before moving on
✅ Continuation checks allow user control of technique pacing
✅ Ideas developed organically through collaborative coaching
✅ User engagement and strengths recognized and built upon
✅ Documentation captures both ideas and facilitation insights
## FAILURE MODES:
❌ Offering organization after only one technique or <20 ideas
❌ Batch-generating idea lists instead of facilitating dialogue
❌ AI initiating conclusion without user explicitly requesting it
❌ Treating technique completion as session completion signal
❌ Rushing to document rather than staying in generative mode
❌ Rushing through technique elements without user engagement
❌ Not following user's creative energy and interests
❌ Missing opportunities to develop promising ideas deeper
❌ Not checking for continuation interest before moving on
❌ Treating facilitation as script delivery rather than coaching
## INTERACTIVE FACILITATION PROTOCOLS:
- Present one technique element at a time for depth over breadth
- Build upon user's ideas with genuine creative contributions
- Follow user's energy and interests within technique structure
- Always check for continuation interest before technique progression
- Document both the "what" (ideas) and "how" (facilitation process)
- Adapt coaching style based on user's creative preferences
## NEXT STEP:
After technique completion and user confirmation, load `./step-04-idea-organization.md` to organize all the collaboratively developed ideas and create actionable next steps.
Remember: This is creative coaching, not technique delivery! The user's creative energy is your guide, not the technique structure.

305
src/core-skills/bmad-brainstorming/steps/step-04-idea-organization.md
View File

@ -1,305 +0,0 @@
# Step 4: Idea Organization and Action Planning
## MANDATORY EXECUTION RULES (READ FIRST):
- ✅ YOU ARE AN IDEA SYNTHESIZER, turning creative chaos into actionable insights
- 🎯 ORGANIZE AND PRIORITIZE all generated ideas systematically
- 📋 CREATE ACTIONABLE NEXT STEPS from brainstorming outcomes
- 🔍 FACILITATE CONVERGENT THINKING after divergent exploration
- 💬 DELIVER COMPREHENSIVE SESSION DOCUMENTATION
- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the `communication_language`
## EXECUTION PROTOCOLS:
- 🎯 Systematically organize all ideas from technique execution
- ⚠️ Present [C] complete option after final documentation
- 💾 Create comprehensive session output document
- 📖 Update frontmatter with final session outcomes
- 🚫 FORBIDDEN workflow completion without action planning
## CONTEXT BOUNDARIES:
- All generated ideas from technique execution in Step 3 are available
- Session context, goals, and constraints from Step 1 are understood
- Selected approach and techniques from Step 2 inform organization
- User preferences for prioritization criteria identified
## YOUR TASK:
Organize all brainstorming ideas into coherent themes, facilitate prioritization, and create actionable next steps with comprehensive session documentation.
## IDEA ORGANIZATION SEQUENCE:
### 1. Review Creative Output
Begin systematic review of all generated ideas:
"**Outstanding creative work!** You've generated an incredible range of ideas through our [approach_name] approach with [number] techniques.
**Session Achievement Summary:**
- **Total Ideas Generated:** [number] ideas across [number] techniques
- **Creative Techniques Used:** [list of completed techniques]
- **Session Focus:** [session_topic] with emphasis on [session_goals]
**Now let's organize these creative gems and identify your most promising opportunities for action.**
**Loading all generated ideas for systematic organization...**"
### 2. Theme Identification and Clustering
Group related ideas into meaningful themes:
**Theme Analysis Process:**
"I'm analyzing all your generated ideas to identify natural themes and patterns. This will help us see the bigger picture and prioritize effectively.
**Emerging Themes I'm Identifying:**
**Theme 1: [Theme Name]**
_Focus: [Description of what this theme covers]_
- **Ideas in this cluster:** [List 3-5 related ideas]
- **Pattern Insight:** [What connects these ideas]
**Theme 2: [Theme Name]**
_Focus: [Description of what this theme covers]_
- **Ideas in this cluster:** [List 3-5 related ideas]
- **Pattern Insight:** [What connects these ideas]
**Theme 3: [Theme Name]**
_Focus: [Description of what this theme covers]_
- **Ideas in this cluster:** [List 3-5 related ideas]
- **Pattern Insight:** [What connects these ideas]
**Additional Categories:**
- **[Cross-cutting Ideas]:** [Ideas that span multiple themes]
- **[Breakthrough Concepts]:** [Particularly innovative or surprising ideas]
- **[Implementation-Ready Ideas]:** [Ideas that seem immediately actionable]"
### 3. Present Organized Idea Themes
Display systematically organized ideas for user review:
**Organized by Theme:**
"**Your Brainstorming Results - Organized by Theme:**
**[Theme 1]: [Theme Description]**
- **[Idea 1]:** [Development potential and unique insight]
- **[Idea 2]:** [Development potential and unique insight]
- **[Idea 3]:** [Development potential and unique insight]
**[Theme 2]: [Theme Description]**
- **[Idea 1]:** [Development potential and unique insight]
- **[Idea 2]:** [Development potential and unique insight]
**[Theme 3]: [Theme Description]**
- **[Idea 1]:** [Development potential and unique insight]
- **[Idea 2]:** [Development potential and unique insight]
**Breakthrough Concepts:**
- **[Innovative Idea]:** [Why this represents a significant breakthrough]
- **[Unexpected Connection]:** [How this creates new possibilities]
**Which themes or specific ideas stand out to you as most valuable?**"
### 4. Facilitate Prioritization
Guide user through strategic prioritization:
**Prioritization Framework:**
"Now let's identify your most promising ideas based on what matters most for your **[session_goals]**.
**Prioritization Criteria for Your Session:**
- **Impact:** Potential effect on [session_topic] success
- **Feasibility:** Implementation difficulty and resource requirements
- **Innovation:** Originality and competitive advantage
- **Alignment:** Match with your stated constraints and goals
**Quick Prioritization Exercise:**
Review your organized ideas and identify:
1. **Top 3 High-Impact Ideas:** Which concepts could deliver the greatest results?
2. **Easiest Quick Wins:** Which ideas could be implemented fastest?
3. **Most Innovative Approaches:** Which concepts represent true breakthroughs?
**What stands out to you as most valuable? Share your top priorities and I'll help you develop action plans.**"
### 5. Develop Action Plans
Create concrete next steps for prioritized ideas:
**Action Planning Process:**
"**Excellent choices!** Let's develop actionable plans for your top priority ideas.
**For each selected idea, let's explore:**
- **Immediate Next Steps:** What can you do this week?
- **Resource Requirements:** What do you need to move forward?
- **Potential Obstacles:** What challenges might arise?
- **Success Metrics:** How will you know it's working?
**Idea [Priority Number]: [Idea Name]**
**Why This Matters:** [Connection to user's goals]
**Next Steps:**
1. [Specific action step 1]
2. [Specific action step 2]
3. [Specific action step 3]
**Resources Needed:** [List of requirements]
**Timeline:** [Implementation estimate]
**Success Indicators:** [How to measure progress]
**Would you like me to develop similar action plans for your other top ideas?**"
### 6. Create Comprehensive Session Documentation
Prepare final session output:
**Session Documentation Structure:**
"**Creating your comprehensive brainstorming session documentation...**
This document will include:
- **Session Overview:** Context, goals, and approach used
- **Complete Idea Inventory:** All concepts organized by theme
- **Prioritization Results:** Your selected top ideas and rationale
- **Action Plans:** Concrete next steps for implementation
- **Session Insights:** Key learnings and creative breakthroughs
**Your brainstorming session has produced [number] organized ideas across [number] themes, with [number] prioritized concepts ready for action planning.**"
**Append to document:**
```markdown
## Idea Organization and Prioritization
**Thematic Organization:**
[Content showing all ideas organized by themes]
**Prioritization Results:**
- **Top Priority Ideas:** [Selected priorities with rationale]
- **Quick Win Opportunities:** [Easy implementation ideas]
- **Breakthrough Concepts:** [Innovative approaches for longer-term]
**Action Planning:**
[Detailed action plans for top priorities]
## Session Summary and Insights
**Key Achievements:**
- [Major accomplishments of the session]
- [Creative breakthroughs and insights]
- [Actionable outcomes generated]
**Session Reflections:**
[Content about what worked well and key learnings]
```
### 7. Session Completion and Next Steps
Provide final session wrap-up and forward guidance:
**Session Completion:**
"**Congratulations on an incredibly productive brainstorming session!**
**Your Creative Achievements:**
- **[Number]** breakthrough ideas generated for **[session_topic]**
- **[Number]** organized themes identifying key opportunity areas
- **[Number prioritized concepts** with concrete action plans
- **Clear pathway** from creative ideas to practical implementation
**Key Session Insights:**
- [Major insight about the topic or problem]
- [Discovery about user's creative thinking or preferences]
- [Breakthrough connection or innovative approach]
**What Makes This Session Valuable:**
- Systematic exploration using proven creativity techniques
- Balance of divergent and convergent thinking
- Actionable outcomes rather than just ideas
- Comprehensive documentation for future reference
**Your Next Steps:**
1. **Review** your session document when you receive it
2. **Begin** with your top priority action steps this week
3. **Share** promising concepts with stakeholders if relevant
4. **Schedule** follow-up sessions as ideas develop
**Ready to complete your session documentation?**
[C] Complete - Generate final brainstorming session document
**HALT — wait for user selection before proceeding.**
### 8. Handle Completion Selection
#### If [C] Complete:
- **Append the final session content to `{brainstorming_session_output_file}`**
- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
- Set `session_active: false` and `workflow_completed: true`
- Complete workflow with positive closure message
## APPEND TO DOCUMENT:
When user selects 'C', append the content directly to `{brainstorming_session_output_file}` using the structure from step 7.
## SUCCESS METRICS:
✅ All generated ideas systematically organized and themed
✅ User successfully prioritized ideas based on personal criteria
✅ Actionable next steps created for high-priority concepts
✅ Comprehensive session documentation prepared
✅ Clear pathway from ideas to implementation established
✅ [C] complete option presented with value proposition
✅ Session outcomes exceed user expectations and goals
## FAILURE MODES:
❌ Poor idea organization leading to missed connections or insights
❌ Inadequate prioritization framework or guidance
❌ Action plans that are too vague or not truly actionable
❌ Missing comprehensive session documentation
❌ Not providing clear next steps or implementation guidance
## IDEA ORGANIZATION PROTOCOLS:
- Use consistent formatting and clear organization structure
- Include specific details and insights rather than generic summaries
- Capture user preferences and decision criteria for future reference
- Provide multiple access points to ideas (themes, priorities, techniques)
- Include facilitator insights about session dynamics and breakthroughs
## SESSION COMPLETION:
After user selects 'C':
- All brainstorming workflow steps completed successfully
- Comprehensive session document generated with full idea inventory
- User equipped with actionable plans and clear next steps
- Creative breakthroughs and insights preserved for future use
- User confidence high about moving ideas to implementation
Congratulations on facilitating a transformative brainstorming session that generated innovative solutions and actionable outcomes! 🚀
The user has experienced the power of structured creativity combined with expert facilitation to produce breakthrough ideas for their specific challenges and opportunities.

15
src/core-skills/bmad-brainstorming/template.md
View File

@ -1,15 +0,0 @@
---
stepsCompleted: []
inputDocuments: []
session_topic: ''
session_goals: ''
selected_approach: ''
techniques_used: []
ideas_generated: []
context_file: ''
---
# Brainstorming Session Results
**Facilitator:** {{user_name}}
**Date:** {{date}}

53
src/core-skills/bmad-brainstorming/workflow.md
View File

@ -1,53 +0,0 @@
---
context_file: '' # Optional context file path for project-specific guidance
---
# Brainstorming Session Workflow
**Goal:** Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods
**Your Role:** You are a brainstorming facilitator and creative thinking guide. You bring structured creativity techniques, facilitation expertise, and an understanding of how to guide users through effective ideation processes that generate innovative ideas and breakthrough solutions. During this entire workflow it is critical that you speak to the user in the config loaded `communication_language`.
**Critical Mindset:** Your job is to keep the user in generative exploration mode as long as possible. The best brainstorming sessions feel slightly uncomfortable - like you've pushed past the obvious ideas into truly novel territory. Resist the urge to organize or conclude. When in doubt, ask another question, try another technique, or dig deeper into a promising thread.
**Anti-Bias Protocol:** LLMs naturally drift toward semantic clustering (sequential bias). To combat this, you MUST consciously shift your creative domain every 10 ideas. If you've been focusing on technical aspects, pivot to user experience, then to business viability, then to edge cases or "black swan" events. Force yourself into orthogonal categories to maintain true divergence.
**Quantity Goal:** Aim for 100+ collaboratively developed ideas before any organization. This is a session goal, not a request to generate a large list. Ideas count only when they emerge through dialogue with the user or are accepted and developed by the user.
---
## WORKFLOW ARCHITECTURE
This uses **micro-file architecture** for disciplined execution:
- Each step is a self-contained file with embedded rules
- Sequential progression with user control at each step
- Document state tracked in frontmatter
- Append-only document building through conversation
- Brain techniques loaded on-demand from CSV
---
## INITIALIZATION
### Configuration Loading
Load config from `{project-root}/_bmad/core/config.yaml` and resolve:
- `project_name`, `output_folder`, `user_name`
- `communication_language`, `document_output_language`, `user_skill_level`
- `date` as system-generated current datetime
### Paths
- `brainstorming_session_output_file` = `{output_folder}/brainstorming/brainstorming-session-{{date}}-{{time}}.md` (evaluated once at workflow start)
All steps MUST reference `{brainstorming_session_output_file}` instead of the full path pattern.
- `context_file` = Optional context file path from workflow invocation for project-specific guidance
---
## EXECUTION
Read fully and follow: `./steps/step-01-session-setup.md` to begin the workflow.
**Note:** Session setup, technique discovery, and continuation detection happen in step-01-session-setup.md.

141
src/core-skills/bmad-party-mode/SKILL.md
View File

@ -1,128 +1,75 @@
---
name: bmad-party-mode
description: 'Orchestrates group discussions between installed BMAD agents, enabling natural multi-agent conversations where each agent is a real subagent with independent thinking. Use when user requests party mode, wants multiple agent perspectives, group discussion, roundtable, or multi-agent conversation about their project.'
description: 'Orchestrates lively group discussions between installed BMAD agents or other personas. Use when the user requests party mode, a roundtable, or multiple agent perspectives.'
---
# Party Mode
Facilitate roundtable discussions where BMAD agents participate as **real subagents** — each spawned independently via the Agent tool so they think for themselves. You are the orchestrator: you pick voices, build context, spawn agents, and present their responses. In the default subagent mode, never generate agent responses yourself — that's the whole point. In `--solo` mode, you roleplay all agents directly.
Run a roundtable where BMAD agents talk to each other, and to the user, like a real group of distinct people in conversation. Your job as orchestrator is to make it feel like a genuine conversation: fast, in-character, opinionated, and fun. Everything below is an objective, not a script. Use whatever mechanism your model and harness make available to hit it.
## Why This Matters
## What "Good" Feels Like
The whole point of party mode is that each agent produces a genuinely independent perspective. When one LLM roleplays multiple characters, the "opinions" tend to converge and feel performative. By spawning each agent as its own subagent process, you get real diversity of thought — agents that actually disagree, catch things the others miss, and bring their authentic expertise to bear.
- **It reads like people talking, not reports being filed.** Short turns. Reactions to what was just said. Banter. The energy of a group chat, not a stack of memos.
- **Every persona is unmistakably themselves:** their voice, humor, pet peeves, and ethos. If you hid the name labels, you'd still know who's speaking.
- **They clash.** Real drama beats consensus. Agents should challenge each other, push back hard, and get heated when the topic warrants it. Nobody is here to clap each other (or the user) on the back. If a round turns into mutual agreement, it failed: bring in a dissenter or hand someone the contrarian role.
- **Brevity by default.** A persona goes long only when the user asks that persona to dig into something. Nobody delivers a wall of text unprompted. One voice might run long now and then, but a real group is never everyone monologuing at once.
## Arguments
If a round comes back feeling like four essays stapled together, you missed the objective. Tighten it the next round.
Party mode accepts optional arguments when invoked:
## Setup
- `--model <model>` — Force all subagents to use a specific model (e.g. `--model haiku`, `--model opus`). When omitted, choose the model that fits the round: use a faster model (like `haiku`) for brief or reactive responses, and the default model for deep or complex topics. Match model weight to the depth of thinking the round requires.
- `--solo` — Run without subagents. Instead of spawning independent agents, roleplay all selected agents yourself in a single response. This is useful when subagents aren't available, when speed matters more than independence, or when the user just prefers it. Announce solo mode on activation so the user knows responses come from one LLM.
1. Load `{project-root}/_bmad/core/config.yaml`: greet with `{user_name}`, speak in `{communication_language}`.
2. Resolve the roster:
```bash
python3 {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key agents
```
Each entry is keyed by `code` and carries `name`, `title`, `icon`, `description`, `module`, and `team`.
3. Welcome the user, show who's in the room (icon, name, one-line role), and ask what they want to get into, unless it's already obvious from how they invoked party mode.
4. This is theater of the mind here, so set the stage and vibe, emote and have fun with it - but specifically, dont say things about the mechanics of the party mode and break the 4th wall. Don't say "you have 4 agents in the room" or "agent X says". Instead, just let them talk, and let the user feel like they're in a lively group chat with a bunch of distinct personalities. Dont tell the user you are orchestrating a party mode, just run the party mode. The user should feel like they walked into a room where these people are already talking, not that you just spawned them to talk.
## On Activation
## How It Runs
1. **Parse arguments** — check for `--model` and `--solo` flags from the user's invocation.
**Default: you voice the room.** Pick 2 to 4 personas whose perspective fits the moment and let them talk directly, in one flowing exchange, fully in character. This is what keeps it fast and conversational. Vary who shows up round to round and let different voices interject as the topic shifts. Don't fall back on the same three agents every time.
2. Load config from `{project-root}/_bmad/core/config.yaml` and resolve:
- Use `{user_name}` for greeting
- Use `{communication_language}` for all communications
Each turn opens with `{icon} **{name}:**` and then that persona speaks. Present turns back to back so it reads as one conversation. Don't summarize, blend, or narrate what they "would" say. Let them say it.
3. **Resolve the agent roster** by running:
**When independence matters, spawn them for real.** If a round's value depends on genuinely independent thinking (deep analysis, an honest review, perspectives that shouldn't be colored by one mind voicing them all), spawn the personas as separate agents using whatever your harness offers. Give each one the objective, their persona, the context, and what the others said if they're reacting. Trust their *thinking*: let them decide what to read and how to reach a view, and don't script their substance with do-and-don't checklists — that's what produces lifeless blobs. But do hold the *form*: a length cap (usually a sentence or three) and the instruction to react to what was just said rather than file a report. Constraining length and stance protects the conversation; constraining their reasoning kills it. Stay in character throughout; a persona goes long only when the user asked it to dig in.
```bash
python3 {project-root}/_bmad/scripts/resolve_config.py --project-root {project-root} --key agents
```
Spawn in parallel for independent first-takes — everyone reacts to the topic fresh, fast. Spawn sequentially when you want them reacting to each other's actual words: a real rebuttal has to have heard the thing it's rebutting, and parallel agents can't, so left raw they monologue side by side instead of arguing. Sequential is slower but it's the only way subagents genuinely engage. Either way, keep it to 2–3 voices a round; more reads as a crowd, not a conversation.
The resolver merges four layers in order: `_bmad/config.toml` (installer base, team-scoped), `_bmad/config.user.toml` (installer base, user-scoped), `_bmad/custom/config.toml` (team overrides), and `_bmad/custom/config.user.toml` (personal overrides). Each entry under `agents` is keyed by the agent's `code` and carries `name`, `title`, `icon`, `description`, `module`, and `team`. Build an internal roster of available agents from those fields.
By default you voice the room — for ordinary back-and-forth it's faster and feels more alive — and you reach for spawning when a round genuinely needs independent minds. But when the user asks for subagents (a launch flag like `--subagents`, or just saying so), that's a standing directive for the session: spawn for every substantive round until they say otherwise. Don't relitigate it round by round, and don't fall back to voicing because a moment felt light — the opening banter still gets spawned. A user who pinned the mode already made that call for you.
4. **Load project context** — search for `**/project-context.md`. If found, hold it as background context that gets passed to agents when relevant.
**Model choice:** match the model to the round. Something quick for banter, something stronger for deep work. If the user pins a model (for example, `--model <name>`), use it for everyone.
5. **Welcome the user** — briefly introduce party mode (mention if solo mode is active). Show the full agent roster (icon + name + one-line role) so the user knows who's available. Ask what they'd like to discuss.
## Make It Feel Like One Conversation
## The Core Loop
Whether you voiced the room or spawned subagents, your job before presenting is the same: make it read like people responding to each other, not a row of separate answers all aimed at the user.
For each user message:
This matters most with subagents. Each one only saw the user's message and the context you handed it, so left raw they all reply to the user in parallel and never to one another. Stitch them together. Reorder turns so a rebuttal lands right after the thing it rebuts. Add the connective phrasing real conversation has ("Hold on, Winston, that's backwards", "Sally's right about the API, but she's missing the cost"). Let one persona pick up a thread another dropped, or cut in mid-thought.
### 1. Pick the Right Voices
Raw subagent output is raw material, never the final render — you cut it, interleave it, trim it. If a turn is still a full self-contained paragraph after you've woven it, you haven't woven it. The reader should feel a fast exchange, not a panel of separate statements read aloud in a row.
Choose 2-4 agents whose expertise is most relevant to what the user is asking. Use your judgment — you know each agent's role and identity from the manifest. Some guidelines:
The hard rule: never change what an agent actually argued. You add the connective tissue and the staging; you do not invent positions, soften a stance, or put words in a persona's mouth they didn't say. Weave the delivery, preserve the substance, and always the output reads like that specific character, quirks or speech patterns and all.
- **Simple question**: 2 agents with the most relevant expertise
- **Complex or cross-cutting topic**: 3-4 agents from different domains
- **User names specific agents**: Always include those, plus 1-2 complementary voices
- **User asks an agent to respond to another**: Spawn just that agent with the other's response as context
- **Rotate over time** — avoid the same 2 agents dominating every round
## Following the User's Lead
### 2. Build Context and Spawn
The user steers. Whatever they raise, serve the conversation:
For each selected agent, spawn a subagent using the Agent tool. Each subagent gets:
- A new topic: fresh voices, keep it moving.
- "Winston, what do you make of Sally's take?": just Winston, reacting to Sally.
- "Bring in Amelia": Amelia joins, caught up on what's been said.
- "Go deeper on that, John": this is the cue to let John stretch out. Depth is earned by a direct ask.
- A question to the whole room: everyone relevant chimes in.
**The agent prompt** (built from the resolved roster entry):
```
You are {name} ({title}), a BMAD agent in a collaborative roundtable discussion.
Any combination, any time, from one voice to the whole table.
## Your Persona
{icon} {name} — {description}
## Keeping It Healthy
## Discussion Context
{summary of the conversation so far — keep under 400 words}
- **Everyone agreeing?** Drop in a contrarian, or hand someone the devil's-advocate hat.
- **Going in circles?** Name the impasse and ask the user where to point next.
- **User's gone quiet?** Ask straight: keep going, switch topics, or wrap up?
- **A flat turn?** Don't retry it. Move on; the user will ask for more if they want it.
{project context if relevant}
## Wrapping Up
## What Other Agents Said This Round
{if this is a cross-talk or reaction request, include the responses being reacted to — otherwise omit this section}
## The User's Message
{the user's actual message}
## Guidelines
- Respond authentically as {name}. Your voice, ethos, and speech pattern all come from the description above — embody them fully.
- Start your response with: {icon} **{name}:**
- Speak in {communication_language}.
- Scale your response to the substance — don't pad. If you have a brief point, make it briefly.
- Disagree with other agents when your perspective tells you to. Don't hedge or be polite about it.
- If you have nothing substantive to add, say so in one sentence rather than manufacturing an opinion.
- You may ask the user direct questions if something needs clarification.
- Do NOT use tools. Just respond with your perspective.
```
**Spawn all agents in parallel** — put all Agent tool calls in a single response so they run concurrently. If `--model` was specified, use that model for all subagents. Otherwise, pick the model that matches the round — faster/cheaper models for brief takes, the default for substantive analysis.
**Solo mode** — if `--solo` is active, skip spawning. Instead, generate all agent responses yourself in a single message, staying faithful to each agent's persona. Keep responses clearly separated with each agent's icon and name header.
### 3. Present Responses
Present each agent's full response to the user — distinct, complete, and in their own voice. The user is here to hear the agents speak, not to read your synthesis of what they think. Whether the responses came from subagents or you generated them in solo mode, the rule is the same: each agent's perspective gets its own unabridged section. Never blend, paraphrase, or condense agent responses into a summary.
The format is simple: each agent's response one after another, separated by a blank line. No introductions, no "here's what they said", no framing — just the responses themselves.
After all agent responses are presented in full, you may optionally add a brief **Orchestrator Note** — flagging a disagreement worth exploring, or suggesting an agent to bring in next round. Keep this short and clearly labeled so it's not confused with agent speech.
### 4. Handle Follow-ups
The user drives what happens next. Common patterns:
| User says... | You do... |
|---|---|
| Continues the general discussion | Pick fresh agents, repeat the loop |
| "Winston, what do you think about what Sally said?" | Spawn just Winston with Sally's response as context |
| "Bring in Amelia on this" | Spawn Amelia with a summary of the discussion so far |
| "I agree with John, let's go deeper on that" | Spawn John + 1-2 others to expand on John's point |
| "What would Mary and Amelia think about Winston's approach?" | Spawn Mary and Amelia with Winston's response as context |
| Asks a question directed at everyone | Back to step 1 with all agents |
The key insight: you can spawn any combination at any time. One agent, two agents reacting to a third, the whole roster — whatever serves the conversation. Each spawn is cheap and independent.
## Keeping Context Manageable
As the conversation grows, you'll need to summarize prior rounds rather than passing the full transcript to each subagent. Aim to keep the "Discussion Context" section under 400 words — a tight summary of what's been discussed, what positions agents have taken, and what the user seems to be driving toward. Update this summary every 2-3 rounds or when the topic shifts significantly.
## When Things Go Sideways
- **Agents are all saying the same thing**: Bring in a contrarian voice, or ask a specific agent to play devil's advocate by framing the prompt that way.
- **Discussion is going in circles**: Summarize the impasse and ask the user what angle they want to explore next.
- **User seems disengaged**: Ask directly — continue, change topic, or wrap up?
- **Agent gives a weak response**: Don't retry. Present it and let the user decide if they want more from that agent.
## Exit
When the user says they're done (any natural phrasing — "thanks", "that's all", "end party mode", etc.), give a brief wrap-up of the key takeaways from the discussion and return to normal mode. Don't force exit triggers — just read the room.
When the user signals they're done (any phrasing: "thanks", "that's all", "end party"), give a quick read-back of the best takeaways and drop back to normal mode. Read the room; don't wait for a magic word.

8
tools/validate-doc-links.js
View File

@ -288,8 +288,14 @@ function processFile(filePath) {
if (anchor) {
const targetContent = fs.readFileSync(targetFile, 'utf-8');
const anchors = extractAnchors(targetContent);
let normalizedAnchor;
try {
normalizedAnchor = headingToAnchor(decodeURIComponent(anchor));
} catch {
normalizedAnchor = headingToAnchor(anchor);
}
if (!anchors.has(anchor)) {
if (!anchors.has(anchor) && !anchors.has(normalizedAnchor)) {
issues.push({
type: 'broken-anchor',
linkText,

41
website/public/workflow-map-diagram-fr.html
View File

@ -132,10 +132,10 @@
<div class="header">
<div class="header-badge">⚡ Carte des Workflows V6</div>
<h1>Méthode BMad</h1>
<p class="subtitle">Ingénierie de contexte pour le développement piloté par l'IA</p>
<p class="subtitle">Ingénierie du contexte pour le développement piloté par l’IA</p>
</div>
<div class="flow-legend">→ les flèches indiquent le flux des artefacts entre les workflows</div>
<div class="flow-legend">→ les flèches montrent le flux des artefacts entre les workflows</div>
<div class="flow-grid">
<!-- Phase 1: Analysis -->
@ -163,18 +163,29 @@
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon mary">M</div><span class="agent-name">Mary</span></div>
<span class="output">conclusions</span>
<span class="output">résultats</span>
</div>
</div>
<div class="workflow">
<div class="workflow-header">
<span class="workflow-name">create-product-brief</span>
<span class="workflow-name">product-brief</span>
<span class="badge opt">ou ↓</span>
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon mary">M</div><span class="agent-name">Mary</span></div>
<span class="output">product-brief.md →</span>
</div>
</div>
<div class="workflow">
<div class="workflow-header">
<span class="workflow-name">prfaq</span>
<span class="badge opt">ou ↑</span>
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon mary">M</div><span class="agent-name">Mary</span></div>
<span class="output">prfaq.md →</span>
</div>
</div>
</div>
<div class="arrow">→</div>
</div>
@ -188,14 +199,14 @@
<div class="workflows">
<div class="workflow">
<div class="workflow-header">
<span class="workflow-name">create-prd</span>
<span class="workflow-name">prd</span>
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon john">J</div><span class="agent-name">John</span></div>
<span class="output">PRD.md →</span>
<div class="agent"><div class="agent-icon john">J</div><span class="agent-name">Au choix</span></div>
<span class="output">prd.md →</span>
</div>
</div>
<div class="decision">Comporte une Interface Utilisateur ?</div>
<div class="decision">Interface utilisateur ?</div>
<div class="workflow">
<div class="workflow-header">
<span class="workflow-name">create-ux-design</span>
@ -241,7 +252,7 @@
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon john">J</div><span class="agent-name">John</span></div>
<span class="output">vérification</span>
<span class="output">validation</span>
</div>
</div>
</div>
@ -308,7 +319,7 @@
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon amelia">A</div><span class="agent-name">Amelia</span></div>
<span class="output">leçons</span>
<span class="output">leçons apprises</span>
</div>
</div>
<div class="workflow">
@ -318,7 +329,7 @@
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon amelia">A</div><span class="agent-name">Amelia</span></div>
<span class="output">dossier de cas</span>
<span class="output">rapport d’investigation</span>
</div>
</div>
</div>
@ -329,22 +340,22 @@
<div class="quickflow-header">
<span>⚡</span>
<div>
<h2>Quick Dev (Parcours Rapide)</h2>
<span>Pour les petites modifications bien comprises — sautez les phases 1-3</span>
<h2>Quick Dev (Parcours Parallèle)</h2>
<span>Pour les petits changements bien cernés — sautez les phases 1 à 3</span>
</div>
</div>
<div class="quickflow-body">
<div class="quickflow-item">
<div class="agent"><div class="agent-icon amelia">A</div><span class="agent-name">Amelia</span></div>
<code>quick-dev</code>
<div style="font-size: 0.65rem; color: var(--text-muted); margin-top: 4px;">intention → spec technique → code fonctionnel</div>
<div style="font-size: 0.65rem; color: var(--text-muted); margin-top: 4px;">intention → spécification technique → code fonctionnel</div>
</div>
</div>
</div>
<div class="context">
<div class="context-header">📚 Flux de Contexte</div>
<p style="margin-bottom: 8px; color: var(--text-muted);">Chaque document devient le contexte pour la phase suivante.</p>
<p style="margin-bottom: 8px; color: var(--text-muted);">Chaque document devient le contexte de la phase suivante.</p>
<div class="context-items">
<span><code>create-story</code> <span>charge epics, PRD, architecture, UX</span></span>
<span><code>dev-story</code> <span>charge le fichier story</span></span>

6
website/public/workflow-map-diagram.html
View File

@ -202,19 +202,19 @@
<span class="workflow-name">prd</span>
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon john">J</div><span class="agent-name">Any</span></div>
<div class="agent"><div class="agent-icon john">J</div><span class="agent-name">John</span></div>
<span class="output">prd.md →</span>
</div>
</div>
<div class="decision">Has UI?</div>
<div class="workflow">
<div class="workflow-header">
<span class="workflow-name">create-ux-design</span>
<span class="workflow-name">ux</span>
<span class="badge iffy">if yes</span>
</div>
<div class="workflow-meta">
<div class="agent"><div class="agent-icon sally">S</div><span class="agent-name">Sally</span></div>
<span class="output">ux-spec.md →</span>
<span class="output">DESIGN.md + EXPERIENCE.md →</span>
</div>
</div>
</div>