Pai do Claude Code revela: Como transformar o Claude na sua “equipe de desenvolvimento virtual”?

Texto original: Boris Cherny, desenvolvedor do Claude Code

Compilação e Organização: Xiaohu AI

Talvez já tenha ouvido falar do Claude Code e até o tenha usado para escrever código e modificar documentação. Mas já alguma vez se questionou: como é que a IA mudaria a forma como trabalha se não for uma “ferramenta temporária”, mas sim um membro pleno do seu processo de desenvolvimento, ou até um sistema automatizado de colaboração?

Boris Cherny, o pai do Claude Code, escreveu um tweet muito detalhado sobre como utiliza a ferramenta de forma eficiente e como ele e a sua equipa integram o Claude em todo o processo de engenharia na prática.

Este artigo irá fazer um resumo sistemático e uma interpretação popular da sua experiência.

Como é que o Boris tornou a IA um parceiro de automação no seu fluxo de trabalho?

Principais conclusões:

Apresentou o seu fluxo de trabalho, incluindo:

Como usar o Claude:

Execute vários Claudes em conjunto: Abra 5~10 sessões no terminal e na página web para tratar de tarefas em paralelo, e também use o seu telemóvel Claude.

Não mudes cegamente as definições padrão: o Claude funciona logo de fábrica, por isso não há necessidade de configurações complicadas.

Usa o modelo mais forte (Opus 4.5): um pouco mais lento, mas mais inteligente e menos incómodo.

Planeie antes de escrever código (modo Plan): Deixe o Claude ajudar-te a pensar claramente antes de escrever, com uma taxa de sucesso elevada.

Depois de gerar código, use ferramentas para verificar a formatação e evitar erros.

Como tornar o Claude mais inteligente quanto mais o usares:

A equipa mantém uma “base de conhecimento”: sempre que Claude escreve algo errado, acrescenta experiência e não volta a fazê-lo da próxima vez.

Treine automaticamente o Claude ao escrever PRs: Deixe o Claude ler PRs e aprender novas utilizações ou especificações.

Comandos comuns tornam-se comandos de barra, e Claude pode chamá-los automaticamente, poupando trabalho repetitivo.

Use “subagentes” para tratar de tarefas fixas, como simplificação de código, verificação de funções, etc.

Como gerir permissões:

Em vez de saltar permissões, defina comandos seguros para passarem automaticamente.

Sincroniza os fluxos de trabalho do Claude em vários dispositivos (web, terminal, móvel).

O ponto mais importante:

Certifique-se de dar ao Claude um “mecanismo de validação” para que possa confirmar que o que escreve está correto.

Por exemplo, o Claude executa automaticamente os testes, abre o navegador para testar páginas web e verifica se a função funciona.

Claude Code é um “parceiro”, não uma “ferramenta”

Boris começa por transmitir uma ideia central: Claude Code não é uma ferramenta estática, mas um companheiro inteligente que pode trabalhar consigo, aprender continuamente e crescer em conjunto.

Não requer uma configuração muito complicada e é forte logo à saída da caixa. Mas se estiveres disposto a investir tempo em construir melhores formas de o usar, os ganhos de eficiência que pode trazer são exponenciais.

Seleção de modelos: escolha o mais inteligente, não o mais rápido

Boris utiliza o modelo topo de gama da Claude, Opus 4.5 + Mindset (“com pensamento”), para todas as tarefas de desenvolvimento.

Embora este modelo seja maior e mais lento que o Sonnet, mas:

• Tem uma capacidade mais forte de compreender
• Melhor capacidade de utilização de ferramentas
• Sem necessidade de orientação repetida, menos comunicação de ida e volta
• No geral, poupa mais tempo do que ao usar modelos rápidos
• Iluminação: A verdadeira eficiência de produção não reside na velocidade de execução, mas em “menos erros, menos retrabalho e menos explicações repetitivas”.

