100 Prompts IA pour les Développeurs Web — Guide Complet

Génère une API REST complète en [langage] avec [framework] pour une ressource [nom_ressource]. Inclure : les routes CRUD (GET, POST, PUT, DELETE), la validation des données avec [bibliothèque_validation], la gestion des erreurs avec codes HTTP appropriés, et les commentaires JSDoc. Utilise le pattern Repository pour la couche de données.

Crée un composant React en TypeScript pour [description_composant]. Le composant doit : accepter des props typées avec une interface, gérer les états de chargement et d'erreur, être accessible (ARIA), inclure des tests unitaires avec React Testing Library, et utiliser [CSS_solution] pour le style. Fournis également un fichier Storybook.

Crée un hook React personnalisé useData[NomRessource] qui gère les appels API à l'endpoint [url_endpoint]. Le hook doit exposer : les données, un état de chargement (isLoading), un état d'erreur, une fonction de rechargement (refetch), et supporter l'annulation des requêtes avec AbortController. Inclure le typage TypeScript complet.

Écris un middleware Express en TypeScript pour authentifier les requêtes via JWT. Le middleware doit : vérifier le header Authorization Bearer, décoder et valider le token avec la clé secrète, attacher l'utilisateur décodé à req.user, retourner des erreurs 401/403 explicites, et gérer l'expiration du token. Ajoute des logs structurés avec winston.

Génère une configuration [Webpack/Vite] optimisée pour un projet [framework] en production. Inclure : le code splitting par routes, la compression des assets (gzip/brotli), l'optimisation des images, le tree shaking, les source maps pour le debugging, et les variables d'environnement. Explique chaque option importante.

Crée le schéma de base de données et les migrations SQL pour [description_application]. Inclure les tables pour [entités], les relations (foreign keys), les index pour les requêtes fréquentes, les contraintes de validation, et les triggers pour updated_at automatique. Fournis aussi les requêtes Drizzle/Prisma correspondantes.

Crée un docker-compose.yml pour un environnement de développement avec [stack_technologique]. Inclure : le hot-reload pour le frontend et le backend, un service de base de données [PostgreSQL/MongoDB] avec données persistantes, un service Redis pour le cache, les variables d'environnement via .env, et les healthchecks. Ajoute un Makefile avec les commandes courantes.

Génère un formulaire React complet en TypeScript pour [type_formulaire] en utilisant React Hook Form et Zod. Le formulaire doit avoir : la validation côté client avec messages d'erreur en français, les états désactivé pendant la soumission, la gestion des erreurs API, l'accessibilité complète (labels, aria-describedby), et être stylé avec [Tailwind/CSS Modules].

Implémente un service de cache en [langage] utilisant Redis pour mettre en cache les résultats de [type_données]. Le service doit inclure : les méthodes get/set/delete avec TTL configurable, la sérialisation/désérialisation automatique, un pattern cache-aside, la gestion des erreurs de connexion avec fallback, et des métriques de hit/miss ratio.

Crée un outil CLI en Node.js avec [commander/yargs] pour [description_outil]. L'outil doit avoir : des commandes et sous-commandes avec aide intégrée, la validation des arguments et options, un mode interactif avec inquirer.js, des sorties colorées avec chalk, et une gestion propre des erreurs avec codes de sortie.

Implémente l'intégration Stripe pour [type_paiement : abonnement/paiement unique] dans une application [framework]. Inclure : la création de l'intention de paiement côté serveur, le composant Stripe Elements côté client, les webhooks pour les événements de paiement, la gestion des erreurs utilisateur, et les tests avec la carte de test Stripe.

Génère une configuration ESLint et Prettier complète pour un projet [framework] avec TypeScript. Inclure les règles pour : la qualité du code, les imports ordonnés, les règles spécifiques à [React/Vue/Angular], l'accessibilité (eslint-plugin-jsx-a11y), la sécurité (eslint-plugin-security), et les hooks pre-commit avec husky. Explique les règles les plus importantes.

Analyse cette stack trace JavaScript et explique-moi : 1) La cause racine de l'erreur, 2) Le fichier et la ligne exacte où l'erreur se produit, 3) La séquence d'appels qui a mené à l'erreur, 4) Les solutions possibles avec des exemples de code, 5) Comment prévenir ce type d'erreur à l'avenir. Stack trace : [coller la stack trace ici]

