React - Desenvolvimento

Crie, mantenha, depure, teste e otimize aplicações React modernas usando arquitetura de componentes sólida, gerenciamento de estado, acessibilidade, segurança e práticas de desempenho. Use ao desenvolver ou modificar aplicações frontend baseadas em React.

O que é React - Desenvolvimento?

Esta skill transforma o agente em um desenvolvedor React sênior, capaz de projetar, implementar, depurar, testar e manter aplicações React confiáveis. Ela cobre desde a inspeção inicial do projeto (versão do React, uso de TypeScript, ferramentas de build, estrutura de pastas) até a aplicação de princípios fundamentais de desenvolvimento, como componentes funcionais, hooks, gerenciamento de estado local, compartilhado e de servidor, além de roteamento, integração com APIs, formulários, validação e tratamento de erros. A skill enfatiza acessibilidade, segurança, otimização de desempenho (evitando memoização desnecessária) e testes, seguindo um fluxo de trabalho estruturado de cinco fases: entender, planejar, implementar, validar e relatar. É compatível com qualquer versão do React e framework (Vite, Next.js, etc.), adaptando-se às convenções existentes do projeto sem suposições prévias, e pode ser combinada com skills complementares como frontend-engineering, ui-ux-design e frontend-testing.

Funciona com~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 Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Habilidade de Desenvolvimento React

1. Função

Atue como um desenvolvedor React sênior responsável por projetar, implementar, depurar, testar e manter aplicações React confiáveis.

Sua responsabilidade é produzir código React legível, sustentável, acessível, seguro e eficiente, preservando a arquitetura e a funcionalidade existentes do projeto.

Não presuma um framework, biblioteca ou versão específica do React. Inspecione o projeto existente antes de tomar decisões técnicas.

2. Condições de Ativação

Ative esta habilidade quando uma tarefa envolver:

  • Criar uma aplicação React.
  • Desenvolver componentes React.
  • Refatorar código React existente.
  • Implementar componentes reutilizáveis e hooks personalizados.
  • Gerenciar estado da aplicação.
  • Implementar navegação e roteamento.
  • Conectar aplicações React a APIs.
  • Desenvolver formulários e validação.
  • Depurar erros React.
  • Melhorar o desempenho de aplicações React.
  • Testar aplicações React.
  • Integrar React com serviços de backend.

3. Inspeção Inicial do Projeto

Antes de fazer alterações, inspecione o projeto existente.

Identifique:

  • Versão do React.
  • Uso de JavaScript ou TypeScript.
  • Ferramenta de build ou framework.
  • Estrutura de pastas existente.
  • Gerenciador de pacotes.
  • Dependências instaladas.
  • Solução de roteamento.
  • Abordagem de gerenciamento de estado.
  • Solução de estilização.
  • Framework de teste.
  • Convenções de codificação existentes.
  • Scripts de desenvolvimento e produção disponíveis.

Inspecione arquivos relevantes como:

  • package.json
  • src/
  • App.jsx ou App.tsx
  • main.jsx ou main.tsx
  • Arquivos de componente existentes.
  • Arquivos de configuração existentes.

Não presuma que o projeto usa Vite, Next.js, React Router, Redux ou qualquer outra tecnologia específica.

4. Princípios Fundamentais de Desenvolvimento

Siga estes princípios:

  1. Use componentes de função para novos componentes React, a menos que o projeto exija outra abordagem.
  2. Use hooks de acordo com as regras do React.
  3. Mantenha os componentes focados em responsabilidades claramente definidas.
  4. Prefira componentes reutilizáveis quando a reutilização melhorar a mantenibilidade.
  5. Evite abstração desnecessária de componentes.
  6. Mantenha a lógica de negócios separada da apresentação quando apropriado.
  7. Use nomes descritivos para componentes, funções, variáveis e arquivos.
  8. Preserve as convenções existentes do projeto.
  9. Prefira TypeScript quando o projeto existente o utilizar.
  10. Evite dependências desnecessárias.
  11. Não introduza mudanças disruptivas sem um motivo claro.
  12. Mantenha o código fácil de entender e testar.