1. Modo Planear: Escreve código com IA, não te apresses a deixá-la “escrever”

Quando abrimos o Claude, muitas pessoas escrevem intuitivamente “escreve uma interface para mim” ou "refatora este código… Claude também costuma “escrever algumas”, mas muitas vezes perde-se, falha a lógica ou até interpreta mal os requisitos.

O primeiro passo do Boris nunca pediu ao Claude para escrever código. Ele utiliza o modelo de Plano – trabalha com Claude para desenvolver primeiro a ideia de implementação e depois passa para a fase de execução.

Como é que ele fez isso?

Ao iniciar uma PR, o Boris não deixa o Claude escrever o código diretamente, mas usa o modo Plano:

1. Descrever o objetivo

2. Fazer um plano com o Claude

3. Confirmar cada passo

4. Deixe Claude escrever à mão

Sempre que precisar de implementar uma nova funcionalidade, como “adicionar throttling a uma API”, confirma com o Claude passo a passo:

• É implementado com middleware ou está logicamente embedded?
• A configuração atual do limite precisa de ser modificada dinamicamente?
• Preciso de registos? O que é devolvido quando falha?

Este processo de “negociação de planos” é semelhante a duas pessoas a desenharem “desenhos de construção” juntas.

Quando Claude percebe o objetivo, Boris ativa o modo de “aceitar edições automáticas”, que permite a Claude modificar código, submeter PRs e, por vezes, até eliminar a necessidade de confirmação manual.

“A qualidade do código do Claude depende de concordares ou não antes de escreveres o código.” —— Boris

Revelation: Em vez de corrigir repetidamente os erros do Claude, vamos traçar um roteiro claro desde o início.

Resumo

O modelo do Plano não é uma perda de tempo, mas uma pré-negociação para uma execução estável. Por mais forte que seja a IA, também tem de ser “dizes claramente”.

2. Multi-Claude Parallel: Não é uma IA, mas uma equipa de desenvolvimento virtual

O Boris não usou apenas um Claude. A rotina diária dele é assim:

• Abrir 5 Claudes locais no terminal, e as sessões são atribuídas a tarefas diferentes (por exemplo, refatoração, escrita de testes e bugs).
• Abrir mais 5–10 Claudes no navegador, paralelos ao nível local
• Use a aplicação Claude para iOS no seu telemóvel para iniciar tarefas a qualquer momento

Cada instância do Claude é como um “assistente dedicado”: algumas são responsáveis por escrever código, outras pela conclusão do documento, e outras ficam muito tempo em segundo plano para realizar tarefas de teste.

Ele até configurou notificações do sistema para ser alertado assim que Claude esperasse por uma entrada.

Porquê fazer isto?

O contexto de Claude é local e não adequado para “uma janela faz tudo”. Boris divide Claude em vários caracteres para trabalharem em paralelo, reduzindo os tempos de espera e “interferindo com a memória” no outro.

Ele também se lembra através das notificações do sistema: “Claude 4 está à espera da tua resposta” e “Claude 1 terminou os testes”, gerindo estas IAs como se estivessem a gerir um sistema multithread.

Compreensão por analogia

Imagina-te sentado ao lado de cinco estagiários inteligentes, cada um com uma tarefa. Não tens de fazer tudo até ao fim, basta “cortar pessoas” em momentos críticos e manter a tarefa a decorrer sem problemas.

Implicações: Usar o Claude como múltiplos “assistentes virtuais” para realizar diferentes tarefas pode reduzir significativamente os tempos de espera e os custos de mudança de contexto.

3. Comandos de Corte: Transforma o que fazes todos os dias em atalhos para Claude

Existem alguns fluxos de trabalho que fazemos dezenas de vezes por dia:

• Modificar código → commit → push → criar uma PR
• Verificar o estado da construção → notificar a equipa de → problemas de atualização
• Alterações de sincronização para múltiplas sessões na web e localmente
• O Boris não quer provocar o Claude sempre: “Por favor, compromete-se, depois empurra, e depois faz PR…”

