DeepSeek para pensar e Claude Code para executar: como dividir a tarefa entre os dois

Fala aí, beleza? A tentação é grande: usar o chat gratuito do DeepSeek pra desenhar a solução inteira e deixar o Claude Code só com o trabalho braçal de aplicar no repositório

Só que agora essa ideia parou de ser gambiarra de fim de semana

O DeepSeek-V4-Pro saiu da fase de preview e virou versão geral, disponível no site, no app e na API, com foco em capacidade de agente. Os modelos V4 trabalham com janela de 1 milhão de tokens de contexto e saída máxima de 384 mil tokens, e têm dois modos, thinking e non-thinking, sendo que o thinking tem três níveis de esforço: low, high e max

Janela desse tamanho muda o jogo de uma conversa longa de arquitetura

Aí a pergunta "quem pensa e quem executa" deixa de ser papo de Twitter e vira decisão de workflow 🙂

O que você precisa antes de começar

Lista curta, tudo verificável antes de você abrir o terminal:

• Conta no chat do DeepSeek: o chat no site e nos apps iOS e Android é gratuito, e a empresa não vende assinatura mensal pra uso individual
• Claude Code instalado e funcionando no projeto que você vai mexer
• Repositório versionado em git, porque a parte de executar vai mexer em arquivo de verdade e você precisa conseguir desfazer
• Uma chave da API do DeepSeek, mas SÓ se você for fazer o caminho alternativo lá do final do post

Se você não vai apontar o CLI pra API, esquece a chave

O fluxo principal é dois chats abertos e um repositório no meio, mais nada

Pré-inscrição Formação Claude Code

Domine o Claude Code do básico ao avançado

Você vai aprender a criar sistemas completos com Claude Code, sem precisar ser programador. Inscreva-se para ter acesso a um desconto de lançamento e bônus especiais!

Quero minha vaga

Como usar o DeepSeek para pensar e o Claude Code para executar (passo a passo)

A lógica é simples: decisão fora, edição dentro

Nada de arquivo é tocado enquanto a decisão não voltar pro repositório

1. Levante o contexto do código antes de perguntar qualquer coisa

Modelo nenhum adivinha o teu projeto. Antes de abrir a discussão, junte o que descreve a área que você vai mexer: estrutura de pastas, o arquivo principal, o schema, o trecho que dá problema

O plan mode do Claude Code serve bem aqui, porque ele lê o código e propõe um plano sem editar arquivo nenhum até você aprovar. Você pode usar essa leitura só pra entender o terreno

O erro comum deste passo: perguntar "como eu faço autenticação nesse projeto" pra um modelo que nunca viu uma linha do projeto. A resposta vem linda e genérica, e não serve

2. Discuta a abordagem no chat do DeepSeek, no modo que pensa

Aqui é conversa mesmo: duas abordagens, trade-off, o que quebra se escolher a A, o que fica caro se escolher a B

Os modelos V4 têm modo thinking e non-thinking, e o thinking vem em três níveis de esforço (low, high e max). Decisão de arquitetura pede o modo que pensa, não o que responde rápido… pergunta simples de sintaxe não precisa de esforço max

O erro comum deste passo: aceitar a primeira resposta. Peça a alternativa, peça o contra. É pra isso que serve ter um segundo modelo na jogada

3. Traga a decisão pro repositório e valide no plan mode do Claude Code

Agora sim, dentro do projeto. No Claude Code, o plan mode é aquele estado em que o modelo lê o código e propõe um plano sem tocar em arquivo até você aprovar

Pra ligar, você aperta Shift+Tab até a barra de status mostrar plan mode on. Atenção nesse ciclo, porque ele passa por accept edits on antes de chegar no plan mode: Normal > accept edits on > plan mode on

Se parar no meio do caminho, você ligou justamente o modo que aceita edição sozinho. Tome cuidado!

Pra já abrir a sessão dentro do plan mode:

claude --permission-mode plan

Aí você cola a decisão que veio do chat e pede pro Claude Code confrontar com o código real: isso faz sentido aqui? esse arquivo existe? esse padrão é o que a gente já usa?

