Claude Code no Zed: como revisar o diff e não sobrescrever o que o agente está editando?

Ter o editor aberto enquanto um agente escreve nos mesmos arquivos é tipo duas pessoas rabiscando a mesma folha ao mesmo tempo

Fala aí, beleza? Quem usa Zed edita fora do terminal, e isso muda o problema de lugar: o Claude Code no Zed entra como agente externo pelo Agent Client Protocol (ACP), onde um adaptador embrulha o SDK do Claude Code e traduz as interações pro formato JSON RPC do protocolo

O detalhe que importa pro seu dia a dia: o Claude Code roda como processo independente, e o Zed fornece a interface, os diffs e o editor em volta

Ou seja, tem um processo escrevendo no disco e tem o seu buffer em memória, e os dois nem sempre estão contando a mesma história

O buraco aqui é fluxo de edição simultânea: o que fazer com arquivo alterado por fora, como revisar o diff sem confiar no que está na tela e como evitar que um lado sobrescreva o trabalho do outro

O que você precisa antes de começar

Primeiro a versão: a partir da v0.221.x o ACP Registry passou a ser a forma preferida de instalar agentes externos no Zed, e agentes instalados por ali se atualizam automaticamente

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 116 aulas
• 4 projetos
• 9h 23min

Conhecer formação

Segundo o nome: na documentação atual do Zed o agente aparece como Claude Agent

Se liga nisso, porque muita gente procura por "Claude Code" na interface e não acha

Terceiro, e esse pega todo mundo: o Claude Agent tem autenticação e cobrança próprias

Uma chave de API configurada pro Zed Agent NÃO configura o Claude Agent, são coisas separadas

Se tu tá chegando de outro editor e quer entender o que muda no bolso e no jeito de trabalhar, já falei por aqui sobre migrar do Cursor pro Claude Code

E o <code>claude</code> no terminal integrado do Zed, funciona igual?

Aqui vai o recado honesto de expectativa: o Zed não implementa o protocolo de IDE integration que o CLI do Claude usa pra se acoplar a VS Code, JetBrains e Neovim

Na prática, rodar <code>claude</code> no terminal integrado do Zed não enxerga sua seleção, seus editores abertos ou seus diagnostics, e não mostra diffs de aceitar e rejeitar dentro do editor

O pedido existe e está registrado como discussion no repositório do Zed, convertida da issue #58298 em 2026-06-02

Quem quer a extensão gráfica nativa está no caminho do VS Code, que a Anthropic aponta como a forma recomendada de usar o Claude Code lá

No Zed o caminho é o agente via ACP 🙂

Como instalar o Claude Agent no Zed e abrir a primeira thread

Passo a passo curto, só com o que está documentado:

1. Abra o ACP Registry pela paleta de comandos

<pre><code>zed: acp registry</code></pre>

2. Se preferir, chegue pelo mesmo lugar por outro caminho: rode <code>agent: open settings</code> e escolha adicionar um agente do registry

<pre><code>agent: open settings</code></pre>

3. Inicie a thread do Claude Agent pelo Agent Panel ou pela Threads Sidebar

4. Dentro da thread do Claude Agent, rode o login e escolha como quer ser cobrado

<pre><code>/login</code></pre>

Aí tu autentica com chave de API ou com o login do Claude Code, do jeito que fizer sentido pra você

O erro comum deste passo: achar que a chave de API já configurada pro Zed Agent vale pro Claude Agent

Não vale, e normalmente a ficha cai só depois, quando a cobrança aparece separada

Como revisar o diff do agente hunk por hunk no Zed

Essa é a parte que salva você de aceitar coisa errada no automático

1. Olhe o multibuffer de revisão: é ali que as alterações do agente aparecem, com controles pra aceitar ou rejeitar hunks individuais

2. Clique no cabeçalho do card do arquivo editado: isso te leva direto ao primeiro hunk modificado, em vez de você ficar caçando o que mudou

3. Aceite e rejeite arquivos individuais a partir do editor de mensagem quando o turno mexeu em vários arquivos e você só concorda com parte

