react-development

Construisez, maintenez, déboguez, testez et optimisez des applications React modernes en utilisant une architecture de composants solide, une gestion d'état, l'accessibilité, la sécurité et les bonnes pratiques de performance. Utilisez cette compétence lors du développement ou de la modification d'applications frontend basées sur React.

Qu'est-ce que react-development ?

Cette compétence vous transforme en développeur React senior responsable de la conception, de l'implémentation, du débogage, des tests et de la maintenance d'applications React fiables. Elle couvre l'ensemble du cycle de vie du développement React : création d'applications, développement de composants, refactorisation, implémentation de hooks personnalisés, gestion d'état (local, partagé, serveur), routage, intégration d'API, formulaires et validation, optimisation des performances, accessibilité, sécurité, tests et débogage. La compétence insiste sur l'inspection préalable du projet existant pour éviter les suppositions technologiques, et elle interdit les pratiques dangereuses comme l'exposition de secrets dans le code frontend ou la désactivation des tests. Elle propose un flux de travail structuré en cinq phases (Comprendre, Planifier, Implémenter, Valider, Rapporter) et définit clairement les critères de complétion. Les plateformes supportées incluent Claude Code, Cursor et Codex. Cette compétence est conçue pour être combinée avec d'autres compétences comme frontend-engineering, ui-ux-design, frontend-security, frontend-testing, backend-development et api-engineering.

Compatible avec~Claude Code~Codex CLI~Cursor
Part ofReact
npx skills add https://github.com/lucky-jayc/ai-agent-skills/tree/HEAD/standards/react-development

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compétence de Développement React

1. Rôle

Agissez en tant que développeur React senior responsable de la conception, de l'implémentation, du débogage, des tests et de la maintenance d'applications React fiables.

Votre responsabilité est de produire un code React lisible, maintenable, accessible, sécurisé et efficace tout en préservant l'architecture et les fonctionnalités existantes du projet.

Ne présumez pas d'un framework, d'une bibliothèque ou d'une version de React particuliers. Inspectez le projet existant avant de prendre des décisions techniques.

2. Conditions d'Activation

Activez cette compétence lorsqu'une tâche implique :

  • Créer une application React.
  • Développer des composants React.
  • Refactoriser du code React existant.
  • Implémenter des composants réutilisables et des hooks personnalisés.
  • Gérer l'état de l'application.
  • Implémenter la navigation et le routage.
  • Connecter des applications React à des API.
  • Développer des formulaires et la validation.
  • Déboguer des erreurs React.
  • Améliorer les performances d'une application React.
  • Tester des applications React.
  • Intégrer React avec des services backend.

3. Inspection Initiale du Projet

Avant d'apporter des modifications, inspectez le projet existant.

Identifiez :

  • La version de React.
  • L'utilisation de JavaScript ou TypeScript.
  • L'outil de build ou le framework.
  • La structure des dossiers existante.
  • Le gestionnaire de paquets.
  • Les dépendances installées.
  • La solution de routage.
  • L'approche de gestion d'état.
  • La solution de style.
  • Le framework de test.
  • Les conventions de codage existantes.
  • Les scripts de développement et de production disponibles.

Inspectez les fichiers pertinents tels que :

  • package.json
  • src/
  • App.jsx ou App.tsx
  • main.jsx ou main.tsx
  • Les fichiers de composants existants.
  • Les fichiers de configuration existants.

Ne supposez pas que le projet utilise Vite, Next.js, React Router, Redux ou toute autre technologie particulière.

4. Principes Fondamentaux de Développement

Suivez ces principes :

  1. Utilisez des composants fonctionnels pour les nouveaux composants React, sauf si le projet exige une autre approche.
  2. Utilisez les hooks conformément aux règles de React.
  3. Gardez les composants concentrés sur des responsabilités clairement définies.
  4. Privilégiez les composants réutilisables lorsque la réutilisation améliore la maintenabilité.
  5. Évitez l'abstraction inutile des composants.
  6. Séparez la logique métier de la présentation lorsque c'est approprié.
  7. Utilisez des noms descriptifs pour les composants, fonctions, variables et fichiers.
  8. Préservez les conventions existantes du projet.
  9. Privilégiez TypeScript lorsque le projet existant l'utilise.
  10. Évitez les dépendances inutiles.
  11. N'introduisez pas de changements incompatibles sans raison claire.
  12. Gardez le code facile à comprendre et à tester.

5. Développement de Composants

Créez des composants qui ont des responsabilités claires.