O erro comum deste passo: aprovar o plano sem ler. Se você vai só apertar enter, o plan mode virou enfeite

4. Fixe no CLAUDE.md o que vale pra sempre

Decisão boa que morre no histórico do chat vai ser rediscutida semana que vem

O CLAUDE.md guarda instruções persistentes do projeto e é lido pelo Claude Code no começo de cada sessão. Dá pra quebrar em vários arquivos e puxar com imports @caminho, então você não precisa de um arquivão único

Entra ali o que é regra: o padrão de erro, a convenção de pasta, a escolha de biblioteca que você acabou de fechar

O erro comum deste passo: transformar o CLAUDE.md em diário do projeto. Ele é lido toda sessão, então tudo que você joga lá custa contexto pra sempre

5. Execute em fatias, referenciando arquivo com @

Com o plano aprovado, você sai do plan mode e manda executar por partes

Quando você referencia um arquivo com @, o Claude Code também puxa pro contexto os CLAUDE.md do diretório daquele arquivo e dos diretórios pais. Ou seja: apontar o arquivo certo já carrega a regra daquele pedaço do sistema junto

Se a tarefa for grande, vale quebrar em entregas fechadas antes de soltar o agente, senão ele começa bonito e termina pela metade

O erro comum deste passo: deixar o agente editar antes de existir plano aprovado. Plano depois da edição não é plano, é justificativa haha

Variante: rodar o próprio Claude Code na API do DeepSeek

Esse aqui é outro caminho, e é importante não confundir com o de cima

Aqui você não divide nada: você mantém o CLI do Claude Code e troca o modelo por trás dele

A API do DeepSeek expõe um endpoint compatível com a interface da Anthropic, e a documentação deles tem uma página específica de integração com o Claude Code com as variáveis de ambiente a definir

1. Defina as variáveis de ambiente da sessão

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=<sua DeepSeek API Key>
export ANTHROPIC_MODEL=deepseek-v4-pro
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4-pro
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4-pro
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash

2. Entenda o que cada variável define

Essas variáveis dizem qual modelo do DeepSeek responde em cada posição do Claude Code: ANTHROPIC_DEFAULT_OPUS_MODEL e ANTHROPIC_DEFAULT_SONNET_MODEL apontam pro deepseek-v4-pro, e ANTHROPIC_DEFAULT_HAIKU_MODEL aponta pro deepseek-v4-flash

Então aquela lógica de escolher o modelo certo por tipo de tarefa continua valendo, só que com outros nomes do outro lado do fio

3. Confirme pra onde a sessão está apontando

/status

O /status mostra qual provedor, base URL e proxy a sessão está usando. É a checagem que evita você achar que economizou e estar rodando no lugar de sempre 😀

4. Saiba o que muda no meio do caminho

A API do DeepSeek dá suporte nativo ao Web Search dentro do Claude Code nessa configuração: a busca web é executada pela API deles quando o modelo julga necessário

E tem o fator custo: o DeepSeek passou a cobrar a API com tarifa de pico e fora de pico, vigente desde 16:00 UTC de 16/08/2026. O pico vai das 01:00 às 04:00 e das 06:00 às 10:00 UTC, e as demais horas ficam fora de pico com 50% de desconto

Quer dizer que a MESMA tarefa custa metade dependendo da hora que você roda

Ah, e a versão GA do V4-Pro também ganhou suporte ao formato Responses API da OpenAI, com integração com o Codex, além da interface Anthropic e do ChatCompletions

O erro comum deste passo: achar que essa variante é a mesma coisa do fluxo de dois chats. Não é. Aqui o modelo do DeepSeek pensa E executa, com acesso ao teu repositório. É outro risco e outra conta

Como a divisão de pensar e executar funcionou em um SaaS completo

Nesse projeto eu combinei o Claude Code com os modelos do Antigravity, e o FORMATO da divisão é o mesmo do fluxo lá de cima: decisão fora, edição dentro

O projeto foi um SaaS de widget de feedback, com dashboard, API e widget embutível

A parte de "pensar" aconteceu fora do Claude Code, de propósito, pra não queimar cota. Primeiro eu pedi um PROJECT.md descrevendo banco, rotas de API, estrutura de páginas, estrutura de pastas, ordem de implementação e o que depende do quê, deixando explícito no prompt que aquele documento ia virar código gerado por IA

Depois, um segundo prompt leu esse PROJECT.md e transformou o plano em tarefas executáveis, cada uma funcionando sozinha, com dependências marcadas e separadas em 3 módulos: servidor e API, dashboard e widget. Isso virou um TASKS.md na raiz do projeto

Só então eu abri o Claude Code e mandei executar o que estava descrito no TASKS.md, excluindo explicitamente a landing page do escopo

O Claude Code criou 3 agentes pra tocar isso, e as faixas ficaram assim:

Repara onde estava o trabalho de verdade: decidir a arquitetura e recortar as tarefas

A execução por módulo é o que o agente faz bem sozinho

Na primeira etapa a dashboard veio funcionando, com um bug encontrado e corrigido durante a própria execução. Eu testei o cadastro na mão (nome, e-mail e senha) e a autenticação passou

A landing page foi gerada no outro ambiente referenciando o MESMO PROJECT.md, e é esse o segredo do negócio: os dois lados lendo os mesmos arquivos de contexto. No teste final o envio de feedback pela landing page funcionou e o dado apareceu na dashboard, separado por projeto

A régua que eu uso pra dividir: regra de negócio que mexe no núcleo do sistema fica com o modelo caro, front simples, landing page e ajuste depois do sistema pronto vão pro barato

E não é regra fixa, viu? Se o cenário de modelos mudar, isso muda junto

No vídeo acima você vê o fluxo inteiro rodando: os dois documentos sendo gerados fora, os agentes executando por módulo dentro do Claude Code, e o teste final do feedback chegando na dashboard

Quando dividir compensa e quando atrapalha mais do que ajuda

Compensa quando:

• Você tem decisão de arquitetura pra tomar ANTES de escrever código
• Precisa comparar duas abordagens e quer um segundo olhar que não está preso ao que já existe no repo
• Quer revisar um plano que você mesmo escreveu, procurando o buraco
• A discussão é longa e vale usar a janela de 1 milhão de tokens de contexto pra manter tudo na mesa

Atrapalha quando:

• É refactor mecânico. Renomear, mover, ajustar import: isso é trabalho de agente dentro do repositório, discutir só atrasa
• É bug pontual. O contexto que resolve está no arquivo, não numa conversa
• Copiar contexto pra fora do repo custa mais que o ganho. Se você vai passar 20 minutos montando o dossiê pra o modelo entender o projeto, você já perdeu
• Você não vai revisar o que voltou

E tem o risco central, que é o mais chato de todos: um modelo que não enxerga o teu repositório pode propor um passo perfeitamente lógico e completamente inexistente no teu projeto

Pasta que não existe, biblioteca que você não usa, comando que ninguém rodou nunca

Soma nisso que a cobertura de imprensa sobre o V4-Pro atualizado aponta avaliação mista, com desempenho fraco em parte dos benchmarks públicos e resultado forte em cibersegurança

Ou seja: bom aliado, péssimo chefe. Terceirizar decisão sem revisar é pedir pra retrabalhar

Conclusão

Dividir DeepSeek e Claude Code funciona por um motivo só: o plano volta pra dentro do repositório antes de virar edição

Se você pular essa volta, você não dividiu tarefa, você só criou duas fontes de verdade brigando entre si

O resumo do fluxo é esse: junta contexto, discute a abordagem no chat com o modo que pensa, valida no plan mode do Claude Code (Shift+Tab até aparecer plan mode on), fixa o que virou regra no CLAUDE.md e executa em fatias

Próximo passo concreto pra hoje: pega UMA tarefa pequena, roda o ciclo inteiro com o plan mode ligado e deixa uma decisão registrada no CLAUDE.md

Uma tarefa. Não o projeto inteiro

Se funcionar bem nessa, aí você escala pro resto

Até o próximo post! 😀