Cadê o diff inline no meu arquivo?

Esse ponto mudou e confunde bastante

O ajuste <code>agent.single_file_review</code> passou a ter valor padrão <code>false</code>, ou seja, os diffs do agente não sobrescrevem mais o git diff do buffer

Então tu tem duas saídas:

• revisar pelo botão de review do action log
• voltar o ajuste <code>agent.single_file_review</code> pra <code>true</code> e ver o diff inline no arquivo, com os mesmos controles de keep e reject por hunk

O erro comum deste passo: abrir o arquivo, não ver diff inline nenhum e concluir que o agente não mexeu em nada

Mexeu, o diff só não está onde você procurou

Como conferir o resultado final pelo Project Diff e pelo staging

Depois do keep e reject vem a segunda camada de revisão, e é ela que separa o que foi seu do que foi do agente antes do commit

1. Abra o Project Diff: no Zed ele funciona como multibuffer, assim como File History e Stash Diff

2. Use os multibuffers dedicados de Staged Changes e Unstaged Changes, onde dá pra revisar, dar stage, tirar do stage ou restaurar hunks individuais

3. Compare o que está lá com o que você lembra de ter escrito à mão: num fluxo de edição simultânea, essa é a hora em que a colisão aparece de forma clara

O erro comum deste passo: aceitar tudo no multibuffer do agente e commitar sem nunca olhar o diff do projeto inteiro

O multibuffer do agente te mostra o que ELE fez

O Project Diff te mostra o estado real do repositório, que é o que vai pro commit

O Zed diz que o arquivo mudou no disco: o que fazer sem sobrescrever o agente

Sintoma: você salva um buffer e o Zed abre um modal dizendo que o arquivo mudou no disco desde que você começou a editar, com opção de sobrescrever

Usuários relatam que esse modal aparece com frequência e obriga a escolher sobrescrever

Causa: seu buffer em memória e o arquivo em disco divergiram, porque o agente escreveu no arquivo enquanto você editava do outro lado

Lembra que o Claude Code roda em processo separado? É exatamente isso batendo na sua porta

Solução: antes de salvar, recarregue o arquivo do disco pela paleta de comandos

<pre><code>editor::ReloadFile</code></pre>

Depois reaplique a sua edição por cima do conteúdo novo

É chato? É

Mas sobrescrever cegamente é apagar o turno inteiro do agente sem perceber

Como prevenir: mantenha o autosave sob controle

No Zed o ajuste <code>autosave</code> tem valor padrão <code>off</code>, e as outras opções documentadas são <code>on_focus_change</code>, <code>on_window_change</code> e <code>after_delay</code> com milissegundos

Salvamento automático em cima do trabalho do agente é o tipo de coisa que você só descobre depois do commit

O editor mostra conteúdo antigo do arquivo: por que acontece e como resolver

Sintoma: o arquivo foi modificado fora do editor e o Zed segue exibindo o conteúdo antigo, cacheado

Tu olha a tela, acha que está tudo no lugar, e o disco diz outra coisa

Causa e estado atual: existe issue aberta no repositório do Zed relatando exatamente isso, a #48439, aberta em 2026-02-05 e ainda com rótulo de triagem pendente

Solução: recarregar manualmente com <code>editor::ReloadFile</code>

Como prevenir: cria o hábito de recarregar ANTES de começar a editar qualquer arquivo que o agente acabou de tocar

Nesse fluxo, o que está na tela é uma foto, não é a verdade

A verdade está no disco e no diff 😀

Erro File has been modified since read: quando você edita antes do agente

Sintoma: as ferramentas Edit e MultiEdit do Claude Code falham com o erro indicando que o arquivo foi modificado desde a leitura

Tem relato específico de bloqueio quando um processo externo modifica o arquivo depois do Read

Causa: o arquivo mudou entre a leitura e a edição

E é exatamente isso que acontece quando você salva do lado do editor no meio do turno do agente: ele leu uma versão, você gravou outra, e a edição dele não bate mais