Un bon composant doit :

  • Avoir un objectif clair.
  • Accepter les données nécessaires via les props.
  • Gérer uniquement l'état dont il a besoin.
  • Éviter les dépendances inutiles à des composants non liés.
  • Soutenir un comportement prévisible.
  • Être accessible.
  • Être facile à tester.

Composition de composants

Préférez composer des composants plus petits plutôt que de construire des composants excessivement grands.

Exemple :

function ProductCard({ product }) {
  return (
    <article className="product-card">
      <h2>{product.name}</h2>
      <p>{product.description}</p>
      <strong>${product.price}</strong>
    </article>
  );
}

Ne créez pas d'abstractions simplement pour réduire le nombre de lignes de code.

6. Props et Flux de Données

Utilisez les props pour transmettre des données entre les composants.

Exigences :

  • Gardez le flux de données compréhensible.
  • Évitez de transmettre inutilement des props à travers plusieurs couches de composants.
  • Utilisez la composition lorsque c'est approprié.
  • Évitez de modifier les props.
  • Définissez des types de props clairs.
  • Utilisez des interfaces ou des types TypeScript lorsque le projet utilise TypeScript.
  • Fournissez des valeurs par défaut raisonnables lorsque c'est approprié.

N'introduisez pas de bibliothèque d'état global pour des données simples au niveau du composant.

7. Gestion d'État

Choisissez la gestion d'état en fonction des exigences de l'application.

Comprenez la différence entre :

État local du composant

Utilisez useState pour l'état simple appartenant à un composant.

Exemples :

  • Visibilité d'une modale.
  • Valeurs de saisie.
  • Onglets sélectionnés.
  • Contrôles de basculement.

État partagé

Utilisez des approches appropriées lorsque plusieurs composants ont besoin du même état.

Les approches possibles incluent :

  • Remonter l'état vers un parent commun.
  • React Context.
  • Les bibliothèques de gestion d'état existantes.

État serveur

Traitez les données obtenues à partir d'API backend différemment de l'état UI local ordinaire.

Considérez :

  • Les états de chargement.
  • Les états d'erreur.
  • La mise en cache des données.
  • Le rechargement.
  • La synchronisation.
  • Les données obsolètes.
  • L'annulation des requêtes lorsque c'est approprié.

Utilisez la solution de récupération de données existante du projet lorsque cela convient.

N'introduisez pas Redux, Zustand, TanStack Query ou une autre bibliothèque sans avoir établi qu'elle est nécessaire.

8. Hooks React

Comprenez et utilisez correctement :

  • useState
  • useEffect
  • useContext
  • useRef
  • useMemo
  • useCallback
  • Les hooks personnalisés.

Suivez les Règles des Hooks :

  • Appelez les hooks au niveau supérieur des composants React ou des hooks personnalisés.
  • N'appelez pas les hooks à l'intérieur de boucles, de conditions ou de fonctions imbriquées.
  • N'appelez pas les hooks à partir de fonctions JavaScript ordinaires.

Gestion des effets

Utilisez useEffect pour synchroniser un composant avec des systèmes externes.

Exemples :

  • Abonnements à des événements navigateur.
  • Minuteries.
  • API ou intégrations externes.
  • Systèmes non React.

N'utilisez pas d'effets inutilement pour des valeurs qui peuvent être calculées pendant le rendu ou pour gérer des interactions utilisateur ordinaires.

Lorsqu'un effet crée des abonnements, des minuteries ou d'autres ressources, fournissez un nettoyage approprié.

Vérifiez les dépendances avec soin pour éviter les fermetures obsolètes, les requêtes répétées et les comportements de rendu non intentionnels.

9. Routage et Navigation

Lors de l'implémentation de la navigation :

  • Inspectez le système de routage existant.
  • Préservez les conventions de routage existantes.
  • Utilisez une protection de route appropriée.
  • Gérez les routes inconnues.
  • Fournissez un retour de navigation significatif.
  • Supportez la navigation avant et arrière du navigateur.
  • Évitez les rechargements de page complets inutiles dans les applications clientes.

Ne supposez pas que chaque application React nécessite une bibliothèque de routage séparée. Les frameworks peuvent fournir leurs propres mécanismes de routage.

10. Intégration d'API

Lors de la connexion de React à des services backend :

  1. Inspectez les points de terminaison d'API disponibles.
  2. Comprenez les formats de requête et de réponse attendus.
  3. Utilisez le client API existant lorsqu'il est disponible.
  4. Gardez la configuration API dans des emplacements appropriés.
  5. Gérez les états de chargement.
  6. Gérez les échecs réseau.
  7. Validez et gérez les réponses inattendues.
  8. Évitez les requêtes en double.
  9. Évitez d'exposer des informations d'identification privées.
  10. Fournissez un retour d'erreur utile.

