Prompts IA pour développeurs — à copier et coller

Explique étape par étape ce que fait ce code TypeScript. Ensuite, liste :
1. Les entrées et les sorties
2. Les effets de bord (réseau, fichiers, état)
3. Les cas limites qu’il ne gère pas

```
[coller le code]
```

Demander les effets de bord et les cas limites manquants transforme un résumé en revue.

Je découvre ce projet React. À partir de l’arborescence et des fichiers ci-dessous, explique l’architecture : les modules principaux, le cheminement des données d’une requête jusqu’à la réponse, et où je dois regarder pour modifier [fonctionnalité].

Arborescence :
[coller l’arborescence]

Fichiers clés :
[coller les fichiers]

Décompose ceci token par token et donne trois exemples d’entrées qui correspondent et trois qui ne correspondent pas :

[coller la regex ou la commande]

Cette fonction TypeScript devrait [comportement attendu] mais [comportement réel].

```
[coller le code]
```

Trouve la cause racine. Explique pourquoi elle se produit avant de proposer un correctif, et montre la modification la plus petite qui la corrige.

Décrire le comportement attendu et le comportement réel est le meilleur moyen d’améliorer un prompt de débogage.

J’obtiens cette erreur lorsque [ce que vous avez fait] :

```
[coller l’erreur et la stack trace]
```

Code concerné :
```
[coller le code]
```

Explique ce que signifie l’erreur, les causes les plus probables par ordre de probabilité, et comment vérifier chacune d’elles.

Ce code TypeScript met [durée] pour [taille de l’entrée]. Identifie les goulots d’étranglement, estime leur complexité et propose des optimisations classées par impact et effort. Ne modifie pas le comportement.

```
[coller le code]
```

Je bloque sur [problème]. Ne me donne pas encore la réponse. Pose-moi une seule question à la fois pour m’aider à trouver la cause par moi-même.

Idéal lorsque vous voulez apprendre plutôt que simplement obtenir un correctif.

Écris une fonction TypeScript qui [fait X].

Exigences :
- [exigence]
- [exigence]

Gère ces cas limites : [entrée vide, valeurs invalides, …]. N’utilise aucune bibliothèque externe. Ajoute de courts commentaires uniquement là où la logique n’est pas évidente, et inclus un exemple d’utilisation.

Crée un composant React en TypeScript pour [décrire l’interface]. Props : [liste]. Il doit être accessible (clavier, ARIA si nécessaire) et responsive. Garde le style minimal et séparé de la logique.

Écris une requête PostgreSQL qui [objectif].

Schéma :
```sql
[coller les instructions CREATE TABLE]
```

Explique la requête, indique les index dont elle a besoin et signale ce qui pourrait être lent sur les grandes tables.

Convertis ce code de [langage source] vers TypeScript. Conserve le même comportement, utilise un TypeScript idiomatique plutôt qu’une traduction ligne par ligne, et liste les comportements qui ne peuvent pas être préservés à l’identique.

```
[coller le code]
```

Écris un script bash qui [objectif]. Il doit : s’arrêter en cas d’erreur (set -euo pipefail), afficher ce qu’il fait, accepter [arguments] avec un message --help, et pouvoir être relancé deux fois sans risque.

Relis ce code comme un ingénieur TypeScript senior. Regroupe les remarques par gravité (bug, sécurité, performance, lisibilité). Pour chacune, cite la ligne, explique le problème et propose une correction. Pas de compliments ni de remarques de forme sur la mise en page.

```
[coller le diff ou le code]
```

Refactorise ce code pour gagner en lisibilité et en maintenabilité, sans modifier son comportement ni son API publique. Explique chaque changement en une ligne. Signale tout ce dont tu n’es pas certain qu’il préserve le comportement.

```
[coller le code]
```

Audite ce code pour détecter les failles de sécurité : injections, XSS, authentification et contrôle d’accès, secrets, désérialisation non sûre, SSRF et validation des entrées. Pour chaque problème, donne un scénario d’exploitation concret et un correctif.

```
[coller le code]
```

Ce code fonctionne mais paraît trop compliqué. Propose une version plus simple, avec moins de branches et moins d’état, et explique ce qui rendait l’original complexe.

```
[coller le code]
```

Écris des tests unitaires Vitest pour ce code TypeScript. Couvre le cas nominal, les cas limites et la gestion des erreurs. Utilise des noms de tests descriptifs, aucun état mutable partagé, et ne mocke que les dépendances externes.

```
[coller le code]
```

Voici une fonction et ses tests. Liste les cas importants que les tests ne couvrent pas, puis écris des tests pour les trois plus utiles.

Code :
[coller le code]

Tests :
[coller les tests]

Génère [nombre] enregistrements de test réalistes au format JSON pour ce schéma. Inclus des valeurs délicates : noms en Unicode, chaînes très longues, champs optionnels vides, nombres aux limites et dates autour des changements d’heure.

[coller le schéma ou le type]

Rédige un message de commit conventionnel pour ce diff : une ligne de sujet de moins de 72 caractères à l’impératif, une ligne vide, puis un court corps expliquant pourquoi le changement a été fait.

```diff
[coller le git diff --staged]
```

Obtenez le diff avec git diff --staged.

Rédige une description de pull request pour ces modifications avec les sections : Résumé, Pourquoi, Fonctionnement, Comment tester, Risques. Sois concis.

[coller le diff ou la liste des modifications]

Ajoute des commentaires de documentation TypeScript (JSDoc/TSDoc, docstrings ou équivalent) à ce code : finalité, paramètres, valeur de retour, erreurs levées et un exemple. Ne modifie pas le code.

```
[coller le code]
```

Rédige la section « Démarrage rapide » du README de ce projet : prérequis, installation, configuration (variables d’environnement), lancement en local et exécution des tests. Utilise des commandes prêtes à copier.

Détails du projet :
[coller package.json / notes]

Explique ce problème technique à une partie prenante non technique en moins de 120 mots : ce qui s’est passé, l’impact pour les utilisateurs et ce que nous faisons pour y remédier. Pas de jargon.

[coller les notes de l’incident]

Je dois [objectif] dans une application React. Compare [option A], [option B] et [option C] dans un tableau : complexité, performance, maintenance, coût et cas où chacune est le meilleur choix. Recommande ensuite l’une d’elles pour ma situation : [contexte].

Conçois un schéma PostgreSQL pour [domaine]. Entités : [liste]. Montre les instructions CREATE TABLE avec clés, contraintes et index, et explique comment il permet d’exécuter ces requêtes : [requêtes].

Découpe cette fonctionnalité en petites tâches d’une demi-journée maximum, dans un ordre logique, avec des critères d’acceptation pour chacune :

[décrire la fonctionnalité]

Relis cette conception d’API REST sous l’angle de la cohérence, du nommage, des codes de statut, de la pagination, du format d’erreur, du versionnement et de la sécurité. Propose des améliorations concrètes.

[coller les endpoints ou la spécification OpenAPI]