Aller au contenu

Le PROMPT.md

Generateur et référence de structure pour le fichier qui définit votre projet.


Le Générateur

Cette section contient le prompt à copier-coller dans Claude Code. Il lancera une interview Socratique puis générera votre PROMPT.md.

Mode d'emploi

  1. Ouvrez Claude Code dans le terminal (dans n'importe quel dossier)
  2. Copiez le bloc ci-dessous en entier
  3. Collez-le et appuyez sur Enter
  4. Répondez aux questions une par une
  5. Claude génère le PROMPT.md à la fin

Durée

L'interview dure entre 5 et 15 minutes selon la complexité du projet. Ne bâclez pas les réponses — plus vous êtes précis, meilleur sera le PROMPT.md.

Le prompt

Tu es un architecte logiciel senior spécialisé en spécification de projets.

Ta mission : m'interviewer en profondeur pour comprendre exactement ce que
je veux construire, puis générer un fichier PROMPT.md complet à la racine
du projet.

## Déroulement

### Phase 1 — Interview Socratique

Pose-moi des questions UNE PAR UNE avec l'outil AskUserQuestion.
Ne pose jamais plusieurs questions d'un coup.
Creuse les zones d'ombre — ne te contente pas de réponses vagues.

Couvre obligatoirement ces axes :

1. **Vision** : Quel est le projet ? Pour qui ? Quel problème résout-il ?

2. **Stack technique** :

   C'est TOI qui proposes la stack, en te basant sur ces critères
   dans cet ordre de priorité :

   a) **Ta fiabilité d'implémentation** : choisis les technologies où tu
      produis du code correct, idiomatique et sans hallucination du premier
      coup. Sois honnête sur tes forces et faiblesses. Par exemple :
      - Tu es excellent en TypeScript, Python, React, Next.js, Tailwind,
        Prisma, Node.js, Express, FastAPI, PostgreSQL
      - Tu es bon en Vue, Svelte, Django, Flask, SQLite
      - Tu es moins fiable avec des frameworks très récents, des librairies
        de niche, ou des stacks que tu connais mal
      Si le projet nécessite une techno où tu es moins sûr, DIS-LE
      explicitement et propose une alternative où tu seras plus fiable.
      Utilise Context7 pour vérifier ta connaissance des APIs si besoin.

   b) **L'adéquation au projet** : la stack doit correspondre aux besoins
      réels (taille, complexité, type d'app, contraintes de perf).
      Ne recommande pas un canon pour tuer une mouche.

   c) **L'écosystème et la maintenabilité** : librairies matures, bonne
      documentation (disponible via Context7), communauté active.

   d) **Les préférences de l'utilisateur** : si j'ai une préférence ou
      une contrainte, prends-la en compte. Mais si mon choix risque de
      dégrader ta fiabilité d'implémentation, préviens-moi avec une
      explication honnête et une alternative.

   Présente ta recommandation de stack ARGUMENTÉE avec un score de
   confiance pour chaque techno (élevé / moyen / à vérifier via Context7).
   Laisse-moi valider ou ajuster avant de continuer.

3. **Fonctionnalités** : Liste exhaustive des features, priorisées par phase.
   Pour chaque feature, demande les cas limites et les règles métier.

4. **Design & UX** : Direction esthétique, références visuelles, ton,
   palette, typographie souhaitée.

5. **Contraintes** : Performance, accessibilité, SEO, internationalisation,
   budget, deadline.

6. **Conventions** : Nommage, structure de dossiers, patterns préférés,
   workflow Git (branches, worktrees pour isoler les features, stratégie
   de merge). Si je n'ai pas de préférence, propose les conventions
   les plus solides pour la stack choisie — celles où tu sais que tu
   les appliqueras de manière cohérente.

Adapte tes questions en fonction de mes réponses précédentes.
Si une réponse est trop vague, reformule et creuse.
Continue jusqu'à avoir couvert TOUS les axes — ne t'arrête pas trop tôt.

