Projeto legado grande: faz sentido usar o Jev para entender e o Claude Code para alterar?

Em código legado que você nunca viu, o erro mais caro é editar antes de entender

Fala aí, beleza? Se você caiu de paraquedas num projeto gigante, com arquivo de 3 mil linhas e ninguém mais na empresa que saiba por que aquele if existe, este post é pra você 🙂

Dá sim pra separar a fase de leitura e mapeamento da fase de edição, e isso deixa o trabalho MUITO mais seguro

Porém o Jev não faz o papel que muita gente imagina: ele não lê o projeto e não resume nada

Ele responde perguntas estreitas e tipadas, tipo "isso aqui toca pagamento? sim ou não"

Então bora ver onde cada ferramenta entra, e o que passa de uma fase pra outra

O que é o Jev e por que ele não substitui a leitura do código

O Jev é um modelo da TypeSafe AI da classe System One, lançado em 15 de setembro de 2026

Que System One? É a ideia de decisão rápida: você manda um estado (texto ou JSON) junto com perguntas tipadas, e ele devolve respostas tipadas com probabilidade ou confiança, tudo em uma única passada paralela

Ou seja, ele não gera texto, ele decide

Se liga nos limites documentados do Jev 1.13:

• Não gera texto, resumo, documentação nem código
• Não faz contagem
• Não faz cálculo de datas
• Orçamento de 64K por requisição, sendo 32K para o estado

O preço público é US$ 0,042 por milhão de tokens de entrada, e os tokens de saída não são cobrados

A latência informada pela própria TypeSafe fica em torno de 70 a 500 ms por chamada

Barato e rápido, né? 😀

Mas é justamente por isso que o papel dele é roteamento, scoring e guardrails (limites), não leitura de arquivo

Pensa assim: o Jev é o porteiro que responde "pode passar" ou "não pode", e quem senta pra ler o processo inteiro é o Claude Code

O entendimento real do legado vem de quem lê o arquivo, e esse alguém não é o Jev

O que você precisa antes de começar

O kit é curto:

• Claude Code instalado e rodando na pasta do projeto legado
• Conta na TypeSafe: hoje não tem mais lista de espera, o cadastro é aberto no console da TypeSafe e vem com US$ 5 de crédito grátis, e é por lá que você pega a chave de API
• Opcional, plugin comunitário: se quiser usar o BorisLeMeec/jev, vai precisar de Go 1.22+ e da chave TypeSafe

Tome cuidado com um detalhe: esse plugin é da comunidade, NÃO é oficial da TypeSafe

Se ainda nem configurou nada, tem um primeiro passo a passo do Jev aqui no blog pra tarefa inicial

Passo a passo: separar a fase de leitura da fase de edição em um projeto legado

A lógica geral é essa: primeiro ninguém edita nada, só lê e mapeia

Depois sai um plano, você aprova, e aí sim começa a mexer no código

A separação vem do próprio Claude Code, o Jev entra como apoio de triagem 😉

Passo 1: comece o Claude Code em plan mode

No plan mode o Claude pesquisa e propõe mudanças sem editar o código-fonte: lê arquivos, roda comandos de exploração e escreve um plano

As edições ficam bloqueadas até você aprovar, e a própria documentação indica esse modo como o melhor pra explorar um codebase antes de alterar

Tem três jeitos de entrar:

claude --permission-mode plan

• Prefixar o prompt com /plan
• Apertar Shift+Tab, que cicla entre default, acceptEdits e plan

Erro comum deste passo: abrir no modo default e deixar edição acontecer cedo demais, antes de você ter ideia do que o arquivo faz

Já vi muita refatoração "rapidinha" virar uma tarde inteira de git checkout por causa disso

Passo 2: mapeie o projeto com o subagente Explore

O Claude Code tem subagentes nativos (Explore, Plan e general-purpose), e o Explore é somente leitura: Write e Edit são negados pra ele

Ele foi feito pra descoberta de arquivos e busca de código, e a grande vantagem é não encher a conversa principal com resultado de busca e conteúdo de arquivo

Um pedido nessa linha funciona bem:

Use o subagente Explore para mapear onde o fluxo de checkout é tratado:
quais arquivos, quais funções de entrada e quais módulos externos são chamados.
Convenções deste projeto: services ficam em app/Services, nada de lógica em controller.
Não proponha mudanças ainda, só o mapa.

Erro comum deste passo: esquecer que o Explore e o Plan ignoram o CLAUDE.md e o git status da sessão pai (isso é proposital, pra pesquisa ficar rápida e barata)