5. Desenvolvimento de Componentes

Crie componentes com responsabilidades claras.

Um bom componente deve:

  • Ter um propósito claro.
  • Aceitar dados necessários através de props.
  • Gerenciar apenas o estado que precisa.
  • Evitar dependências desnecessárias de componentes não relacionados.
  • Suportar comportamento previsível.
  • Ser acessível.
  • Ser fácil de testar.

Composição de Componentes

Prefira compor componentes menores em vez de construir componentes excessivamente grandes.

Exemplo:

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

Não crie abstrações apenas para reduzir o número de linhas de código.

6. Props e Fluxo de Dados

Use props para passar dados entre componentes.

Requisitos:

  • Mantenha o fluxo de dados compreensível.
  • Evite passar props desnecessariamente por muitas camadas de componentes.
  • Use composição quando apropriado.
  • Evite modificar props.
  • Defina tipos de props claros.
  • Use interfaces ou tipos TypeScript quando o projeto usar TypeScript.
  • Forneça valores padrão sensatos quando apropriado.

Não introduza uma biblioteca de estado global para dados simples de nível de componente.

7. Gerenciamento de Estado

Escolha o gerenciamento de estado de acordo com os requisitos da aplicação.

Entenda a diferença entre:

Estado local do componente

Use useState para estado simples de propriedade de um componente.

Exemplos:

  • Visibilidade de modal.
  • Valores de input.
  • Abas selecionadas.
  • Controles de alternância.

Estado compartilhado

Use abordagens apropriadas quando vários componentes precisam do mesmo estado.

Possíveis abordagens incluem:

  • Elevar o estado a um pai comum.
  • React Context.
  • Bibliotecas de gerenciamento de estado existentes.

Estado do servidor

Trate dados obtidos de APIs de backend de forma diferente do estado normal de UI local.

Considere:

  • Estados de carregamento.
  • Estados de erro.
  • Cache de dados.
  • Re-busca.
  • Sincronização.
  • Dados obsoletos.
  • Cancelamento de requisição quando apropriado.

Use a solução de busca de dados existente do projeto quando adequada.

Não introduza Redux, Zustand, TanStack Query ou outra biblioteca sem estabelecer que é necessário.

8. Hooks React

Entenda e use corretamente:

  • useState
  • useEffect
  • useContext
  • useRef
  • useMemo
  • useCallback
  • Hooks personalizados.

Siga as Regras dos Hooks:

  • Chame hooks no nível superior de componentes React ou hooks personalizados.
  • Não chame hooks dentro de loops, condicionais ou funções aninhadas.
  • Não chame hooks de funções JavaScript comuns.

Gerenciamento de efeitos

Use useEffect para sincronizar um componente com sistemas externos.

Exemplos:

  • Assinaturas de eventos do navegador.
  • Timers.
  • APIs ou integrações externas.
  • Sistemas não React.

Não use efeitos desnecessariamente para valores que podem ser calculados durante a renderização ou para lidar com interações comuns do usuário.

Quando um efeito cria assinaturas, timers ou outros recursos, forneça a limpeza adequada.

Verifique as dependências com cuidado para evitar closures obsoletas, requisições repetidas e comportamento de renderização não intencional.

9. Roteamento e Navegação

Ao implementar navegação:

  • Inspecione o sistema de roteamento existente.
  • Preserve as convenções de rota existentes.
  • Use proteção de rota apropriada.
  • Lide com rotas desconhecidas.
  • Forneça feedback de navegação significativo.
  • Suporte navegação para trás e para frente do navegador.
  • Evite recarregamentos de página desnecessários em aplicações client-side.

Não presuma que toda aplicação React requer uma biblioteca de roteamento separada. Frameworks podem fornecer seus próprios mecanismos de roteamento.

10. Integração com API

Ao conectar React a serviços de backend:

  1. Inspecione os endpoints de API disponíveis.
  2. Entenda os formatos de requisição e resposta esperados.
  3. Use o cliente de API existente quando disponível.
  4. Mantenha a configuração da API em locais apropriados.
  5. Lide com estados de carregamento.
  6. Lide com falhas de rede.
  7. Valide e lide com respostas inesperadas.
  8. Evite requisições duplicadas.
  9. Evite expor credenciais privadas.
  10. Forneça feedback de erro útil.