### Phase 2 — Génération du PROMPT.md

Une fois l'interview terminée, génère un fichier PROMPT.md à la racine
du projet contenant :

- **Vision du projet** (2-3 phrases)
- **Stack technique** avec tableau incluant le score de confiance
  par techno (🟢 élevé / 🟡 moyen / 🔵 via Context7)
- **Architecture** et structure des dossiers
- **Conventions de codage** adaptées à la stack
- **Outils et plugins Claude Code** avec directives d'utilisation de
  Superpowers (incluant `using-git-worktrees` pour isoler chaque feature),
  Context7, Frontend Design et Commit Commands
- **Fonctionnalités** découpées en phases avec checklist
- **Design & UX** avec direction esthétique
- **Règles impératives**
- **Stratégie de fiabilité** : comportement quand une techno est 🟡/🔵,
  quand un pattern échoue, vérification systématique

## Règles pour la génération

- Le PROMPT.md doit être AUTONOME
- Sois spécifique : pas de "bonnes pratiques", mais des règles concrètes
- Les sections Outils/plugins et Stratégie de fiabilité sont OBLIGATOIRES
- Le score de confiance par techno est OBLIGATOIRE
- Inclure la directive : ne jamais ajouter de ligne Co-Authored-By dans les messages de commit
- Si pendant l'interview je choisis une techno où ta confiance est basse,
  tu dois l'avoir signalé ET la marquer 🔵 dans le PROMPT.md
- Écris en français

Commence l'interview maintenant. Première question.

Ce qui va se passer

sequenceDiagram
    participant U as Vous
    participant C as Claude Code

    U->>C: Colle le prompt

    loop Interview (5-15 min)
        C->>U: Question (vision, stack, features...)
        U->>C: Réponse
        C->>C: Adapte les questions suivantes
    end

    Note over C: Fin de l'interview

    C->>C: Évalue sa confiance par techno
    C->>C: Structure les conventions
    C->>C: Rédige les directives plugins
    C->>U: Génère PROMPT.md à la racine

    Note over U,C: PROMPT.md prêt

Après la génération

  1. Relisez le PROMPT.md — corrigez ce qui ne correspond pas
  2. Committez : git add PROMPT.md && git commit -m "docs: add project spec"
  3. Nouvelle session Claude Code (contexte propre)
  4. Lancez l'implémentation : voir Premier projet

Nouvelle session obligatoire

L'interview consomme du contexte. Ouvrez une nouvelle session Claude Code pour l'implémentation — elle démarrera avec un contexte propre et le PROMPT.md comme seule source de vérité.


Référence structure

Voici la structure complète d'un PROMPT.md bien formé, avec annotations.

Squelette annoté

# PROMPT.md — [Nom du Projet]                          ← (1)

## Vision du projet                                     ← (2)
[2-3 phrases. Quoi, pour qui, quel problème.]

## Stack technique                                      ← (3)

| Catégorie       | Choix             | Confiance        |
|-----------------|-------------------|------------------|
| Framework       | Next.js 15        | 🟢 élevé         |
| Langage         | TypeScript strict | 🟢 élevé         |
| Styling         | Tailwind CSS v4   | 🟢 élevé         |
| UI Components   | shadcn/ui         | 🟢 élevé         |
| State           | Zustand           | 🟢 élevé         |
| ORM             | Prisma            | 🟢 élevé         |
| Auth            | NextAuth.js v5    | 🔵 Context7      |
| Tests           | Vitest + Playwright| 🟢 élevé        |

Pour toute techno 🟡 ou 🔵 : Context7 AVANT de coder.

## Architecture                                         ← (4)
### Structure des dossiers
[Arborescence src/ complète, adaptée à la stack]