Ele encapsula estas operações em comandos Slash, tais como:

/commit-push-pr

Por trás destes comandos está a lógica do script Bash, armazenada na pasta .claude/commands/, adicionada à gestão Git e usada pelos membros da equipa.

Como é que o Claude usa estes comandos?

Quando Claude encontra este comando, ele não se limita a “executar o comando”, conhece o fluxo de trabalho que representa e pode executar automaticamente passos intermédios, pré-preencher parâmetros e evitar comunicação repetida.

Compreenda os pontos-chave

O comando Slash é como o “botão automático” que se instala para o Claude. Treina-o para perceber o fluxo de uma tarefa, e depois ele pode executá-lo com um clique.

“Não só posso poupar tempo com comandos, como o Claude também pode.” —— Boris

Revelação: Não repitas o prompt de entrada todas as vezes, abstrai tarefas de alta frequência em comandos, tu e o Claude podem trabalhar juntos para “automatizar”.

4. Base de Conhecimento da Equipa: Claude não depende de prompts para aprender, mas sim dos genes de conhecimento mantidos pela equipa

A equipa do Boris mantém uma base de conhecimento .claude e junta-se à gestão do Git.

É como uma “Wikipédia interna” para o Claude, a gravar:

• Qual é a forma correta de a escrever
• Quais são as melhores práticas para acordos de equipa
• Que problemas encontra e como resolvê-los?

Claude consulta automaticamente esta base de conhecimento para compreender o contexto e determinar o estilo do código.

O que acontece quando o Claude faz algo errado?

Sempre que Claude interpreta mal ou escreve a lógica de forma errada, acrescenta uma lição.

Cada equipa mantém a sua própria versão.

Todos colaboram na edição, e o Claude faz juízos com base nessa base de conhecimento em tempo real.

Por exemplo:

Se o Claude continuar a escrever a lógica de paginação errada, a equipa só precisa de escrever o padrão correto de paginação na base de conhecimento, e todos os utilizadores beneficiarão automaticamente no futuro.

A abordagem do Boris: não ralhar, não desligue, mas “treine uma vez”:

Não escrevemos este código assim, mas adicionamo-lo à base de conhecimento

Claude não vai cometer este erro outra vez da próxima vez.

Além disso, este mecanismo não é mantido apenas pelo Boris, mas sim contribuído e modificado por toda a equipa todas as semanas.

Iluminação: Com a IA, não todos sozinhos, mas para construir um sistema de “memória coletiva”.

5. Mecanismo de aprendizagem automática: A própria RP é o “dado de treino” do Claude

Boris frequentemente @Claude PRs ao fazer revisões de código, tais como:

@.claude adicionou esta função à base de conhecimento

Em conjunto com o GitHub Actions, o Claude aprende automaticamente a intenção por detrás desta alteração e atualiza o seu conhecimento interno.

É semelhante a “treinar continuamente o Claude”, onde cada análise não só corresponde ao código como também melhora as capacidades da IA.

Isto já não é “pós-manutenção”, mas integra os mecanismos de aprendizagem da IA na colaboração diária.

A equipa usa relações públicas para melhorar a qualidade do código, e Claude melhora o conhecimento ao mesmo tempo.

Implicações: A RP não é apenas um processo de revisão de código, mas uma oportunidade para as ferramentas de IA evoluírem.

6. Subagentes: Deixe Claude executar tarefas complexas de forma modular

Para além do processo principal da tarefa, Boris também define vários subagentes para lidar com tarefas secundárias comuns.

Subagentes são módulos que correm automaticamente, tais como:

• simplificador de código: Simplifica automaticamente a estrutura depois de Claude terminar de escrever o código
• verify-app: Executar um teste completo para verificar se o novo código está disponível
• analisador de logs: Analisar registos de erro e localizar rapidamente problemas

