10 Prompts IA Indispensables pour Développeurs en 2025

J'ai une erreur dans mon application [type d'app : web/mobile/API]. Aide-moi à la résoudre étape par étape.

**Stack technique :** [Node.js / Python / React / etc.]
**Message d'erreur exact :**
```
[coller l'erreur ici]
```

**Contexte :**
- Ce que j'essaie de faire : [description]
- Ce que j'ai déjà essayé : [tentatives]
- Le code concerné :
```
[coller le code]
```

Donne-moi :
1. L'explication de la cause probable de l'erreur
2. La solution étape par étape avec le code corrigé
3. Comment éviter cette erreur à l'avenir
4. Les edge cases similaires à surveiller

Agis comme un architecte logiciel spécialisé en [langage]. Refactore le code suivant en appliquant les principes SOLID et les design patterns appropriés.

**Code actuel :**
```
[coller votre code ici]
```

**Objectifs du refactoring :**
- [ ] Améliorer la lisibilité
- [ ] Réduire la complexité cyclomatique
- [ ] Appliquer le Single Responsibility Principle
- [ ] Extraire les fonctions réutilisables
- [ ] Ajouter le typage strict (si applicable)

Pour chaque modification :
1. Explique POURQUOI tu fais ce changement
2. Montre le code AVANT et APRÈS
3. Indique le pattern utilisé (Strategy, Factory, Observer, etc.)
4. Confirme que le comportement est identique (pas de régression)

Génère des tests unitaires complets pour le code suivant en utilisant [Jest / Pytest / JUnit / etc.].

**Code à tester :**
```
[coller votre code ici]
```

**Exigences :**
- Couverture des cas nominaux (happy path)
- Couverture des cas limites (edge cases)
- Couverture des cas d'erreur (error handling)
- Mocks pour les dépendances externes
- Nommage descriptif des tests (should_xxx_when_yyy)
- Arrange / Act / Assert pattern

Pour chaque test, ajoute un commentaire expliquant :
- Ce qui est testé
- Pourquoi ce cas est important
- Le comportement attendu

Conçois une API REST complète pour [décrire la fonctionnalité] en suivant les meilleures pratiques.

**Contexte :**
- Stack : [Node.js Express / FastAPI / Spring Boot / etc.]
- Base de données : [PostgreSQL / MongoDB / etc.]
- Authentification : [JWT / OAuth2 / API Key]

**Ressource principale :** [nom de la ressource, ex: "utilisateurs", "commandes"]

Génère :
1. **Les endpoints** (méthode HTTP, URL, description) avec la convention RESTful
2. **Les schémas de requête/réponse** (JSON avec types)
3. **Les codes de statut HTTP** appropriés pour chaque endpoint
4. **La validation des données** entrantes
5. **La gestion des erreurs** (format standardisé)
6. **La pagination** pour les endpoints de liste
7. **Le code d'implémentation** d'un endpoint complet (route + controller + service + model)

Bonus : suggère les middlewares utiles (rate limiting, logging, CORS).

Génère une documentation technique complète pour le code suivant.

**Code :**
```
[coller votre code ici]
```

**Génère :**

1. **README.md** avec :
   - Description du module/projet
   - Prérequis et installation
   - Exemples d'utilisation (avec code)
   - Configuration disponible

2. **Docstrings/JSDoc** pour chaque fonction publique :
   - Description claire en une phrase
   - @param avec type et description
   - @returns avec type et description
   - @throws pour les erreurs possibles
   - @example avec un cas d'utilisation concret

3. **Changelog** des modifications si c'est une mise à jour

Adopte un ton professionnel mais accessible. Un développeur junior doit pouvoir comprendre le code après avoir lu la documentation.

Agis comme un DBA expert en optimisation de requêtes [PostgreSQL / MySQL / etc.].

**Requête lente à optimiser :**
```sql
[coller votre requête SQL ici]
```

**Contexte :**
- Tables concernées et leur taille approximative : [ex: users ~1M rows, orders ~10M rows]
- Temps d'exécution actuel : [ex: 4.2 secondes]
- Fréquence d'exécution : [ex: appelée 500 fois/jour]

**Analyse demandée :**
1. Identifie les problèmes de performance (full table scan, jointures coûteuses, etc.)
2. Propose la requête optimisée avec EXPLAIN ANALYZE commenté
3. Suggère les index à créer (avec la commande CREATE INDEX)
4. Estime le gain de performance attendu
5. Propose des alternatives (dénormalisation, matérialized views, caching) si pertinent

Génère un message de commit et une description de pull request pour les changements suivants.

**Diff des changements :**
```diff
[coller votre git diff ici]
```

**Contexte du ticket/issue :** [référence et description courte]

**Génère :**

1. **Message de commit** (Conventional Commits) :
   - Format : type(scope): description courte
   - Types : feat, fix, refactor, test, docs, chore, perf
   - Max 72 caractères pour la première ligne
   - Corps détaillé si nécessaire

2. **Description de PR** :
   - Titre concis
   - ## Changements (liste des modifications)
   - ## Motivation (pourquoi ces changements)
   - ## Tests (comment tester)
   - ## Screenshots (si UI modifié)
   - ## Checklist (breaking changes, migrations, etc.)

Agis comme un expert en cybersécurité applicative (OWASP). Fais un audit de sécurité du code suivant.

**Code à auditer :**
```
[coller votre code ici]
```

**Type d'application :** [Web app / API / Mobile backend]
**Framework :** [Express / Django / Spring / etc.]
**Données sensibles manipulées :** [mots de passe, données bancaires, PII, etc.]

**Vérifie :**
1. **OWASP Top 10** : injection SQL/NoSQL, XSS, CSRF, broken auth, etc.
2. **Gestion des secrets** : hardcoded credentials, API keys exposées
3. **Validation des entrées** : sanitisation, types, limites
4. **Authentification & autorisation** : sessions, tokens, permissions
5. **Exposition de données** : logs, messages d'erreur, headers
6. **Dépendances** : vulnérabilités connues (CVE)

Pour chaque vulnérabilité trouvée :
- Sévérité (critique / haute / moyenne / basse)
- Vecteur d'attaque possible
- Code corrigé
- Référence OWASP

Crée une expression régulière (regex) pour le besoin suivant.

**Ce que je veux matcher :** [description en langage naturel]

**Exemples qui doivent matcher (✅) :**
- [exemple 1]
- [exemple 2]
- [exemple 3]

**Exemples qui ne doivent PAS matcher (❌) :**
- [contre-exemple 1]
- [contre-exemple 2]

**Langage cible :** [JavaScript / Python / Java / etc.]

**Donne-moi :**
1. La regex avec une explication de chaque partie
2. La regex commentée (mode verbose si le langage le supporte)
3. Le code complet d'utilisation (avec la fonction match/test/findall)
4. Les cas limites à surveiller
5. Un lien regex101.com pour tester en live