Não coloque chaves de API privadas, credenciais de banco de dados ou segredos do servidor em variáveis de ambiente do frontend.

Lembre-se de que variáveis de ambiente do frontend podem ser expostas aos usuários através do bundle da aplicação.

11. Formulários e Validação

Construa formulários previsíveis e acessíveis.

Requisitos:

  • Use tipos de input apropriados.
  • Associe labels aos controles do formulário.
  • Valide campos obrigatórios.
  • Exiba mensagens de validação úteis.
  • Evite envios duplicados acidentais.
  • Forneça feedback de carregamento e sucesso.
  • Lide com erros de validação do servidor.
  • Preserve a entrada do usuário quando apropriado.
  • Use HTML semântico.

A validação client-side melhora a experiência do usuário, mas não substitui a validação do backend.

12. Tratamento de Erros

Lide com erros nos níveis apropriados.

Considere:

  • Erros de renderização de componentes.
  • Falhas de requisição de API.
  • Entrada de usuário inválida.
  • Falhas de autenticação.
  • Falhas de autorização.
  • Dados ausentes.
  • Interrupções de rede.
  • Estados de aplicação inesperados.

Use limites de erro quando apropriado.

Evite ignorar erros silenciosamente.

Não exponha stack traces internos, informações privadas ou detalhes sensíveis do servidor aos usuários.

13. Otimização de Desempenho

Otimize com base em problemas reais de desempenho.

Considere:

  • Re-renderizações desnecessárias.
  • Árvores de componentes grandes.
  • Cálculos caros.
  • Bundles JavaScript grandes.
  • Imagens não otimizadas.
  • Requisições de rede desnecessárias.
  • Renderização de listas ineficiente.
  • Divisão de código.
  • Carregamento preguiçoso.

Use ferramentas de profiling React quando necessário.

Aplique useMemo, useCallback e React.memo apenas quando fornecerem um benefício significativo.

Não introduza memoização em todos os lugares.

Use keys estáveis e significativas ao renderizar listas. Evite índices de array como keys quando os itens da lista puderem ser reordenados, inseridos ou excluídos.

14. Acessibilidade

Toda interface React deve seguir princípios de acessibilidade.

Requisitos:

  • Use HTML semântico.
  • Forneça nomes acessíveis para controles.
  • Suporte navegação por teclado.
  • Mantenha indicadores de foco visíveis.
  • Associe labels de formulário corretamente.
  • Forneça texto alternativo para imagens significativas.
  • Use hierarquia de cabeçalhos apropriada.
  • Evite depender apenas de cor para comunicar informações.
  • Garanta que elementos interativos tenham papéis e comportamento apropriados.

Use atributos ARIA quando necessário, não como substituto para HTML semântico.

15. Segurança

Siga os padrões de segurança do projeto.

Práticas importantes:

  • Não exponha segredos no código frontend.
  • Não confie na autorização client-side.
  • Não armazene credenciais sensíveis de forma insegura.
  • Evite renderização de HTML insegura.
  • Sanitize conteúdo não confiável quando necessário.
  • Valide a entrada do usuário no backend.
  • Use práticas seguras de autenticação e sessão.
  • Evite registrar informações sensíveis do usuário.
  • Inspecione dependências de terceiros.
  • Proteja rotas autenticadas enquanto impõe autorização no servidor.

Nunca presuma que esconder um botão no frontend fornece controle de acesso real.

16. Teste e Depuração

Teste a aplicação após fazer alterações.

Use o framework de teste existente do projeto.

Teste áreas relevantes:

  • Renderização de componentes.
  • Interações do usuário.
  • Validação de formulários.
  • Navegação.
  • Integração com API.
  • Estados de carregamento.
  • Estados de erro.
  • Comportamento de autenticação.
  • Comportamento responsivo.
  • Riscos de regressão.

Use níveis de teste apropriados:

  • Testes unitários.
  • Testes de componentes.
  • Testes de integração.
  • Testes ponta a ponta.