Estes sub-agentes ligam-se automaticamente aos fluxos de trabalho do Claude como plugins, correndo de forma automática e colaborativa, sem necessidade de pedidos repetidos.

Revelação: O subagente é o “membro da equipa” de Claude, e Claude é promovido de assistente a “comandante de projeto”.

O Claude não é apenas uma pessoa, mas um pequeno gestor que pode liderar uma equipa.

7. Parágrafo suplementar 1: Gancho PostToolUse - o último guardião da formatação do código

Não é fácil fazer com que todos escrevam código de forma uniforme numa equipa. Embora Claude tenha fortes capacidades de geração, inevitavelmente terá falhas de detalhe, como má indentação e mais linhas em branco.

A abordagem de Boris é estabelecer umGancho PostToolUse —

Simplificando, este é o “gancho de pós-processamento” que Claude chama automaticamente após “completar a tarefa”.

O seu papel inclui:

• Corrigir automaticamente a formatação do código
• Omissões suplementares
• Lidar com erros de lint para evitar bloqueios de CI

Este passo é geralmente simples, mas fundamental. Tal como voltar a usar o Grammarly depois de escrever um artigo, o trabalho submetido é estável e arrumado.

Para as ferramentas de IA, a chave do sucesso muitas vezes não está no poder gerativo, mas na capacidade de finalização.

8. Gestão de permissões: Pré-autorizar em vez de saltar

O Boris deixa claro que não usa --dangerously-skip-permissions-- um parâmetro no Claude Code que pode saltar todos os prompts de permissão ao executar comandos.

Parece conveniente, mas também pode ser perigoso, como apagar ficheiros acidentalmente, executar scripts errados, etc.

As suas alternativas são:

1. Usar o comando /permissions para declarar explicitamente quais os comandos que são confiáveis

2. Escrever estas configurações de permissões em .claude/settings.json

3. Partilhe estas definições de segurança com toda a sua equipa

É como pré-abrir um conjunto de operações de “whitelisting” para o Claude, tais como:

“Comandos pré-Aprovados”: [

“Compromete-te”,

“build de corrida npm”,

“o mais difícil”

]

Claude executa estas ações sem as interromper sempre.

Este mecanismo de permissões foi concebido para se assemelhar mais a um sistema operativo de equipa do que a uma ferramenta autónoma. Ele pré-autoriza os comandos comuns e seguros de bash com o comando /permissions, que são guardados em .claude/settings.json e partilhados pela equipa.

Implicações: a automação da IA não significa sair do controlo. Incorporar políticas de segurança no próprio processo de automação é verdadeiramente engenharia.

9. Ligação multi-ferramenta: Claude = robô multifuncional

O Boris não deixa o Claude escrever código localmente. Configurou o Claude para aceder a múltiplas plataformas centrais através do MCP (um módulo central de serviço):

• Notificações automáticas do Slack (por exemplo, resultados de compilação)
• Consultar dados do BigQuery (por exemplo, métricas de comportamento do utilizador)
• Raspar registos de sentinela (por exemplo, rastreio de exceções online)

Como conseguir isso?

A configuração do MCP é guardada em .mcp.json

Claude lê configurações em tempo de execução, realizando tarefas multiplataforma de forma autónoma

Toda a equipa partilha um conjunto de configurações

Tudo isto é feito através da integração do MCP (sistema central de controlo do Claude) com o Claude, e a configuração é guardada em .mcp.json.

O Claude é como um assistente robótico que o ajuda:

“Terminar de escrever código → submeter um PR → Avaliar o desempenho → Notificar QA → registo de relatórios”.

Isto já não é uma ferramenta de IA no sentido tradicional, mas sim um centro nervoso para sistemas de engenharia.

Revelação: Não deixes a IA trabalhar apenas “no editor”,

Pode ser um agendador em todo o ecossistema do seu sistema.

10. Processamento assíncrono de tarefas longas: agente em segundo plano + plugin + hook