Solução: interromper e resincronizar

No modo interativo do Claude Code, Esc interrompe o turno

Aí tu deixa o agente reler o arquivo antes de tentar de novo, em vez de insistir no turno que já está com a base desatualizada

Como prevenir: não editar o mesmo arquivo que está no turno atual do agente, e segurar o save enquanto o turno roda

Parece regra boba, mas é ela que evita metade dos conflitos desse fluxo

Como desfazer quando os dois lados mexeram no mesmo arquivo

1. Com o campo de prompt vazio, aperte Esc duas vezes pra abrir o menu de rewind (se tiver texto no campo, o Esc duplo só limpa o texto)

2. Se preferir o comando, chame direto

<pre><code>/rewind</code></pre>

3. Escolha o que restaurar: dá pra restaurar a conversa mantendo o código atual, ou restaurar o código revertendo arquivos e mantendo a conversa

4. Saiba que as duas opções de restaurar código só aparecem quando o checkpoint selecionado tem alterações de arquivo rastreadas

E aqui vem a parte que importa de verdade num fluxo com editor aberto: o checkpointing só rastreia arquivos editados dentro da sessão atual

O erro comum deste passo: contar com o rewind pra desfazer a SUA edição manual

Ele não vê o que você escreveu por fora, então o undo do seu lado é o git, não o menu de rewind

Quando vale isolar a thread em um git worktree

Tem cenário em que prevenir é bem melhor que revisar

O Zed permite isolar threads de agente em git worktrees: se duas threads podem editar os mesmos arquivos, a recomendação é iniciar uma em um novo worktree pra ter um checkout isolado, escolhendo o worktree pelo seletor na barra de título

Threads rodando em worktrees vinculados aparecem sob o mesmo projeto do worktree principal, então tu não perde o contexto do repo

Os casos onde isso paga o esforço:

• refatoração longa rodando em paralelo com uma correção pontual que você quer entregar hoje
• agente trabalhando enquanto você edita à mão no mesmo módulo
• duas threads no mesmo repositório, cada uma com a sua tarefa

E tem um detalhe bem massa pra quem precisa de dependência instalada no checkout novo: o Zed tem um hook de task <code>create_worktree</code>, que roda automaticamente depois que o editor cria um worktree vinculado

Ele recebe <code>ZED_WORKTREE_ROOT</code> apontando pro novo worktree e <code>ZED_MAIN_GIT_WORKTREE</code> apontando pro repositório original

Dá pra usar isso pra preparar o ambiente do checkout novo em vez de repetir setup na mão toda vez

Se o teu fluxo já tem mais de um agente circulando, vale olhar também onde o Hermes Agent entra e onde o Claude Code entra, porque isolar thread fica ainda mais importante quando não é só um bicho mexendo no repo

Fechando o fluxo: revisar sempre, isolar quando o risco é alto

O fluxo do Claude Code no Zed cabe em três movimentos

Recarregar antes de editar, com <code>editor::ReloadFile</code>, porque a tela mente quando outro processo escreve no disco

Revisar hunk por hunk no multibuffer de revisão, e depois conferir o resultado no Project Diff e nos multibuffers de Staged e Unstaged Changes

E isolar a thread em um git worktree quando o risco de colisão for real, em vez de apostar que dessa vez ninguém vai encostar no mesmo arquivo

O veredito honesto: rodar <code>claude</code> no terminal integrado do Zed não te dá IDE integration, então nada de seleção, editores abertos, diagnostics ou diff de aceitar e rejeitar dentro do editor

E ainda tem coisa em aberto no caminho, como a issue #48439 do conteúdo cacheado e a discussion convertida da #58298

Próximo passo? Instala pelo ACP Registry, roda <code>/login</code> na thread do Claude Agent e testa o ciclo completo (agente edita, você recarrega, revisa por hunk, confere no Project Diff) em um arquivo de baixo risco antes de soltar o bicho no projeto principal

Bora testar e ver como o teu fluxo reage…

até o próximo post!