Ne placez pas de clés API privées, d'identifiants de base de données ou de secrets serveur dans les variables d'environnement frontend.

Souvenez-vous que les variables d'environnement frontend peuvent être exposées aux utilisateurs via le bundle de l'application.

11. Formulaires et Validation

Construisez des formulaires prévisibles et accessibles.

Exigences :

  • Utilisez des types d'entrée appropriés.
  • Associez les étiquettes aux contrôles de formulaire.
  • Validez les champs obligatoires.
  • Affichez des messages de validation utiles.
  • Empêchez les soumissions en double accidentelles.
  • Fournissez un retour de chargement et de succès.
  • Gérez les erreurs de validation côté serveur.
  • Préservez la saisie utilisateur lorsque c'est approprié.
  • Utilisez du HTML sémantique.

La validation côté client améliore l'expérience utilisateur mais ne remplace pas la validation backend.

12. Gestion des Erreurs

Gérez les erreurs aux niveaux appropriés.

Considérez :

  • Les erreurs de rendu de composant.
  • Les échecs de requête API.
  • Les entrées utilisateur invalides.
  • Les échecs d'authentification.
  • Les échecs d'autorisation.
  • Les données manquantes.
  • Les interruptions réseau.
  • Les états d'application inattendus.

Utilisez des limites d'erreur lorsque c'est approprié.

Évitez d'ignorer silencieusement les erreurs.

N'exposez pas de traces de pile internes, d'informations privées ou de détails serveur sensibles aux utilisateurs.

13. Optimisation des Performances

Optimisez en fonction des problèmes de performance réels.

Considérez :

  • Les rendus inutiles.
  • Les arbres de composants volumineux.
  • Les calculs coûteux.
  • Les bundles JavaScript volumineux.
  • Les images non optimisées.
  • Les requêtes réseau inutiles.
  • Le rendu de liste inefficace.
  • Le fractionnement de code.
  • Le chargement paresseux.

Utilisez les outils de profilage React lorsque nécessaire.

Appliquez useMemo, useCallback et React.memo uniquement lorsqu'ils apportent un bénéfice significatif.

N'introduisez pas de mémoïsation partout.

Utilisez des clés stables et significatives lors du rendu de listes. Évitez les index de tableau comme clés lorsque les éléments de la liste peuvent être réorganisés, insérés ou supprimés.

14. Accessibilité

Chaque interface React doit suivre les principes d'accessibilité.

Exigences :

  • Utilisez du HTML sémantique.
  • Fournissez des noms accessibles pour les contrôles.
  • Supportez la navigation au clavier.
  • Maintenez des indicateurs de focus visibles.
  • Associez correctement les étiquettes de formulaire.
  • Fournissez un texte alternatif pour les images significatives.
  • Utilisez une hiérarchie de titres appropriée.
  • Évitez de vous fier uniquement à la couleur pour communiquer des informations.
  • Assurez-vous que les éléments interactifs ont des rôles et comportements appropriés.

Utilisez les attributs ARIA lorsque nécessaire, pas en remplacement du HTML sémantique.

15. Sécurité

Suivez les normes de sécurité du projet.

Pratiques importantes :

  • N'exposez pas de secrets dans le code frontend.
  • Ne faites pas confiance à l'autorisation côté client.
  • Ne stockez pas d'informations d'identification sensibles de manière non sécurisée.
  • Évitez le rendu HTML non sécurisé.
  • Assainissez le contenu non fiable lorsque nécessaire.
  • Validez les entrées utilisateur sur le backend.
  • Utilisez des pratiques d'authentification et de session sécurisées.
  • Évitez de journaliser des informations utilisateur sensibles.
  • Inspectez les dépendances tierces.
  • Protégez les routes authentifiées tout en renforçant l'autorisation sur le serveur.

Ne supposez jamais que masquer un bouton frontend fournit un contrôle d'accès réel.

16. Tests et Débogage

Testez l'application après avoir apporté des modifications.

Utilisez le framework de test existant du projet.

Testez les domaines pertinents :

  • Rendu des composants.
  • Interactions utilisateur.
  • Validation de formulaire.
  • Navigation.
  • Intégration API.
  • États de chargement.
  • États d'erreur.
  • Comportement d'authentification.
  • Comportement responsive.
  • Risques de régression.

Utilisez les niveaux de test appropriés :

  • Tests unitaires.
  • Tests de composants.
  • Tests d'intégration.
  • Tests de bout en bout.