Então as convenções do legado precisam ir EXPLÍCITAS no pedido, como no exemplo acima

Se o problema é um legado que ninguém mais entende, também vale dar uma olhada no Graphify em projeto legado, que é outra abordagem pro mesmo drama

Passo 3 (opcional): use o plugin BorisLeMeec/jev nas leituras grandes

O plugin usa o Jev pra responder perguntas sobre o codebase sem carregar os arquivos no contexto do agente

Mas ele não intercepta tudo: só buscas e leituras grandes

Arquivos com menos de 400 linhas, edições (Update) e comandos Bash passam direto pro Claude Code

Erro comum deste passo: achar que o plugin vai "resumir" o projeto pra você

Não vai, porque o Jev não gera resumo, ele responde pergunta

Passo 4: faça perguntas de triagem ao Jev pela API

A API do Jev tem um único endpoint:

POST https://api.typesafe.ai/v1/systemone

Ele recebe o estado, o alias do modelo (por exemplo jev-latest) e um mapa de perguntas nomeadas

Tem SDK oficial em Python (typesafe-sdk) e em JavaScript, se preferir não montar a requisição na mão

Pensa num estado tipo o trecho de app/Services/CheckoutService.php com as funções finalizarPedido() e aplicarCupom(), e num mapa de perguntas nessa linha:

• toca_pagamento: este trecho altera dados de pagamento? sim ou não
• acessa_banco_direto: este trecho faz query direto no banco? sim ou não
• area: a qual área este trecho pertence, checkout, estoque ou usuário?

Repara que cada pergunta é estreita: sim ou não, ou escolher uma categoria

É aí que o Jev brilha, rápido e barato

Erro comum deste passo: mandar o repositório inteiro como estado e estourar os 32K, ou pedir coisa que ele não faz, tipo "quantas vezes essa função é chamada?" (contagem) ou "explica esse módulo" (geração de texto)

Passo 5: feche o plano antes de editar

Ainda em plan mode, peça pro Claude Code juntar o mapa do Explore e as respostas de triagem num plano escrito

As edições continuam bloqueadas até você aprovar

Erro comum deste passo: aprovar um plano que cita arquivos que ninguém leu de fato

Se o plano fala de PaymentGateway.php e esse arquivo nunca apareceu numa leitura, para tudo e manda ler antes

Passo 6: edite em acceptEdits, revisando

Com o plano aprovado, troca pro acceptEdits (ele faz parte do mesmo ciclo do Shift+Tab)

A documentação indica esse modo pra iterar em código que você está revisando, que é exatamente o cenário aqui

Erro comum deste passo: confiar numa resposta de triagem no lugar de ler o trecho que vai ser alterado

O Jev disse "não toca pagamento" com confiança alta? Massa, mas o trecho editado precisa ser lido mesmo assim

Passo 7: use o Jev para triar o diff

Esse é o uso mais natural dele ao lado de um agente de código: o Claude Code faz o trabalho deliberado (planejar, implementar, investigar, corrigir) e o Jev responde perguntas estreitas, como o que merece revisão humana num diff

Na prática, você manda o trecho do diff como estado e pergunta coisas tipo "esta mudança merece revisão humana? sim ou não"

Erro comum deste passo: tratar a confiança da resposta como garantia

Confiança é probabilidade, não prova 🙂

O que passar da fase de leitura para a de edição, e o que ler direto do arquivo

Aqui tá o coração da coisa: o que pode virar resumo e o que não pode de jeito nenhum

O que pode ir como resumo:

• O plano escrito pelo Claude Code, já aprovado por você
• A lista de arquivos e módulos envolvidos, que saiu do mapeamento do Explore
• As respostas de triagem do Jev: sim ou não, categoria e confiança

Se liga: esse resumo é produzido pelo Claude Code, não pelo Jev

O Jev só contribui com respostas curtinhas e tipadas, que entram no resumo como dado

O que precisa ser lido direto do arquivo:

• O trecho exato que vai ser editado, sempre
• As assinaturas e os contratos chamados por ele: parâmetros, retornos, exceções
• As convenções do projeto, ou seja, o CLAUDE.md (lembra que o Explore não carrega ele)
• Tudo que envolve contagem ou datas, porque fica fora do que o Jev faz

Pra visualizar melhor:

Informação	Pode ir como resumo?	De onde vem
Plano de mudança	Sim	Claude Code em plan mode
Arquivos e módulos envolvidos	Sim	Subagente Explore
"Toca pagamento? sim ou não"	Sim	Jev
Trecho que vai ser editado	Não	Leitura direta do arquivo
Assinaturas e contratos	Não	Leitura direta do arquivo
Convenções do projeto	Não	CLAUDE.md
Contagem e datas	Não	Claude Code lendo o código

A regra de bolso: o resumo serve pra decidir ONDE mexer, e o arquivo serve pra decidir COMO mexer

Quando essa divisão faz sentido e quando não vale a pena

Quando faz sentido:

• Codebase grande, com muita busca e arquivo longo, onde jogar tudo no contexto do agente fica pesado
• Triagem repetitiva de diffs, em que custo e latência baixos fazem diferença no dia a dia

Quando não vale a pena:

• Projeto pequeno: arquivo com menos de 400 linhas já passa direto pro Claude Code no plugin, então o ganho some
• Quando você quer documentação ou explicação do código: o Jev não gera texto, não adianta insistir
• Quando a pergunta exige raciocínio deliberado: "por que esse fluxo foi desenhado assim?" não é pergunta de sim ou não

Nesses casos, Claude Code puro com plan mode e Explore resolve muito bem, sem camada extra

Conclusão: Jev triando, Claude Code entendendo e alterando

Recapitulando: a separação entre leitura e edição vem do próprio Claude Code, com plan mode, subagente Explore e acceptEdits

O Jev entra como triagem barata e estreita, respondendo pergunta tipada, e não como leitor do legado

O resumo que atravessa de uma fase pra outra é o plano, a lista de arquivos e as respostas de triagem

Já o trecho que vai ser editado, os contratos e as convenções, esses sempre vêm direto do arquivo

Próximo passo? Abre o projeto com claude --permission-mode plan, pede um mapeamento ao Explore e só depois testa o Jev com os US$ 5 de crédito numa pergunta de triagem concreta

Faça o teste e me conta se a divisão fez sentido no seu legado 😀

Até o próximo post!

Perguntas frequentes

Quanto custa usar o Jev pra fazer triagem num projeto legado grande?

O preço público é US$ 0,042 por milhão de tokens de entrada, e os tokens de saída não são cobrados. Como o Jev trabalha com perguntas tipadas e curtas (sim/não, categoria, confiança), o volume de entrada tende a ficar baixo mesmo em codebase grande. Vale lembrar que ele não lê o projeto inteiro de uma vez, então o custo está ligado ao tamanho do estado que você manda, não ao tamanho do repositório.

O Jev substitui o subagente Explore do Claude Code?

Não. O Explore é somente leitura (Write e Edit negados) e foi feito pra descoberta de arquivo e busca de código dentro do próprio Claude Code. O Jev não lê arquivo nenhum, ele recebe um estado e responde perguntas tipadas sobre esse estado. São papéis diferentes: um mapeia o projeto, o outro faz triagem rápida sobre o que já foi mapeado.

Ainda existe lista de espera pra usar o Jev em 2026?

Não mais. A lista de espera foi removida e hoje qualquer pessoa pode se cadastrar direto no console da TypeSafe. O cadastro vem com US$ 5 de crédito grátis, suficiente pra testar a triagem em cima de um projeto pequeno antes de decidir se vale pro legado grande.

O plugin BorisLeMeec/jev é oficial da TypeSafe AI?

Não, é um plugin da comunidade, não é oficial da TypeSafe. Pra usar ele você precisa de Go 1.22+ instalado e de uma chave de API da TypeSafe. Ele intercepta só buscas e leituras grandes dentro do Claude Code; arquivo com menos de 400 linhas, edição (Update) e comando Bash passam direto, sem passar pelo Jev.

Que tipo de pergunta o Jev consegue responder sobre um codebase legado?

Perguntas estreitas e tipadas, do tipo ‘isso toca pagamento, sim ou não’ ou ‘esse diff merece revisão humana’. Ele devolve resposta tipada com probabilidade ou confiança numa única passada, mas não gera resumo, não gera documentação e não gera código. Pra entender o que o arquivo faz de fato, quem lê é o Claude Code, geralmente em plan mode ou via subagente Explore.

Qual a latência esperada ao colocar o Jev numa etapa de triagem?

A TypeSafe informa latência de aproximadamente 70 a 500 ms por chamada. Isso é rápido o suficiente pra rodar como um filtro antes do Claude Code decidir se vale a pena carregar um arquivo inteiro no contexto. Ainda assim, o número é o reportado pela própria TypeSafe, então o ideal é medir no seu pipeline específico antes de assumir esse valor como garantido.