## Conventions de codage                                ← (5)
### TypeScript
[Règles concrètes : strict mode, interface vs type, exports...]
### Composants
[Fonctionnels, un par fichier, props typées...]
### Gestion d'erreurs
[Result type, errors typées, logging structuré...]
### Tests
[TDD, couverture, frameworks, nommage...]
### Git
[Conventional commits, branches, squash merge, worktrees pour isoler
chaque feature/plan, cleanup des branches `[gone]` via /clean_gone...]
### Performance
[Lazy loading, images, memoization...]
### Accessibilité
[ARIA, clavier, contraste, focus...]

## Outils et plugins Claude Code                        ← (6)

### Superpowers
- Brainstorming avant chaque feature complexe
- Plan granulaire avant d'implémenter
- Worktree Git isolé (`using-git-worktrees`) pour chaque feature/plan :
  jamais travailler sur la branche courante si le workspace a des
  modifications non commitées ou si la tâche est exécutée en parallèle
- Code review après implémentation
- Debug en 4 phases
- TDD strict

### Context7
- Docs à jour pour CHAQUE librairie AVANT de coder
- OBLIGATOIRE pour les technos 🟡 et 🔵
- Jamais se fier aux connaissances internes pour les API
- Mentionner la version pour les docs versionnées

### Frontend Design
- S'active automatiquement sur tout travail UI
- Direction esthétique : [définie dans Design & UX]
- Polices distinctives, pas de fonts génériques
- Palette cohérente, animations soignées
- Zéro "AI slop"

- Ne PAS utiliser pour les tâches nécessitant validation humaine

### Commit Commands
- Après chaque feature complète et testée : /commit
- Pour la PR finale : /commit-push-pr
- Messages Conventional Commits
- Ne jamais ajouter de ligne Co-Authored-By dans les messages de commit
- Nettoyer régulièrement avec /clean_gone

## Fonctionnalités                                      ← (7)

### Phase 1 — Fondations
1. [ ] Setup projet
2. [ ] Auth
3. [ ] Layout principal
4. [ ] Schema DB initial

### Phase 2 — Core
5. [ ] Feature A — [description + cas limites]
6. [ ] Feature B — [description + règles métier]

### Phase 3 — Polish
7. [ ] Tests E2E
8. [ ] Performance
9. [ ] Déploiement

## Design & UX                                          ← (8)
[Direction, palette, typo, ton, références visuelles]

## Règles impératives                                   ← (9)
[Interdictions absolues et obligations non-négociables]

## Stratégie de fiabilité                               ← (10)
- Techno 🔵 → Context7 systématiquement
- Techno 🟡 → Context7 au moindre doute
- 2 échecs → STOP → chercher la doc
- Ne jamais inventer une API
- Tests + linter après chaque phase
- Code review Superpowers avant chaque merge

Annotations

# Section Pourquoi c'est là
(1) Titre Identifie le projet immédiatement
(2) Vision Orienté toutes les décisions — Claude s'y réfère quand il doute
(3) Stack + confiance Le contrat de transparence. Claude sait où vérifier
(4) Architecture La carte du projet. Claude sait où poser chaque fichier
(5) Conventions Règles concrètes, pas de "suivre les bonnes pratiques"
(6) Plugins Sans ça, les plugins sont installés mais pas utilisés activement
(7) Features par phase Claude peut se concentrer sur un ensemble délimité
(8) Design Frontend Design l'utilisé pour choisir sa direction
(9) Règles Les "jamais" et "toujours" non-négociables
(10) Fiabilité Le filet de sécurité quand Claude n'est pas sûr

Anti-patterns

Ce qu'il ne faut PAS mettre

  • Code style détaillé (espaces, quotes, semicolons) → c'est le travail du linter, pas du PROMPT
  • Tout l'historique du projet → le PROMPT est une spec, pas un journal
  • Des instructions vagues : "écrire du bon code", "suivre les best practices"
  • Trop d'instructions : au-delà de ~150 instructions, Claude commence à tout ignorer uniformément
  • Des commandes shell exhaustives → laissez Claude les découvrir via le code