Cette requête SQL prend [X secondes] à s'exécuter sur une table de [N millions] de lignes. Analyse le plan d'exécution suivant et propose des optimisations : [coller le plan EXPLAIN ANALYZE]. Considère : les index manquants, les problèmes de N+1 queries, les jointures inefficaces, et les alternatives avec des CTEs ou sous-requêtes. Fournis la requête optimisée.

J'ai une erreur CORS entre mon frontend sur [URL_frontend] et mon backend sur [URL_backend]. Voici les headers de ma requête et la réponse du serveur : [coller les headers]. Explique exactement pourquoi l'erreur se produit, quels headers CORS je dois configurer côté serveur avec [Express/Nginx/autre], et si je dois modifier quelque chose côté client. Fournis le code de configuration.

Mon application Node.js consomme de plus en plus de mémoire au fil du temps. Voici le profil mémoire et les logs : [coller les informations]. Aide-moi à identifier : les event listeners non supprimés, les closures retenant des références, les caches sans limite de taille, les connexions base de données non fermées, et les timers actifs. Fournis un plan d'investigation et les corrections.

J'ai cette erreur TypeScript que je ne comprends pas : [coller l'erreur]. Voici le code concerné : [coller le code]. Explique l'erreur en termes simples, pourquoi TypeScript la signale, et propose 2-3 façons de la corriger avec leurs avantages et inconvénients. Si l'erreur vient d'un type générique complexe, décompose-le étape par étape.

Mon composant React [NomComposant] se re-rend trop souvent et cause des problèmes de performance. Voici le code du composant et le profil React DevTools : [coller le code]. Identifie toutes les causes de re-renders inutiles (props instables, contexte mal optimisé, closures dans les handlers, etc.) et propose les corrections avec useMemo, useCallback, React.memo, ou une restructuration.

J'ai une erreur d'hydratation Next.js : [coller le message d'erreur]. Le composant est : [coller le code]. Explique pourquoi le HTML rendu côté serveur ne correspond pas au rendu côté client, les causes courantes de ce problème (dates, IDs aléatoires, données dynamiques, extensions navigateur), et comment le corriger en utilisant useEffect, suppressHydrationWarning, ou dynamic().

Analyse ces logs d'erreur de production et identifie les patterns : [coller les logs]. Je veux savoir : quelles erreurs se répètent le plus, s'il y a une corrélation temporelle, les erreurs les plus critiques à traiter en priorité, et une liste d'actions correctives avec leur impact estimé. Format de réponse : tableau récapitulatif + plan d'action priorisé.

Ma connexion WebSocket entre [client] et [serveur] se déconnecte après [durée] ou ne se reconnecte pas correctement. Voici les logs : [coller les logs]. Analyse les causes possibles : timeouts, heartbeat manquant, gestion des reconnexions, problèmes de proxy/load balancer, limites de connexions simultanées. Fournis le code de gestion robuste des connexions WebSocket.

Ce test [Jest/Vitest/Cypress] échoue avec le message : [coller le message d'erreur]. Voici le test et le code testé : [coller le code]. Explique pourquoi le test échoue, si c'est le test ou le code qui est incorrect, et comment corriger le problème. Si le test teste mal le comportement, propose une meilleure stratégie de test.

Mon application charge lentement. Voici les métriques Lighthouse et la cascade réseau : [coller les métriques]. Identifie les [3-5] optimisations avec le plus grand impact sur le LCP, FID, et CLS. Pour chaque optimisation, explique : l'impact attendu en millisecondes, la difficulté d'implémentation, et fournis le code ou la configuration nécessaire.

J'ai cette erreur lors de l'installation de dépendances npm : [coller l'erreur]. Voici mon package.json : [coller le fichier]. Explique le conflit de versions, quelles dépendances sont incompatibles, et comment le résoudre sans casser d'autres fonctionnalités. Indique si je dois utiliser --legacy-peer-deps, résoudre manuellement, ou mettre à jour certains packages.

Écris des tests unitaires complets avec [Jest/Vitest] pour cette fonction : [coller la fonction]. Couvre : les cas nominaux, les cas limites (valeurs null, undefined, tableaux vides, chaînes vides), les cas d'erreur, et les entrées invalides. Utilise des noms de tests descriptifs en français, le pattern AAA (Arrange, Act, Assert), et les matchers Jest les plus appropriés.

Crée des tests d'intégration avec Supertest pour les endpoints API suivants : [lister les endpoints]. Les tests doivent : utiliser une base de données de test isolée, tester les codes de statut HTTP, les corps de réponse, les headers, les cas d'erreur (404, 422, 500), et nettoyer les données après chaque test. Inclure la configuration du setup/teardown.

Crée des tests E2E avec Playwright pour le parcours utilisateur suivant sur [URL_application] : [décrire le parcours]. Les tests doivent : utiliser les Page Object Models, gérer l'authentification, tester sur [Chrome/Firefox/Safari], capturer des screenshots en cas d'échec, et s'exécuter en mode headless en CI. Inclure les assertions sur l'accessibilité.

Analyse ce code pour les vulnérabilités de sécurité : [coller le code]. Vérifie spécifiquement : les injections SQL/NoSQL, les failles XSS, les problèmes CSRF, l'exposition de données sensibles, l'authentification et autorisation incorrectes, les dépendances vulnérables, et la gestion des erreurs qui expose des informations. Pour chaque vulnérabilité trouvée, indique la sévérité (OWASP) et le code corrigé.

Voici mon rapport de couverture de code [Istanbul/V8] : [coller le rapport]. Les fichiers les moins couverts sont [liste]. Pour chaque fichier, génère des tests qui couvrent les branches non testées, explique pourquoi ces branches sont importantes à tester, et identifie si certains chemins de code sont inaccessibles (dead code).

J'ai besoin de mocker [service externe : API tiers, base de données, système de fichiers] pour les tests de [NomModule]. Montre-moi comment créer des mocks avec [Jest/Vitest] qui : simulent les réponses normales et d'erreur, sont réutilisables entre les tests, ne font pas d'appels réseau réels, et vérifient que le code appelle bien les bonnes méthodes avec les bons arguments.

Écris un script k6 pour tester les performances de l'API [URL_API] sous charge. Le test doit simuler : [N] utilisateurs simultanés pendant [durée], les scénarios de montée en charge progressive, les endpoints critiques [liste], et capturer les métriques p95/p99. Définis les seuils d'acceptance et les critères d'échec. Inclure un script de rapport.

Refactorise ce code JavaScript legacy vers du TypeScript moderne en utilisant les patterns actuels : [coller le code]. Applique : les types TypeScript stricts, async/await à la place des callbacks, les modules ES6, la déstructuration, les méthodes tableau fonctionnelles (map/filter/reduce), et sépare les responsabilités en fonctions pures. Garde le même comportement et ajoute des tests.

Analyse la complexité de ce code et identifie les fonctions trop complexes : [coller le code]. Pour les fonctions avec une complexité cyclomatique > 10, propose des refactorisations pour : extraire des sous-fonctions, utiliser des early returns, remplacer les switch/case par des tables de dispatch, et appliquer le principe de responsabilité unique. Maintiens les tests existants.

Génère la documentation JSDoc/TSDoc complète pour ce module : [coller le code]. Pour chaque fonction publique, inclure : la description, les paramètres avec leurs types et descriptions, la valeur de retour, les exceptions possibles, un exemple d'utilisation, et les cas limites à connaître. Génère aussi un README.md du module.

Crée une pipeline CI/CD avec [GitHub Actions/GitLab CI] pour un projet [framework]. La pipeline doit inclure : les étapes lint, tests unitaires, tests d'intégration, build, analyse de sécurité (Snyk/Dependabot), déploiement automatique sur staging, et déploiement manuel sur production avec approbation. Optimise pour réduire le temps d'exécution en parallélisant les jobs.

Audite l'accessibilité de ce composant React : [coller le code]. Vérifie la conformité WCAG 2.1 niveau AA : les attributs ARIA appropriés, la navigation clavier, le contraste des couleurs, les alternatives textuelles, l'ordre de focus logique, et les annonces pour les lecteurs d'écran. Fournis le composant corrigé avec des explications pour chaque modification.

Je dois construire [description_application] avec les contraintes suivantes : [liste des contraintes : budget, équipe, trafic attendu, délai]. Compare les architectures possibles (monolithique, microservices, serverless, JAMstack) en fonction de : la complexité opérationnelle, le coût d'infrastructure, la scalabilité, la vitesse de développement, et recommande la meilleure option avec justification.

Mon application [description] a des problèmes de gestion d'état avec [Redux/Context API/Zustand/autre]. Voici la structure actuelle : [décrire la structure]. Analyse les problèmes actuels (prop drilling, mises à jour trop fréquentes, état trop centralisé) et propose une architecture d'état optimisée avec des exemples de code pour les cas d'usage les plus courants.

Je dois migrer [N millions] de lignes de [ancienne_structure] vers [nouvelle_structure] sans interruption de service. Crée un plan de migration en plusieurs étapes avec : les scripts SQL, la stratégie de déploiement progressif (expand/contract pattern), les rollbacks possibles, les tests de validation de données, et l'estimation du temps d'exécution.

Conçois une stratégie de versionnement d'API pour [nom_API] qui doit évoluer sans casser les clients existants. Compare les approches (URL path /v1/, header Accept, query param), recommande la meilleure pour mon cas d'usage, et fournis : les conventions de nommage, la politique de dépréciation, la documentation Swagger/OpenAPI, et des exemples de migration entre versions.

J'ai un monolithe [framework] de [N lignes] que je veux décomposer progressivement. Voici les modules principaux : [liste]. Propose une stratégie de découpage basée sur les bounded contexts DDD, identifie les dépendances circulaires à résoudre, l'ordre de migration recommandé, et comment maintenir les deux systèmes en parallèle avec le pattern Strangler Fig.

Implémente le pattern CQRS pour le module [nom_module] de mon application [framework]. Sépare les commandes (écriture) des requêtes (lecture) avec : les handlers de commandes et queries, les événements du domaine, les projections pour les lectures optimisées, et l'intégration avec [base_données]. Fournis des exemples concrets pour les opérations [CRUD] de ma ressource [nom_ressource].

Je dois choisir entre [option_A] et [option_B] pour [besoin_spécifique] dans mon projet [description]. Compare les deux options sur : les performances, la courbe d'apprentissage, la maturité et l'écosystème, la maintenabilité à long terme, le coût en cloud/licences, et l'adéquation avec mon équipe de [N] développeurs. Conclus avec une recommandation argumentée.

Conçois un système de notifications en temps réel pour [N] utilisateurs simultanés. Compare WebSockets, Server-Sent Events, et Long Polling pour mon cas d'usage. Fournis l'architecture avec : le serveur [Node.js/Go/autre], le stockage des notifications non lues, la gestion des reconnexions, le scaling horizontal, et les exemples de code pour le serveur et le client.

Je dois démarrer un projet [type_projet] en [durée] avec une équipe de [N] développeurs. Crée un plan technique détaillé incluant : le choix du stack technologique justifié, la structure des dossiers, les conventions de code, le setup CI/CD initial, les étapes de développement priorisées (MVP en [durée], v1.0 en [durée]), et les risques techniques à anticiper.

Mon application [description] a des problèmes de performance à [N] requêtes/seconde. Voici l'architecture actuelle : [décrire]. Propose une stratégie de cache multi-niveaux (CDN, cache applicatif, cache base de données) avec : les données à mettre en cache, les TTL appropriés, les stratégies d'invalidation, et l'implémentation avec [Redis/Memcached/autre].

Implémente le flux OAuth 2.0 avec [Google/GitHub/autre] dans une application [framework]. Couvre les deux flows : Authorization Code (web) et PKCE (mobile/SPA). Inclure : la configuration du provider, les routes callback, le stockage sécurisé des tokens, le refresh automatique, la gestion de la déconnexion, et les bonnes pratiques de sécurité (state parameter, PKCE challenge).

Conçois une stratégie de logging pour une application [description] en production. Définis : les niveaux de log (DEBUG/INFO/WARN/ERROR), les informations à inclure dans chaque log (timestamp, trace ID, user ID, etc.), le format structuré JSON, l'intégration avec [ELK/Loki/CloudWatch], les alertes automatiques sur les erreurs critiques, et la politique de rétention.

Convertis ce design Figma en composant React TypeScript : [description détaillée du design ou lien]. Respecte exactement : les espacements (gap, padding, margin en utilisant les valeurs Tailwind), les couleurs (utilise les variables CSS custom), la typographie (famille, taille, graisse), les états interactifs (hover, focus, active, disabled), et rends le composant responsive pour mobile/tablette/desktop.

Transforme ces requirements client en tickets de développement structurés : [coller les requirements]. Pour chaque fonctionnalité, crée un ticket avec : le titre au format user story (En tant que [persona], je veux... afin de...), la description technique, les critères d'acceptance (Given/When/Then), l'estimation en points de complexité, et les dépendances entre tickets.

Migre ce fichier JavaScript vers TypeScript strict : [coller le code]. Ajoute : les interfaces pour tous les objets, les types de retour explicites, les types génériques là où approprié, les types utilitaires (Partial, Required, Pick, Omit), et résous tous les any implicites. Commente les décisions de typage non évidentes et indique si certains types nécessitent des @types à installer.

Convertis ce CSS en classes Tailwind équivalentes : [coller le CSS]. Pour les valeurs non standard, utilise les classes arbitraires Tailwind [value]. Si une règle CSS ne peut pas être convertie directement, explique pourquoi et propose une alternative. Ajoute les variantes responsive et les pseudo-classes (hover, focus) appropriées.

Écris une fonction TypeScript qui transforme ces données JSON d'entrée : [coller exemple JSON entrée] vers ce format de sortie : [coller exemple JSON sortie]. La transformation doit gérer : les champs manquants ou null, les tableaux imbriqués, les conversions de format (dates, nombres, booléens), et valider les données avec Zod avant et après transformation.

Génère les requêtes SQL pour implémenter ces fonctionnalités dans une base [PostgreSQL/MySQL] : [décrire les fonctionnalités]. Inclure : les requêtes SELECT avec JOINs et agrégations, les requêtes INSERT/UPDATE avec gestion des conflits (ON CONFLICT), les index appropriés, les transactions pour les opérations multi-tables, et les explications sur les choix de performance.

Convertis ce composant React en classe vers un composant fonctionnel avec les hooks appropriés : [coller le composant classe]. Remplace : componentDidMount par useEffect, componentDidUpdate par useEffect avec dépendances, componentWillUnmount par le cleanup de useEffect, setState par useState, et les méthodes de cycle de vie complexes par des hooks personnalisés si nécessaire.

J'ai une API REST qui retourne [description_données]. Crée des adaptateurs pour : 1) Un client mobile (données allégées, pagination), 2) Un client web (données complètes avec relations), 3) Un webhook externe (format spécifique du partenaire). Utilise le pattern Adapter/Transformer et génère les interfaces TypeScript pour chaque format de sortie.

Génère la spécification OpenAPI 3.0 (Swagger) complète pour cette API Express : [coller les routes]. Inclure : les descriptions des endpoints, les schémas de requête et réponse avec exemples, les codes d'erreur documentés, l'authentification Bearer, et les examples curl. Formate en YAML valide directement importable dans Swagger UI.

Génère des données de seed réalistes pour cette base de données : [décrire le schéma]. Crée [N] enregistrements par table avec : des relations cohérentes entre les tables, des données qui couvrent les cas limites (valeurs max, caractères spéciaux, multilangue), un fichier seed.ts compatible avec [Prisma/Drizzle/Knex], et un script pour réinitialiser et reseed facilement.

Écris un script Node.js pour scraper et structurer le contenu de [URL_ou_description]. Utilise [Cheerio/Playwright] pour extraire : [liste des éléments à extraire], nettoyer les données (supprimer les espaces inutiles, normaliser les URLs), les transformer en JSON structuré, et les sauvegarder dans un fichier. Gère la pagination et les erreurs de réseau.

Génère un client API TypeScript pour consommer l'API suivante (spécification OpenAPI ou description des endpoints) : [coller la spec]. Le client doit avoir : les méthodes typées pour chaque endpoint, la gestion automatique des erreurs, le support des tokens d'authentification, l'intercepteur de requêtes pour les logs, et une configuration de base URL injectable.