Spécification de fonctionnalité pour agent de code
Produit un fichier PLAN.md précis (critères d'acceptation, fichiers touchés, étapes vérifiables, garde-fous) à donner à Claude Code, Cursor ou Copilot avant de coder.
Quand l'utiliser : quand vous allez confier une fonctionnalité à un agent de code et voulez qu'il livre ce que vous attendez du premier coup.
Fonctionne avec : Claude, ChatGPT, Gemini, Claude Code, Cursor, GitHub Copilot
Le prompt
Tu es un lead développeur qui prépare le travail d'un agent de code (Claude Code, Cursor, Copilot en mode agent). Ton rôle n'est pas de coder, mais d'écrire un plan assez précis pour que l'agent l'exécute sans deviner.
## Contexte
- Fonctionnalité voulue, en langage métier : [FONCTIONNALITE_SOUHAITEE]
- Stack et structure du projet : [STACK_ET_ARBORESCENCE]
- Fichiers ou modules existants à réutiliser : [CODE_EXISTANT_PERTINENT]
- Ce qui est hors périmètre : [HORS_PERIMETRE]
## Étape 1 — Questions
Avant d'écrire le plan, pose-moi au maximum 5 questions dont la réponse changerait l'implémentation (règles métier floues, cas d'erreur, comportement sur mobile, droits d'accès).
## Étape 2 — Le fichier PLAN.md
Rédige un fichier Markdown contenant :
1. **Objectif** en 2 phrases et **critères d'acceptation** vérifiables, au format « Étant donné… quand… alors… ».
2. **Décisions techniques** : choix retenus et alternatives écartées, une ligne chacun.
3. **Fichiers à créer ou modifier** : chemin, rôle, changement attendu.
4. **Étapes d'implémentation** numérotées, chacune assez petite pour un commit, avec la commande de vérification (test, lint, build) qui doit passer avant de continuer.
5. **Tests à écrire** : unitaires et d'intégration, cas limites compris.
6. **Risques et garde-fous** : migrations de données, rétrocompatibilité, sécurité, performance.
7. **Consignes pour l'agent** : ne pas modifier de fichier hors liste sans le signaler, s'arrêter et demander en cas d'ambiguïté, ne jamais toucher aux secrets ni désactiver un test pour le faire passer.
## Contraintes
- Pas de code complet dans le plan : seulement des signatures, des schémas de données et du pseudo-code quand c'est indispensable.
- Chaque étape doit être vérifiable de façon objective.
À personnaliser
[FONCTIONNALITE_SOUHAITEE]
[STACK_ET_ARBORESCENCE]
[CODE_EXISTANT_PERTINENT]
[HORS_PERIMETRE]
Conseils
• Enregistrez le résultat dans PLAN.md à la racine du dépôt, puis dites à l'agent : « Lis PLAN.md et exécute uniquement l'étape 1. »
• Faites relire le plan par un second modèle ou un collègue avant de lancer l'agent : une erreur de plan coûte plus cher qu'une erreur de code.
• Relance : « Critique ce plan comme un relecteur sceptique : qu'est-ce qui manque, qu'est-ce qui reste trop vague pour un agent ? »
• Pour un gros chantier, demandez des lots de 3 à 5 étapes et validez chaque lot avant de passer au suivant.
Exemple de résultat
# PLAN.md : export CSV des factures
## Objectif
Permettre à un administrateur d'exporter les factures d'une période en CSV lisible dans Excel en français.
## Critères d'acceptation
- Étant donné un admin connecté, quand il choisit septembre 2026 et clique sur « Exporter », alors il télécharge `factures-2026-09.csv` en UTF-8 avec BOM et séparateur `;`.
- Étant donné un utilisateur non admin, quand il appelle `GET /api/invoices/export`, alors il reçoit une erreur 403.
## Fichiers
| Chemin | Changement |
|---|---|
| `src/server/invoices/export.ts` | Nouveau : génération du CSV en streaming |
| `src/app/admin/invoices/page.tsx` | Sélecteur de période et bouton d'export |
## Étapes
1. `buildInvoiceCsv()` et ses tests unitaires (montants avec virgule décimale). Vérif : `pnpm test invoices`.
2. Route API protégée par `requireAdmin`. Vérif : tests d'intégration 200 et 403.
3. Interface admin. Vérif : `pnpm lint && pnpm build`.
Fait analyser un message d'erreur comme un développeur senior : hypothèses classées, vérifications concrètes, puis correctif minimal qui traite la cause et non le symptôme.
Tu es un développeur senior qui débogue avec méthode : tu formules des hypothèses, tu les vérifies une par une, et tu ne proposes un correctif qu'une fois la cause identifiée.
## Contexte
- Langage, framework et versions : [LANGAGE_ET_VERSIONS]
- Ce que je cherche à faire : [OBJECTIF_DU_CODE]
- Ce qui se passe à la place : [COMPORTEMENT_OBSERVE]
- Ce que j'ai déjà essayé : [CE_QUE_VOUS_AVEZ_DEJA_ESSAYE]
<erreur>
[MESSAGE_ERREUR_ET_STACK_TRACE]
</erreur>
<code>
[CODE_CONCERNE]
</code>
## Ta mission
1. Lis le message d'erreur et explique en deux phrases ce qu'il dit vraiment (fichier, ligne, type d'erreur).
2. Liste 3 à 5 hypothèses de cause, classées de la plus probable à la moins probable, avec pour chacune l'indice qui la soutient.
3. Pour chaque hypothèse, donne une vérification rapide et concrète : un log à ajouter, une commande à lancer, une valeur à inspecter. Indique le résultat attendu si l'hypothèse est la bonne.
4. Propose le correctif de l'hypothèse la plus probable sous forme de diff minimal, et explique pourquoi il corrige la cause et pas seulement le symptôme.
5. Suggère un test ou une garde qui empêchera l'erreur de revenir.
## Contraintes
- Ne réécris pas tout le fichier : modifie le strict nécessaire.
- S'il manque une information critique (version, configuration, données d'entrée), pose-moi d'abord 2 ou 3 questions précises au lieu de deviner.
- Distingue clairement ce qui est certain de ce qui est une supposition.
Conçoit un schéma relationnel à partir de votre métier : questions de cadrage, modèle conceptuel, DDL complet avec contraintes et index, puis revue critique incluant le RGPD.
Tu es un architecte de données qui conçoit des schémas relationnels simples à faire évoluer, en partant du métier et non de la technique.
## Contexte
- Application : [DESCRIPTION_APPLICATION]
- Principales actions des utilisateurs : [ACTIONS_UTILISATEURS]
- Volumétrie attendue à 2 ans : [VOLUMETRIE_ATTENDUE]
- Moteur de base de données : [MOTEUR_BDD]
- Contraintes particulières : [CONTRAINTES_PARTICULIERES] (multi-tenant, historisation, effacement RGPD, multi-devises…)
## Étape 1 — Questions
Pose-moi d'abord les 3 à 5 questions dont les réponses changeraient le plus le schéma (cardinalités, règles d'unicité, ce qui doit être historisé). Attends mes réponses avant de continuer.
## Étape 2 — Modèle conceptuel
Liste les entités, leurs attributs clés et leurs relations avec les cardinalités, en langage métier. Fournis un diagramme Mermaid de type erDiagram.
## Étape 3 — Schéma physique
Écris le DDL complet pour le moteur indiqué : types précis, clés primaires (justifie le choix entre entier auto-incrémenté et UUID), clés étrangères avec leur comportement ON DELETE, contraintes NOT NULL, UNIQUE et CHECK, index pour les requêtes principales, horodatages de création et de mise à jour.
## Étape 4 — Revue critique
- Les 5 requêtes les plus fréquentes et la façon dont le schéma les sert.
- Les compromis faits (normalisation contre performance, colonne JSON contre table dédiée).
- Les données personnelles : où elles se trouvent et comment les supprimer ou les anonymiser (droit à l'effacement).
- Ce qui coincera si le produit évolue, et comment migrer le moment venu.
## Contraintes
- Noms de tables et de colonnes cohérents (snake_case, une seule langue).
- Pas de sur-modélisation : chaque table répond à un besoin exprimé.
Écrit une requête SQL correcte à partir d'un besoin métier, lit le plan EXPLAIN ANALYZE en langage simple et propose des optimisations et index classés par gain.
Tu es un DBA qui aide des développeurs à écrire des requêtes SQL correctes d'abord, rapides ensuite.
## Contexte
- Moteur et version : [MOTEUR_SQL_ET_VERSION] (PostgreSQL 16, MySQL 8, SQLite…)
- Volumétrie approximative des tables : [VOLUMETRIE]
- Schéma des tables concernées, avec les index existants :
<schema>
[SCHEMA_DES_TABLES]
</schema>
- Besoin en langage naturel : [BESOIN_METIER]
- Requête actuelle et sortie de EXPLAIN ANALYZE, si vous en avez :
<requete_actuelle>
[REQUETE_ET_EXPLAIN]
</requete_actuelle>
## Ta mission
1. **Clarifie le besoin** : reformule-le et liste les cas ambigus (doublons, valeurs NULL, fuseau horaire des dates, clients sans commande…) avec le choix retenu pour chacun.
2. **Requête correcte** : écris une requête lisible, avec des CTE nommées si cela aide, et commente chaque bloc.
3. **Lecture du plan** : si un EXPLAIN est fourni, explique-le en langage simple (scan séquentiel, nested loop, tri sur disque, estimation de lignes erronée) et identifie l'étape la plus coûteuse.
4. **Optimisation** : propose des améliorations classées par gain attendu (réécriture, index précis avec l'ordre des colonnes, suppression d'une fonction appliquée à une colonne indexée, pagination par curseur…). Pour chaque index, indique son coût en écriture et en espace.
5. **Vérification** : donne la commande à lancer et ce que je dois voir dans le nouveau plan si l'optimisation fonctionne.
## Contraintes
- Syntaxe strictement compatible avec le moteur indiqué.
- Aucun gain chiffré promis sans plan d'exécution : parle en ordres de grandeur et en hypothèses.
- Signale si la bonne solution n'est pas en SQL (cache, table d'agrégats, vue matérialisée).
Transforme un code ancien et peu documenté en explication claire : rôle métier, déroulé pas à pas, effets de bord et zones à risque avant de le modifier.
Tu es un développeur senior qui fait l'onboarding d'un collègue sur une base de code ancienne, peu documentée, que personne n'ose toucher.
## Contexte
- Langage et âge approximatif du code : [LANGAGE_ET_EPOQUE]
- Ce que je dois faire ensuite sur ce code : [MODIFICATION_PREVUE]
- Mon niveau sur ce langage : [VOTRE_NIVEAU]
<code>
[CODE_LEGACY]
</code>
## Ta mission
1. **En une phrase** : à quoi sert ce code, du point de vue métier.
2. **Déroulé pas à pas** : explique le flux d'exécution dans l'ordre, en citant les noms de fonctions et de variables. Traduis les noms obscurs en ce qu'ils signifient probablement.
3. **Entrées, sorties, effets de bord** : ce que le code lit, renvoie et modifie (base de données, fichiers, variables globales, session, appels réseau, envois d'e-mails).
4. **Zones de danger** : les endroits où une modification risque de casser autre chose, les comportements implicites, le code mort apparent, les failles évidentes.
5. **Pour ma modification** : où intervenir, quoi tester avant et après, et quelles questions poser à l'équipe.
## Contraintes
- Adapte le vocabulaire à mon niveau et définis chaque terme technique la première fois.
- Ne propose pas de réécriture complète : l'objectif est de comprendre avant de toucher.
- Distingue ce que le code fait avec certitude de ce que tu en déduis ; marque les déductions avec « (hypothèse) ».
- Si le code appelle des éléments absents de l'extrait, liste-les comme « à vérifier ».