Trilha Revisão de Código: tudo o que estudar, tópico por tópico

Princípios de uma revisão de código eficaz: no que os revisores devem focar, a diferença entre estilo e corretude, e como priorizar o esforço de revisão.

Boas práticas de tamanho de PR, requisitos de descrição, expectativas de tempo de retorno de revisão e como um fluxo de trabalho de PR deficiente compromete a qualidade da revisão.

Como escrever comentários de revisão que sejam específicos, acionáveis e respeitosos. A diferença entre feedback que melhora o código e feedback que gera conflito.

Como calibrar o escopo de uma revisão para a mudança em questão — quando fazer uma revisão completa de arquitetura vs. uma verificação rápida, e como evitar sub-revisão e super-revisão.

O modelo mental de um revisor eficaz: pensar nos futuros mantenedores, verificar intenção vs. implementação e a responsabilidade do revisor no processo de desenvolvimento.

Construir uma cultura saudável de revisão de código: frameworks de feedback construtivo, segurança psicológica e redução de ansiedade na revisão.

Medir a eficácia da revisão de código: tempo de ciclo, cobertura de revisão, métricas de qualidade de feedback e melhoria contínua.

Reconhecer code smells comuns em PRs: métodos longos, código duplicado, feature envy, data clumps, primitive obsession e quando eles importam.

O trade-off entre código engenhoso e compacto e código legível e manutenível. Como ferramentas de IA tendem a soluções super-engenheiradas ou desnecessariamente complexas.

Revisar nomes de variáveis, funções e classes quanto à clareza e precisão. Identificar abstrações fracas, abstrações vazadas e nomenclatura que obscurece a intenção.

Compreender e aplicar complexidade ciclomática em revisão de código. Identificar funções de alta complexidade, lógica profundamente aninhada e quando a complexidade é uma preocupação bloqueante.

Avaliar a cobertura de testes em PRs — identificar testes ausentes, testes que cobrem apenas o caminho feliz, testes que verificam implementação em vez de comportamento, e métricas de cobertura vs. cobertura significativa.

Implementar e ajustar análise estática em escala: seleção de ferramentas, regras customizadas, redução de ruído e integração ao fluxo de trabalho do desenvolvedor.

Identificar vulnerabilidades do OWASP Top 10 durante revisão de código: injeção, autenticação quebrada, XSS, IDOR, configuração incorreta de segurança e mais.

Encontrar lacunas de autenticação e autorização em PRs: verificações de auth ausentes, caminhos de escalação de privilégio, referências diretas inseguras a objetos e padrões de controle de acesso quebrado.

Vulnerabilidades de injeção que ferramentas de IA frequentemente geram: SQL injection via concatenação de strings, injeção de comandos do SO, injeção LDAP e injeção de templates. Por que LLMs frequentemente produzem código vulnerável.

Identificar padrões que vazam dados sensíveis em PRs: PII em logs, dados sensíveis em respostas de erro, transmissão insegura de dados e superexposição de campos sensíveis em respostas de API.

Detectar segredos codificados, chaves de API, senhas e credenciais em PRs. Padrões que ferramentas de IA frequentemente produzem ao gerar código de configuração ou conexão.

Conduzir revisões de código focadas em segurança: identificar vulnerabilidades de injeção, falhas de autenticação e uso incorreto de criptografia.

Identificar violações de princípios SOLID em contextos reais de revisão de código: violações de SRP (God classes), violações de OCP (switch statements massivos), violações de LSP, ISP e DIP.

Identificar alto acoplamento e baixa coesão em PRs: feature envy, intimidade inapropriada, cadeias de mensagens e como código gerado por IA frequentemente apresenta características ruins de acoplamento.

Revisar PRs quanto a violações de contrato de API: breaking changes, modificações incompatíveis com versões anteriores, códigos de status incorretos, formatos de erro inconsistentes e ausência de testes de contrato.

Revisar novas dependências adicionadas em PRs: vulnerabilidades de segurança, conformidade de licença, inchaço de dependências e o que ferramentas de IA tipicamente adicionam ao gerar código que necessita de bibliotecas.

Identificar quando padrões de design são usados incorretamente ou desnecessariamente em PRs. Ferramentas de IA frequentemente aplicam padrões (Factory, Singleton, Strategy) quando não são necessários, aumentando a complexidade sem benefício.

Revisar código no nível arquitetural: avaliar padrões de design, acoplamento, coesão e manutenibilidade a longo prazo.

Identificar padrões de consultas N+1 em PRs: lazy loading em loops, eager loading ausente, oportunidades de batching. Por que código ORM gerado por IA frequentemente produz padrões N+1.

Detectar padrões de vazamento de memória em revisão de código: recursos não fechados, acúmulo de event listeners, referências circulares e cache sem evicção. Padrões comuns em código gerado por IA.

Identificar bloqueio síncrono em código assíncrono durante revisão: chamadas bloqueantes em funções async, await ausente, awaits sequenciais que deveriam ser paralelos e código gerado por IA que bloqueia event loops.

Identificar gargalos de escalabilidade durante revisão de código: paginação ausente, algoritmos ineficientes, contenção de locks no banco de dados e código gerado por IA que funciona para 100 registros mas falha com 10 milhões.

Modos de falha sistemáticos em código gerado por IA: APIs alucinadas, padrões de segurança obsoletos (MD5, DES), abstrações super-engenheiradas, tratamento incorreto de casos extremos e efeitos de corte de dados de treinamento.

Como revisores caem em complacência ao revisar código gerado por IA: viés de automação, heurísticas de 'parece correto', confiança excessiva na precisão da IA e por que código de IA precisa de MAIS escrutínio em alguns aspectos do que código escrito por humanos.

Como estruturar um fluxo de trabalho de revisão para PRs que misturam código gerado por IA e escrito por humanos: o que verificar primeiro, como avaliar seções de IA e como documentar a revisão.

Critérios para rejeitar código gerado por IA completamente em vez de refatorá-lo: quando a IA entendeu fundamentalmente errado o requisito, quando a abordagem é arquiteturalmente incorreta e quando corrigir o código levaria mais tempo do que escrevê-lo corretamente.