Ao depurar:

  1. Reproduza o erro.
  2. Leia a mensagem de erro completa.
  3. Identifique o componente ou dependência afetados.
  4. Rastreie a causa.
  5. Implemente a menor correção apropriada.
  6. Teste a correção.
  7. Verifique regressões.

Não esconda erros desabilitando verificações importantes ou removendo funcionalidades.

17. Arquitetura do Projeto

Respeite a estrutura de pastas existente.

Uma estrutura possível para uma nova aplicação React é:

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

Esta é uma estrutura de referência, não um modelo obrigatório.

Para aplicações maiores, organize o código em torno de funcionalidades quando isso melhorar a mantenibilidade.

Evite criar pastas e arquivos desnecessários para aplicações pequenas.

18. Fluxo de Trabalho de Desenvolvimento

Siga este fluxo de trabalho para tarefas React.

Fase 1: Entender

  • Leia os requisitos da tarefa.
  • Inspecione o projeto existente.
  • Identifique componentes afetados.
  • Entenda dependências existentes.
  • Identifique riscos potenciais.

Fase 2: Planejar

  • Determine as alterações necessárias.
  • Selecione uma abordagem de implementação apropriada.
  • Identifique arquivos afetados.
  • Considere acessibilidade e segurança.
  • Identifique testes necessários.

Fase 3: Implementar

  • Faça alterações focadas.
  • Reutilize componentes existentes.
  • Siga convenções estabelecidas.
  • Evite modificações não relacionadas.
  • Mantenha a estrutura de código clara.

Fase 4: Validar

  • Execute os testes apropriados.
  • Execute o comando de build do projeto.
  • Verifique linting e erros de tipo onde configurados.
  • Teste interações relevantes do usuário.
  • Revise erros do console do navegador.
  • Verifique se a funcionalidade existente ainda funciona.

Inspecione package.json antes de escolher comandos. Não presuma que scripts existem.

Fase 5: Relatar

Explique:

  • O que foi implementado.
  • Quais arquivos foram alterados.
  • Decisões técnicas importantes.
  • Testes e comandos executados.
  • Quaisquer problemas não resolvidos.
  • Qualquer trabalho adicional necessário.

Nunca afirme que um teste ou build foi bem-sucedido a menos que tenha sido realmente executado e aprovado.

19. Práticas Proibidas

Não:

  • Reescreva toda a aplicação para uma pequena funcionalidade.
  • Instale pacotes desnecessários.
  • Ignore a arquitetura existente.
  • Use padrões React desatualizados sem justificativa.
  • Use efeitos para toda operação.
  • Coloque toda a lógica da aplicação em um componente.
  • Exponha segredos no código frontend.
  • Confie na autorização frontend.
  • Ignore acessibilidade.
  • Desabilite linting ou testes apenas para fazer um build passar.
  • Suprima erros sem entendê-los.
  • Afirme que funcionalidades não verificadas funcionam.
  • Realize migrações importantes sem explicar o impacto.

20. Definição de Concluído

Uma tarefa React está completa quando:

  • A funcionalidade solicitada é implementada.
  • A funcionalidade existente é preservada.
  • Os componentes seguem princípios de design sustentável.
  • O estado e o fluxo de dados são compreensíveis.
  • As interações com a API lidam com falhas adequadamente.
  • Os requisitos de acessibilidade são considerados.
  • Os requisitos de segurança são seguidos.
  • Os testes relevantes passam.
  • O build de produção é bem-sucedido quando aplicável.
  • As limitações conhecidas são documentadas.
  • A implementação é claramente relatada.

21. Habilidades Relacionadas

Quando disponível, combine esta habilidade com:

  • frontend-engineering para arquitetura e engenharia frontend geral.
  • ui-ux-design para experiência do usuário e design de interface.
  • frontend-security para segurança específica do frontend.
  • frontend-testing para práticas de teste frontend.
  • backend-development para integração com backend.
  • api-engineering para design e integração de API.

Use habilidades relacionadas onde relevante sem duplicar suas responsabilidades.

Individual skills in this repo

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

Habilidades Relacionadas