Em projetos reais, Claude por vezes tem de lidar com tarefas longas, tais como:

• Build + Test + Deploy
• Gerar relatórios + enviar emails
• Script de migração de dados a correr

A abordagem de Boris é muito engenheirada:

Três formas de lidar com tarefas longas:

1. Depois de Claude concluir, usar o agente de fundo para verificar os resultados

2. Usar o Gancho de Paragem para ativar automaticamente ações subsequentes no final da tarefa

3. Utilizar o plugin ralph-wiggum (proposto por @GeoffreyHuntley) para gerir estados de processo longos

Nestes cenários, Boris utiliza:

–modo-permissão=dontAsk

Ou coloca tarefas num sandbox para evitar interromper o processo devido a pedidos de permissões.

O Claude não é um “observador constante”, mas sim um colaborador em quem podes confiar para o teu alojamento.

Implicações: As ferramentas de IA não são apenas adequadas para operações curtas e rápidas, mas também para processos complexos e de longo prazo – desde que construa um “mecanismo de alojamento” para elas.

11. Mecanismo de verificação automática: O valor de saída do Claude não compensa, depende se consegue verificar-se a si próprio

Uma das coisas mais importantes sobre a experiência do Boris é:

Qualquer resultado produzido pelo Claude deve ter um “mecanismo de validação” para verificar a sua correção.

Ele adicionará um script de validação ou gancho ao Claude:

• Depois de escrever o código, Claude executa automaticamente casos de teste para verificar se o código está correto
• Simular interações do utilizador no navegador para validar a experiência front-end
• Comparar automaticamente registos e métricas antes e depois da execução

Se não passar, o Claude irá modificar automaticamente e voltar a executar. até passar.

É como se o Claude tivesse trazido um “sistema de feedback fechado” ele próprio.

Isto não só melhora a qualidade, como também reduz a carga cognitiva sobre as pessoas.

Iluminação: O que realmente determina a qualidade dos resultados de IA não é o número de parâmetros do modelo, mas se foi concebido um “mecanismo de verificação de resultados” para ele.

Resumo: Em vez de substituir os humanos, deixar a IA trabalhar em conjunto como humanos

A abordagem de Boris não se baseia em “funcionalidades ocultas” ou tecnologia obscura, mas usa Claude de forma engenheira para a atualizar de uma “ferramenta de chat” para um componente eficiente do sistema funcional.

O seu uso de Claude tem várias características principais:

• **Paralelismo multi-sessão:**A divisão das tarefas é mais clara e eficiente
• **Prioridade de Planeamento:**O modo Plano melhora o alinhamento dos objetivos do Claude
• **Suporte ao sistema de conhecimento:**A equipa trabalha em conjunto para manter a base de conhecimento de IA e iterar continuamente
• **Automação de tarefas:**Comando barra + subagente para fazer Claude funcionar como um motor de processos
• **Mecanismo de realimentação em malha fechada:**Cada saída do Claude tem lógica de verificação para garantir uma saída estável e fiável

Na verdade, a abordagem de Boris mostra uma nova forma de usar a IA:

• Atualizar o Claude de “Assistente Conversacional” para “Sistema de Programação Automatizado”
• Transformar a acumulação de conhecimento do cérebro humano numa base de conhecimento para IA
• Transformar processos de operações manuais repetitivas para fluxos de trabalho scriptados, modulares, colaborativos e automatizados

Esta abordagem não depende da magia negra, mas é uma manifestação da capacidade de engenharia. Também pode aprender com isto para usar o Claude ou outras ferramentas de IA de forma mais eficiente e inteligente.

Se muitas vezes sentes que “sabe um pouco mas é pouco fiável” ou “preciso sempre de corrigir o código que escrevo”, o problema pode não estar no Claude, mas sim porque não lhe deste um mecanismo de colaboração maduro.

O Claude pode ser um estagiário qualificado ou um parceiro de engenharia estável e fiável, dependendo de como o utiliza.