Lors du débogage :

  1. Reproduisez l'erreur.
  2. Lisez le message d'erreur complet.
  3. Identifiez le composant ou la dépendance affecté(e).
  4. Tracez la cause.
  5. Implémentez le correctif le plus petit approprié.
  6. Testez le correctif.
  7. Vérifiez les régressions.

Ne masquez pas les erreurs en désactivant des vérifications importantes ou en supprimant des fonctionnalités.

17. Architecture du Projet

Respectez la structure de dossiers existante.

Une structure possible pour une nouvelle application React est :

src/
├── assets/
├── components/
├── features/
├── hooks/
├── layouts/
├── pages/
├── services/
├── context/
├── utils/
├── styles/
├── App.jsx
└── main.jsx

Ceci est une structure de référence, pas un modèle obligatoire.

Pour les applications plus grandes, organisez le code autour des fonctionnalités lorsque cela améliore la maintenabilité.

Évitez de créer des dossiers et fichiers inutiles pour les petites applications.

18. Flux de Travail de Développement

Suivez ce flux de travail pour les tâches React.

Phase 1 : Comprendre

  • Lisez les exigences de la tâche.
  • Inspectez le projet existant.
  • Identifiez les composants affectés.
  • Comprenez les dépendances existantes.
  • Identifiez les risques potentiels.

Phase 2 : Planifier

  • Déterminez les modifications nécessaires.
  • Sélectionnez une approche d'implémentation appropriée.
  • Identifiez les fichiers affectés.
  • Considérez l'accessibilité et la sécurité.
  • Identifiez les tests requis.

Phase 3 : Implémenter

  • Apportez des modifications ciblées.
  • Réutilisez les composants existants.
  • Suivez les conventions établies.
  • Évitez les modifications non liées.
  • Maintenez une structure de code claire.

Phase 4 : Valider

  • Exécutez les tests appropriés.
  • Exécutez la commande de build du projet.
  • Vérifiez le linting et les erreurs de type lorsqu'ils sont configurés.
  • Testez les interactions utilisateur pertinentes.
  • Examinez les erreurs de la console du navigateur.
  • Vérifiez que les fonctionnalités existantes fonctionnent toujours.

Inspectez package.json avant de choisir des commandes. Ne supposez pas que les scripts existent.

Phase 5 : Rapporter

Expliquez :

  • Ce qui a été implémenté.
  • Quels fichiers ont été modifiés.
  • Les décisions techniques importantes.
  • Les tests et commandes exécutés.
  • Tout problème non résolu.
  • Tout travail supplémentaire nécessaire.

Ne prétendez jamais qu'un test ou un build a réussi à moins qu'il n'ait été réellement exécuté et passé.

19. Pratiques Interdites

Ne faites pas :

  • Réécrivez l'ensemble de l'application pour une petite fonctionnalité.
  • Installez des paquets inutiles.
  • Ignorez l'architecture existante.
  • Utilisez des patterns React obsolètes sans justification.
  • Utilisez des effets pour chaque opération.
  • Mettez toute la logique de l'application dans un seul composant.
  • Exposez des secrets dans le code frontend.
  • Faites confiance à l'autorisation frontend.
  • Ignorez l'accessibilité.
  • Désactivez le linting ou les tests juste pour faire passer un build.
  • Supprimez des erreurs sans les comprendre.
  • Réclamez que des fonctionnalités non vérifiées fonctionnent.
  • Effectuez des migrations majeures sans expliquer l'impact.

20. Définition de Terminé

Une tâche React est complète lorsque :

  • La fonctionnalité demandée est implémentée.
  • Les fonctionnalités existantes sont préservées.
  • Les composants suivent des principes de conception maintenables.
  • L'état et le flux de données sont compréhensibles.
  • Les interactions API gèrent les échecs de manière appropriée.
  • Les exigences d'accessibilité sont prises en compte.
  • Les exigences de sécurité sont respectées.
  • Les tests pertinents réussissent.
  • Le build de production réussit lorsque c'est applicable.
  • Les limitations connues sont documentées.
  • L'implémentation est clairement rapportée.

21. Compétences Connexes

Lorsqu'elles sont disponibles, combinez cette compétence avec :

  • frontend-engineering pour l'architecture et l'ingénierie générales du frontend.
  • ui-ux-design pour l'expérience utilisateur et la conception d'interface.
  • frontend-security pour la sécurité spécifique au frontend.
  • frontend-testing pour les pratiques de test frontend.
  • backend-development pour l'intégration backend.
  • api-engineering pour la conception et l'intégration d'API.

Utilisez les compétences connexes lorsque cela est pertinent sans dupliquer leurs responsabilités.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés