Code review em TypeScript: boas práticas, checklist e ferramentas (2026)
TypeScript consegue identificar muitos problemas antes mesmo de uma PR chegar ao code review. Mas nem todo código que compila está correto.
Uma type assertion pode esconder um dado inválido. Um any pode remover garantias importantes. E uma resposta de API pode ser tratada como confiável sem que ninguém tenha validado seu conteúdo.
São problemas que passam pelo compilador e podem acabar chegando à produção.
Este guia passa pelos principais pontos que merecem atenção num code review de TypeScript, com exemplo de código, um checklist pra usar nas PRs, e as ferramentas que ajudam a automatizar parte desse processo.
Para revisões em JavaScript, veja também boas práticas de code review em JavaScript, e pro processo de revisão em si, independente de linguagem, o checklist geral de code review.
Atualizado em 4 de novembro de 2026
O que revisar em uma PR de TypeScript?
Um bom code review de TypeScript precisa verificar se os tipos realmente representam os dados e comportamentos da aplicação, além de identificar problemas que o compilador não consegue detectar sozinho.
Os principais pontos de atenção:
- segurança de tipos (uso de
any,unknowne type assertions) - configuração do projeto (
strict,strictNullCheckse outras opções do compilador) - tratamento de
null,undefinede valores falsy - modelagem de tipos (union types, generics e estados inválidos)
- contratos públicos (funções exportadas, interfaces e tipos compartilhados)
- validação de dados externos (APIs, requests, webhooks e variáveis de ambiente)
- contratos de componentes React e entradas de dados no backend Node.js
- dados usados em teste (fixtures e mocks)
Nem todos esses pontos precisam ser revisados em toda PR. Uma alteração pequena num componente React, por exemplo, exige uma atenção diferente de uma mudança num endpoint de autenticação.
O importante é saber onde estão os riscos de cada alteração e concentrar a revisão neles.
Por que TypeScript precisa de um checklist específico de code review?
TypeScript ajuda a encontrar erro de tipo durante o desenvolvimento, mas suas garantias dependem dos tipos declarados e das configurações do projeto.
Considere este exemplo:
const user = response.data as User;
Para o compilador, user passa a ser tratado como User, mas isso não significa que os dados recebidos da API realmente seguem essa estrutura.
Se a resposta vier sem uma propriedade obrigatória ou com um valor inesperado, o código ainda pode falhar em runtime.
Esse é o tipo de problema que a revisão precisa identificar.
Em vez de verificar apenas se o código está tipado, pergunte:
- O tipo representa os dados reais?
- Existe alguma suposição que não foi validada?
- O código permite estados que não deveriam existir?
- Uma alteração nesse contrato pode afetar outras partes da aplicação?
Essas perguntas ajudam a encontrar problema que uma verificação estática, sozinha, não resolve.
Como revisar a segurança de tipos em TypeScript?
Antes de analisar tipo mais complexo, confira três pontos: a configuração do compilador, o uso de any e o tratamento de dado desconhecido.
A configuração do TypeScript está correta?
O primeiro passo é verificar o tsconfig.json.
A opção strict habilita um conjunto de verificações mais rigorosas, incluindo noImplicitAny e strictNullChecks.
{
"compilerOptions": {
"strict": true
}
}
Sem essas verificações, o compilador pode aceitar situações que deveriam gerar erro, como valor potencialmente nulo sendo usado sem tratamento.
Em projeto com múltiplos pacotes, confira também as configurações herdadas. Um pacote pode sobrescrever opções do tsconfig principal e acabar usando verificações menos rigorosas que o restante do projeto.
Antes de pedir revisão, rode as checagens automatizadas disponíveis:
tsc --noEmit
eslint .
prettier --check .
O comando depende da configuração de cada repositório. O ideal é essas verificações já fazerem parte do CI, pra o revisor não gastar tempo apontando problema que o compilador, o linter ou o formatador já identificam sozinhos.
Quando o uso de any é um problema?
any permite trabalhar com um valor sem as verificações de tipo que o TypeScript normalmente aplicaria.
Isso pode ser útil em situação específica, como integração com biblioteca que não oferece tipagem adequada ou migração gradual de JavaScript pra TypeScript.
O problema aparece quando any é usado só pra contornar um erro do compilador.
function getUserEmail(user: any) {
return user.profile.email;
}
O TypeScript não consegue verificar se profile existe ou se email está disponível. Se o valor recebido não tiver essa estrutura, a aplicação pode falhar em runtime.
Durante o code review, confira se:
- existe uma razão concreta pra usar
any - o uso está isolado e não se propaga pra outras partes do código
- um tipo mais específico poderia representar o valor
unknownseria uma alternativa mais segura
Não é preciso proibir any em toda situação. A preocupação é evitar que o uso elimine garantia importante sem justificativa.
Quando usar unknown em vez de any?
unknown é uma alternativa mais segura quando o formato de um valor ainda não é conhecido.
Isso acontece com frequência ao receber dado de API, webhook, arquivo e outras fontes externas.
Diferente de any, unknown exige que o código verifique o valor antes de usá-lo.
type User = { id: string; email: string; };function isUser(value: unknown): value is User {
return (
typeof value === "object" &&
value !== null &&
"id" in value &&
typeof value.id === "string" &&
"email" in value &&
typeof value.email === "string"
);
}
Agora dá pra verificar a estrutura antes de acessar as propriedades:
const data: unknown = response.data;if (!isUser(data)) {
throw new Error("Invalid user data");
}console.log(data.email);
A verificação confirma que as propriedades esperadas existem e têm os tipos necessários.
Durante a revisão, procure ponto em que dado externo é usado direto como tipo interno, sem validação nenhuma. É um dos lugares em que uma aplicação TypeScript pode parecer segura pro compilador e continuar vulnerável a dado inesperado.
Como revisar se um tipo pode ser confiado em TypeScript?
Depois da base, o problema muda de figura: o código já tem tipo, a pergunta é se aquele tipo pode ser garantido no ponto em que é usado. Três padrões respondem isso: assertion, valor nulo e union type.
Uma type assertion está escondendo uma incompatibilidade?
Type assertions, como as User, dizem ao compilador qual tipo deve ser considerado pra um valor. Elas não fazem nenhuma validação em runtime.
const user = response.data as User;
Se response.data não seguir o contrato esperado, a assertion não impede o problema.
Isso não significa que toda type assertion deve ser removida. Existe situação em que o código tem informação que o compilador não consegue inferir. O importante é verificar se aquela assertion representa uma garantia real ou só está escondendo uma incompatibilidade.
Quando o valor vem de uma fonte externa, prefira um schema de validação, como Zod:
const user = UserSchema.parse(response.data);
Assim o formato é verificado em runtime antes de o valor ser tratado como User. Um type guard equivalente também funciona, dependendo da complexidade do dado.
Quando o objetivo é verificar se um objeto definido no próprio código atende a um contrato, sem que o dado venha de fora, satisfies costuma ser mais adequado que as:
const config = {
retries: 3,
backoffMs: 500,
} satisfies RetryConfig;
Diferente de uma type assertion, satisfies verifica se o objeto é compatível com o tipo informado e preserva a inferência do tipo da expressão, em vez de simplesmente instruir o compilador a aceitar aquele tipo. Durante a revisão, confira se as é realmente necessário ou se dá pra manter a verificação de tipos com satisfies.
null e undefined são tratados de forma consistente?
Mesmo com strictNullChecks habilitado, o código precisa representar corretamente situação em que um valor pode não existir.
type User = {
id: string;
profile?: {
name: string;
};
};
Aqui, profile pode estar ausente. O código que acessa essa propriedade precisa considerar essa possibilidade.
Optional chaining ajuda nesse acesso:
return user.profile?.name;
Se profile não existir, a expressão retorna undefined em vez de tentar acessar name num valor ausente.
Pra valor padrão, ?? costuma ser mais adequado quando o fallback deve acontecer só pra null ou undefined:
const displayName = user.profile?.name ?? "Anonymous";
Preste atenção também ao uso de ||:
const retries = config.retries || 3;
Se config.retries for 0, o código usa 3, mesmo que zero seja um valor válido pra essa configuração. Com ??, o comportamento muda:
const retries = config.retries ?? 3;
Agora o fallback só se aplica quando retries for null ou undefined.
Durante o code review, confira se o código distingue valor ausente de valor válido como 0, false e string vazia.
Switch ou if-chain sobre union type é exaustivo?
Union types representam valor ou estado específico de forma explícita:
type ReviewStatus = "pending" | "approved" | "rejected";
O problema aparece quando o código usa esses estados sem considerar todas as possibilidades:
function describeStatus(status: ReviewStatus) {
switch (status) {
case "pending":
return "Aguardando revisão";
case "approved":
return "Aprovado";
}
}
A função não trata "rejected". Se receber esse valor, retorna undefined, e dependendo da configuração do projeto e de como o retorno é usado, isso passa sem erro de compilação.
Uma verificação exaustiva com never resolve isso:
function describeStatus(status: ReviewStatus): string {
switch (status) {
case "pending":
return "Aguardando revisão";
case "approved":
return "Aprovado";
case "rejected":
return "Rejeitado";
default: {
const _exhaustive: never = status;
return _exhaustive;
}
}
}
Agora, se alguém adicionar um novo valor à union sem atualizar o switch, o TypeScript sinaliza a incompatibilidade. O padrão é especialmente útil pra status de processo, papel e permissão de usuário, estado de componente, tipo de evento, e plano de assinatura.
Durante a revisão, procure condição que depende de union e confira se todos os estados são tratados. Em muitos casos, isso evita que uma alteração aparentemente pequena introduza comportamento inesperado em outra parte da aplicação.
Como revisar contratos em TypeScript?
Tipo correto não é a mesma coisa que contrato claro. Uma função pode estar corretamente tipada e ainda oferecer um contrato confuso ou permitir uso inválido.
A API tem um contrato claro?
Ao revisar função exportada, hook, componente ou pacote compartilhado, olhe a assinatura primeiro:
export function buildReviewSummary(
pullRequest: PullRequest,
comments: ReviewComment[]
): ReviewSummary {
// ...
}
Os parâmetros e o retorno deixam claro o que a função espera e o que entrega. Tipo de retorno explícito ajuda bastante em API pública e função compartilhada, porque mantém o contrato estável mesmo quando a implementação muda.
Durante a revisão, considere:
- A assinatura deixa claro como a função deve ser usada?
- Os parâmetros representam informação realmente necessária?
- Existe combinação de argumento que deveria ser inválida?
- O retorno comunica os estados possíveis?
- Uma mudança interna pode alterar o contrato usado por outro módulo?
Observe também o nome dos tipos. Tipo genérico como Data, Info, Item e Payload dificulta a compreensão quando usado em várias partes do projeto; prefira um nome que represente o domínio da aplicação.
O objetivo não é adicionar complexidade à tipagem. É tornar o contrato mais fácil de entender e mais difícil de usar errado.
As props do React modelam os estados reais do componente?
Em componente React, a tipagem precisa representar corretamente as props e os estados permitidos.
Um problema comum aparece quando várias props booleanas controlam comportamento relacionado:
<Button isPrimary isDestructive isIconOnly />
Dependendo da implementação, essa combinação pode não fazer sentido. Se as opções forem mutuamente exclusivas, uma union representa melhor o contrato:
type ButtonVariant = "primary" | "destructive" | "icon";type ButtonProps = {
variant: ButtonVariant;
children?: React.ReactNode;
};
Assim o componente recebe uma variante definida, em vez de permitir qualquer combinação de flags.
Durante o code review de componente React, confira também:
- prop opcional que deveria ser obrigatória
- callback tipado genericamente como
Function - event handler usando
any - estado nullable que não está representado corretamente
- hook que retorna estrutura difícil de entender
A pergunta principal é se a tipagem ajuda a impedir uso inválido do componente ou só descreve qualquer combinação possível.
Esta seção fica deliberadamente restrita a modelagem de tipo. Dependência de useEffect, regra de hooks e renderização desnecessária são problema de comportamento, não de contrato de tipo, e continuam importantes num code review completo, mas merecem um artigo próprio em vez de uma seção espremida aqui.
Como revisar TypeScript nas bordas do sistema?
TypeScript não valida automaticamente o dado recebido durante a execução da aplicação. Mesmo num projeto com tipagem rigorosa, request, webhook, variável de ambiente e erro lançado continuam sendo dado de runtime, e os dois pontos abaixo são o mesmo problema em lugares diferentes.
O tratamento de erro preserva o problema original?
Em JavaScript, qualquer valor pode ser lançado como erro, não só instância de Error. Por isso o código não deve assumir automaticamente que uma variável recebida num catch tem propriedade como message ou stack.
try {
await runImport();
} catch (err: unknown) {
if (err instanceof Error) {
console.error(err.message);
} else {
console.error("Unknown import failure", err);
}
}
Aqui o código verifica o tipo antes de acessar message. Isso importa principalmente em aplicação que usa ferramenta de observabilidade, log estruturado ou mensagem de erro apresentada ao usuário.
Durante a revisão, confira se:
- o erro é tratado como valor desconhecido quando necessário
- o tratamento preserva informação útil pra investigação
- uma falha durante o próprio tratamento pode esconder o problema original
- informação sensível não é exposta em log ou resposta pública
A ideia é garantir que o tratamento de erro ajude a diagnosticar o problema, em vez de introduzir uma falha nova.
Código Node.js trata request, webhook e variável de ambiente como dado externo?
O código interno pode estar bem tipado, mas request, webhook, fila, variável de ambiente e resposta de serviço externo continuam sendo dado de runtime.
const input = req.body as CreateUserInput;
A assertion faz o compilador tratar o body como CreateUserInput, mas não verifica o dado recebido. Se uma propriedade obrigatória estiver ausente, o restante da aplicação pode usar um valor inválido.
const input = CreateUserSchema.parse(req.body);
A mesma preocupação vale pra query e route params, headers, webhook, mensagem de fila, resposta de serviço externo e dado carregado de arquivo. Confira se existe validação apropriada e se ela acontece antes de o dado ser usado pela lógica da aplicação.
Variável de ambiente também é dado externo. Em Node.js, process.env pode retornar undefined quando uma configuração não existe, e isso pode causar problema mais grave do que uma falha de inicialização: imagine uma verificação de autenticação que depende de uma variável obrigatória. Se o código não confirmar que ela existe antes de usá-la, uma configuração incorreta compromete o comportamento esperado da própria verificação.
Valide a configuração obrigatória durante a inicialização da aplicação. Assim um ambiente mal configurado falha de forma explícita, em vez de continuar executando com valor inesperado, exatamente o tipo de falha que devia aparecer num processo de identificação de vulnerabilidade de segurança no código. Mais adiante neste guia tem um caso real desse problema, numa PR do cal.com identificada durante um benchmark de ferramentas de code review com IA.
Como revisar generics e teste em TypeScript?
As duas últimas armadilhas ficam fora do caminho feliz: um generic que promete mais do que o runtime garante, e um teste que finge validar um contrato que na prática ignora.
Um generic promete mais do que o runtime garante?
Generics são úteis quando existe uma abstração que realmente precisa funcionar com tipos diferentes, mas também podem criar uma falsa sensação de segurança quando prometem algo que não é garantido em runtime.
async function fetchData<T>(url: string): Promise<T> {
const response = await fetch(url);
return response.json() as Promise<T>;
}
Quem chama a função escolhe qualquer tipo pra T:
const user = await fetchData<User>("/api/user");
Nada confirma que a resposta realmente segue a estrutura de User. Uma alternativa é receber uma função responsável pela validação:
async function fetchData<T>( url: string, parse: (value: unknown) => T ): Promise<T> { const response = await fetch(url); const data: unknown = await response.json();return parse(data);
}
Agora a função exige que o dado recebido passe por validação ou conversão antes de ser retornado como T.
Durante a revisão, observe também o nível de complexidade das abstrações. Nem toda função precisa de generic: se uma abstração exige vários parâmetros de tipo, condicional e assertion pra resolver um problema simples, talvez exista uma alternativa mais fácil de manter. Generic deve facilitar reaproveitamento de código sem tornar o contrato mais difícil de entender.
O teste usa dado que bate com o tipo real?
O teste também pode esconder problema de tipagem, principalmente quando fixture e mock são criados com type assertion.
const user = {
id: "1"
} as User;
Se User exige outras propriedades, essa assertion permite criar uma fixture incompleta sem o compilador apontar o problema. Isso faz o teste usar dado diferente do que a aplicação realmente espera.
Uma factory resolve isso:
function createUser(overrides: Partial<User> = {}): User {
return {
id: "user-1",
email: "user@example.com",
name: "Test User",
...overrides
};
}
Com uma factory, o teste altera só o campo relevante, mantendo uma estrutura válida por padrão.
Durante o code review, confira se:
- a fixture respeita o contrato real
- assertion está sendo usada pra esconder propriedade ausente
- mock representa comportamento possível da dependência
- entrada inválida é testada quando o código recebe dado externo
- tipo complexo precisa de teste específico de tipagem
Teste de runtime e verificação de tipo resolvem problemas diferentes: um teste confirma o comportamento de uma função, uma verificação de tipos garante que determinada combinação de argumento não seja aceita. As boas práticas pra escrever teste unitário detalham esse primeiro ponto, testar comportamento observável em vez de detalhe de implementação.
Checklist completo de code review para TypeScript
Use este checklist como referência durante a revisão. Nem todo item é relevante pra toda PR, então priorize os que estão relacionados ao código alterado.
Segurança de tipos
- O uso de
anytem justificativa? - Valor desconhecido é tratado como
unknownquando apropriado? - O
strictestá habilitado notsconfig? - Type assertion está escondendo incompatibilidade?
satisfiespoderia ser usado no lugar de uma assertion?- Dado externo é validado antes de receber um tipo interno?
- Union type é tratada de forma exaustiva?
- Valor nullable é tratado corretamente?
??seria mais adequado que||?- Os tipos impedem estado inválido?
API e contrato
- A função pública tem assinatura clara?
- O nome do tipo representa o domínio da aplicação?
- O contrato compartilhado é consistente?
- Mudança interna pode quebrar contrato usado por outro módulo?
- A API permite combinação inválida de parâmetro?
- Os tipos representam o comportamento real da aplicação?
React
- As props estão tipadas corretamente?
- Prop opcional é realmente opcional?
- Event handler tem tipo específico?
- Estado nullable está representado corretamente?
- Hook retorna estrutura compreensível?
- As props impedem combinação inválida?
Node.js e backend
- O corpo da request é validado?
- Route params e query params são convertidos e validados?
- Variável de ambiente obrigatória é verificada na inicialização?
- Webhook e mensagem de fila são tratados como dado externo?
- O tipo usado pro dado do banco corresponde ao schema real?
- Erro é verificado antes de acessar propriedade específica?
Teste
- Fixture segue o tipo real?
- Assertion esconde dado incompleto?
- Entrada inválida é coberta por teste?
- Mock representa contrato próximo do real?
- Tipo complexo precisa de teste específico?
Quais são as melhores ferramentas de code review para TypeScript?
Parte das verificações deste checklist pode ser automatizada com TypeScript, ESLint e ferramenta de análise estática. Essas ferramentas são importantes pra achar problema conhecido, como incompatibilidade de tipo, padrão de código proibido e algumas classes de vulnerabilidade.
Mas ainda existe um problema que depende bastante de contexto, que é entender se uma alteração quebra uma regra de negócio, introduz uma regressão ou cria uma vulnerabilidade que uma regra estática sozinha não identifica. É nesse cenário que ferramenta de code review com IA complementa a verificação tradicional; o comparativo entre code review manual e automatizado detalha onde fica a fronteira entre as duas.
Rodamos um benchmark comparando ferramentas de code review com IA. O objetivo era simples: pegar PR real de projeto open source grande, com bug já documentado e confirmado pelos mantenedores, e rodar a mesma PR em quatro ferramentas, sob a mesma configuração padrão, sem dica nem regra customizada pra nenhuma delas. Comparamos Kodus, CodeRabbit, GitHub Copilot e Cursor Bugbot em 38 PRs de cinco repositórios open source, incluindo o cal.com, que é TypeScript, e o resultado foi claro: Kodus identificou 30 dos 38 bugs conhecidos (79%), seguida por Cursor Bugbot (58%), GitHub Copilot (53%) e CodeRabbit (39%).
Na hora de escolher uma ferramenta pra um projeto TypeScript, considere quatro critérios:
| Critério | O que avaliar |
|---|---|
| Regra personalizada | A ferramenta aplica o padrão e a convenção específicos do time? |
| Revisor especializado | Dá pra configurar análise dedicada a segurança, arquitetura ou teste? |
| Contexto do repositório | A ferramenta considera informação além do diff e reaproveita contexto relevante? |
| Modelo e infraestrutura | Existe suporte a BYOK, modelo diferente ou self-hosted? |
Comparação das ferramentas
| Ferramenta | Melhor para | Principais diferenciais |
|---|---|---|
| Kodus | Time que precisa de regra personalizada, contexto persistente e controle sobre modelo | Kody Rules, Kody Memories, Custom Agents, BYOK e self-hosted |
| CodeRabbit | Time que quer combinar revisão de PR, triagem e ferramenta de segurança | Integração com linter, SAST, regra personalizada e triagem de PR |
| Cursor Bugbot | Time que já usa Cursor no desenvolvimento | Integração com o ecossistema Cursor, regra específica e autofix |
| GitHub Copilot | Time que já usa GitHub Copilot | Revisão integrada ao GitHub e reaproveitamento de instrução do repositório |
1. Kodus
Kodus é uma plataforma open source de code review com IA, usada em nuvem ou em ambiente self-hosted. Deixa configurar regra de revisão, manter contexto sobre o repositório e escolher o modelo usado, por meio de BYOK.
Principais recursos
- Kody Rules: regra personalizada em linguagem natural, aplicável a arquivo específico ou à PR inteira.
- Kody Memories: contexto persistente sobre convenção e decisão do projeto, com fluxo de aprovação pra memória gerada por IA.
- Custom Agents: dá pra criar um agente focado numa preocupação específica, como segurança, arquitetura ou cobertura de teste, com as próprias instruções e ferramentas. Ele roda ao lado do Kody na mesma PR e comenta só sobre o que foi configurado pra olhar.
- BYOK: conexão com provider diferente (OpenAI, Anthropic, Google, Vertex AI, endpoint compatível com OpenAI) e escolha do modelo usado em cada revisão.
- Self-hosted: dá pra rodar a própria instância da Kodus na infraestrutura do time, com os mesmos recursos de regra, memória e BYOK.
Esses recursos são úteis em projeto TypeScript com regra específica de arquitetura, validação de dado ou organização de contrato. Um time pode criar uma regra exigindo que todo endpoint novo valide o dado de entrada antes de usá-lo, ou configurar um agente dedicado a revisar mudança relacionada à segurança, sem depender só da análise geral da PR.
Um exemplo real: falha de autenticação num webhook TypeScript
Na PR #11 do repositório usado no experimento, rodada contra um fork do cal.com, uma alteração adiciona um endpoint de webhook protegido por um segredo configurado numa variável de ambiente:
if (
req.headers[process.env.CALCOM_WEBHOOK_HEADER_NAME || "calcom-webhook-secret"] !==
process.env.CALCOM_WEBHOOK_SECRET
) {
return res.status(403).json({ message: "Invalid webhook secret" });
}
O problema está no uso direto de process.env.CALCOM_WEBHOOK_SECRET. Se essa variável não estiver configurada, a comparação vira undefined !== undefined, que é false: o if nunca bloqueia nada, e qualquer um sem segredo nenhum consegue criar ou atualizar credencial de qualquer usuário no sistema.
No benchmark, a Kodus identificou esse problema e classificou como crítico. As outras três ferramentas testadas não sinalizaram a falha nesse cenário.
Esse exemplo mostra por que um code review de TypeScript precisa considerar o comportamento do código, não só sua tipagem. A variável estava sendo usada de um jeito válido pro compilador, mas o problema de verdade era outro: uma configuração ausente podia comprometer uma verificação de segurança, exatamente o que a seção sobre Node.js deste guia descreve.
2. CodeRabbit
CodeRabbit combina code review com IA, triagem de PR e integração com ferramenta de análise estática e segurança. É uma opção pra time que quer concentrar verificações diferentes numa mesma ferramenta.
Principais recursos
- Configuração de regra via
.coderabbit.yaml, compath_instructions, custom checks e instrução porast-grep. - Cerca de 60 linter e ferramenta de SAST integrados, incluindo Semgrep, Trivy e TruffleHog.
- Security agent, issue planner, além de agente de Slack e Discord.
- Bring your own model, mas só no self-hosted Enterprise.
Em projeto TypeScript, a integração com linter e ferramenta de segurança pode complementar a revisão gerada por IA.
Consideração: self-hosted e modelo próprio ficam só no Enterprise, com mínimo de 500 assentos documentado; os planos cloud não dão escolha de modelo.
3. Cursor Bugbot
Cursor Bugbot é a ferramenta de revisão de PR do Cursor, pensada pra time que já desenvolve com o editor e os agentes da empresa.
Principais recursos
- Regra de revisão via arquivo
BUGBOT.md, por diretório. - Regra aprendida automaticamente a partir da atividade do time no GitHub, ou manual via
@cursor remember. - Suporte a ferramenta MCP numa revisão, em Team e Enterprise.
- Integração com o recurso de autofix do Cursor.
Pra time que já usa o Cursor como ambiente principal, essa integração simplifica o workflow.
Consideração: não é self-hosted, roda como serviço do Cursor mesmo conectado a um Git server próprio, e a documentação não menciona escolha de modelo pra revisão em si.
4. GitHub Copilot
O GitHub Copilot também tem revisão de código com IA integrada ao GitHub, usando instrução mantida no próprio repositório.
Principais recursos
- Code review integrado às PRs do GitHub.
- Suporte a
.github/copilot-instructions.mde instrução específica por path em.github/instructions/. - Reaproveitamento do mesmo arquivo de instrução que o agente de código já segue.
Pra time que já paga Copilot, a vantagem é somar revisão com IA ao workflow que já existe.
Consideração: BYOK está em preview pro Copilot Chat, CLI, IDE e o app desktop, mas a documentação não menciona esse recurso pro code review de PR especificamente, nem um sistema de agente dedicado pra esse caso.
Qual ferramenta escolher pro seu time?
| Necessidade | Ferramenta a considerar |
|---|---|
| Regra personalizada, contexto persistente, BYOK e self-hosted | Kodus |
| Revisão integrada com triagem de PR e ferramenta de segurança | CodeRabbit |
| Revisão conectada ao ambiente de desenvolvimento Cursor | Cursor Bugbot |
| Revisão integrada ao GitHub Copilot que o time já usa | GitHub Copilot |
A escolha depende de como o time já desenvolve e revisa código. Em projeto TypeScript, teste a ferramenta com PR que represente problema real do repositório: uma ferramenta pode ser boa pra achar erro comum e ainda não reconhecer regra específica do domínio da aplicação. Além de comparar funcionalidade, observe a qualidade da sugestão, a quantidade de comentário irrelevante, e a capacidade de identificar o que realmente precisa ser corrigido antes do merge.
Perguntas frequentes sobre code review em TypeScript
O que é um code review checklist de TypeScript?
É uma lista de pontos que o revisor confere além do que o compilador já garante: se o any tem motivo, se dado externo é validado antes de virar tipo interno, se union type é tratada de forma exaustiva, e se o contrato de função, componente ou endpoint continua claro pra quem usa depois. O objetivo é pegar o problema que passa pelo tsc sem erro e ainda assim quebra em produção.
Quais são as boas práticas de code review em TypeScript?
Comece pelo tsconfig: sem strict habilitado no projeto inteiro, o resto da checklist vale menos. Depois, questione todo any e toda type assertion sem justificativa, valide dado externo antes de tratá-lo como tipo interno, e confira se union type e tratamento de erro cobrem todos os casos, não só o caminho feliz.
Como automatizar o code review de TypeScript?
tsc --noEmit, ESLint e Prettier no CI resolvem a parte mecânica: erro de tipo, formatação e padrão de código proibido, sem depender de um revisor humano pra isso. O que fica de fora é o que depende de contexto, como saber se uma mudança quebra uma regra de negócio ou introduz uma regressão. É aí que ferramenta de code review com IA, com regra e memória configuráveis pro repositório, complementa a automação tradicional.
Quais são as melhores ferramentas de code review para TypeScript?
Depende do que o time já usa. Pra quem precisa de regra própria, contexto persistente e controle sobre o modelo, Kodus é a opção mais direta, incluindo self-hosted. Pra quem já centraliza o workflow em Cursor ou já paga GitHub Copilot, a revisão integrada nessas ferramentas evita adicionar mais um produto; pra fila grande de PR com necessidade de triagem e scanner de segurança junto, CodeRabbit cobre mais frentes numa ferramenta só.
Qual a diferença entre any e unknown no TypeScript?
any desliga a checagem de tipo pro valor: qualquer propriedade pode ser acessada sem o compilador reclamar. unknown mantém a checagem ligada e obriga o código a validar ou estreitar o valor antes de usá-lo, o que faz dele a escolha mais segura pra dado que ainda não teve o formato confirmado.
Quando usar satisfies em vez de as?
Use satisfies quando o objeto já é definido no próprio código e só precisa ser checado contra um tipo, sem perder a inferência mais específica de cada campo. as não valida nada, só diz ao compilador qual tipo assumir; satisfies continua reportando erro se o objeto não bater com o tipo.
O que é exhaustiveness checking em TypeScript?
É a verificação de que todo caso de uma union type foi tratado, geralmente feita com um default que atribui o valor restante a never. Se alguém adicionar um novo valor à union depois e esquecer de tratar esse caso, o build quebra em vez de o código retornar undefined silenciosamente em produção.
A Kodus é boa pra revisar código TypeScript?
Kody Rules permite travar padrão específico do repositório em linguagem natural, e BYOK deixa escolher o provider e o modelo usados na revisão. Num benchmark comparando Kodus, CodeRabbit, GitHub Copilot e Cursor Bugbot em 38 PRs reais de projetos open source, incluindo um em TypeScript, a Kodus identificou 79% dos bugs conhecidos, à frente das outras três ferramentas testadas.
Como melhorar o code review de TypeScript no dia a dia?
Um bom code review de TypeScript não se limita a achar erro que o compilador já identifica. O objetivo é verificar se o código continua correto quando recebe dado inesperado, passa por mudança de contrato ou interage com outra parte da aplicação.
Isso significa prestar atenção em:
- Os tipos representam o dado real?
- Existe assertion escondendo informação ainda não validada?
- O contrato permite estado inválido?
- Entrada externa é verificada antes de ser usada?
- Uma alteração pode introduzir regressão em outra parte do sistema?
Compilador, linter, teste e ferramenta de revisão com IA ajudam em etapas diferentes desse processo, cada um com seu limite, e a combinação entre eles tende a oferecer cobertura mais completa.
O checklist deste guia serve de ponto de partida pra revisão manual ou pra definir regra automatizada no repositório, do mesmo jeito que o guia geral de como fazer code review serve de base pra qualquer linguagem.
No fim, não basta um código passar no tsc. Os tipos precisam representar o comportamento real da aplicação, inclusive quando ela recebe dado que não estava previsto durante o desenvolvimento.