A Única Regra Que o Criador do Claude Code Nunca Quebra

AAI LABS
Computing/SoftwareAdult EducationInternet Technology

Transcript

00:00:00Este é o Boris,
00:00:00e quando as pessoas ficam presas com o Claude Code,
00:00:02elas perguntam a ele como usá-lo.
00:00:04Mas por que elas perguntariam a ele?
00:00:05É porque o Boris trabalha na Anthropic e foi ele quem realmente criou o Claude Code.
00:00:09Mesmo que ele diga que sua configuração é bem simples,
00:00:11não é.
00:00:12Essa é apenas a perspectiva dele.
00:00:13O que é simples para ele pode ser um sistema inteiro para todos os outros.
00:00:16Agora temos muito o que conversar,
00:00:17já que fiquei honestamente surpreso com alguns dos pontos,
00:00:19e embora algumas coisas fossem tecnicamente mais antigas,
00:00:22ele ainda me deu uma perspectiva nova sobre esses recursos também.
00:00:25Em uma das dicas dele,
00:00:26o Boris corrige um dos maiores equívocos que as pessoas têm ao tentar construir algo com o Claude Code.
00:00:31Elas basicamente dão uma tarefa,
00:00:32e então quando há erros menores,
00:00:34ou ele não consegue completá-la 100%,
00:00:36elas ficam desapontadas.
00:00:38Mas os humanos trabalham de maneira muito similar.
00:00:40Por isso ele nos diz que devemos sempre dar ao Claude uma forma de verificar seu trabalho.
00:00:44Por exemplo,
00:00:44se você vai escrever qualquer código Python para construir um projeto,
00:00:47você deve dizer a ele para usar testes também.
00:00:49Isso porque o Claude obtém esse ciclo de feedback,
00:00:51e isso aumenta instantaneamente a qualidade do resultado final.
00:00:54E se você nem quiser entrar no código,
00:00:56você pode realmente perguntar quais testes deveria usar,
00:00:59e ele vai dar um teste para cada coisa que implementar.
00:01:02Mesmo que você queira que ele trabalhe autonomamente,
00:01:04algo sobre o qual o Boris também tem muitas dicas,
00:01:06você pode simplesmente editar o arquivo Claude.md,
00:01:08que é enviado em todas as sessões do Claude Code.
00:01:11Lá você pode dizer a ele que antes de fazer qualquer trabalho,
00:01:13ele deve mencionar como verificaria esse trabalho,
00:01:15então ele obtém esse ciclo de feedback constante.
00:01:18Outro ponto importante que o Boris identifica é que a verificação é diferente para cada domínio.
00:01:22Novamente,
00:01:22pode ser tão simples quanto executar um comando bash,
00:01:25ou para verificação baseada em UI,
00:01:26você tem muitas formas diferentes de fazer isso também,
00:01:29uma das quais é a própria extensão de navegador do Claude.
00:01:32Fizemos um vídeo bem extenso sobre isso também,
00:01:33e vamos deixar o link aqui embaixo.
00:01:35Basicamente,
00:01:35o Claude navega pelo site inteiro e pode verificar tudo.
00:01:39Isso funciona como verificação para praticamente qualquer coisa.
00:01:41Por exemplo,
00:01:41alguém perguntou como poderia verificar um aplicativo móvel que estava sendo construído.
00:01:45Na verdade,
00:01:45existem vários MCPs de simulador iOS e Android que você pode usar também.
00:01:50Mas se você acha que esses MCPs consomem muitos tokens,
00:01:52então pode usar não apenas verificação,
00:01:54mas técnicas orientadas por verificação.
00:01:56Por exemplo,
00:01:56você pode usar desenvolvimento orientado por testes,
00:01:58onde os testes para um novo recurso são escritos primeiro,
00:02:01e então você faz a implementação real.
00:02:03Você também pode usar capturas de tela nesse processo para verificar a UI também.
00:02:06Falando do Claude.md,
00:02:07o Boris também enfatiza o quão importante esse arquivo é e como ele deve ser único para cada repositório do Claude Code.
00:02:14Pense dessa forma: ele deve conter todas as informações básicas que uma sessão do Claude recém-criada deve ter sobre seu projeto.
00:02:20Isso inclui a pilha de tecnologias,
00:02:21a estrutura básica do projeto,
00:02:22alguns estilos de código e convenções que sua equipe segue e,
00:02:25mais importante,
00:02:26as coisas que ele não deve fazer.
00:02:28Isso porque se você encontrar erros em qualquer uma de suas sessões,
00:02:31você provavelmente não quer que o Claude os repita.
00:02:34Então ele criou o hábito de pedir a toda a sua equipe para contribuir com o Claude.md várias vezes por semana.
00:02:39Sempre que veem ele fazendo algo incorretamente,
00:02:41eles adicionam lá também.
00:02:43Cada membro da equipe também tem uma responsabilidade específica por manter um arquivo específico.
00:02:47Outra ótima estrutura para aplicativos full stack é que cada microsserviço que você está executando pode ter seu próprio Claude.md.
00:02:53O front-end pode ter o seu próprio,
00:02:54e o back-end pode ter o seu próprio também.
00:02:56Outra coisa importante é não sobrecarregar o Claude.md.
00:02:59Ele confirma isso dizendo que seu próprio Claude.md tem cerca de 2.5K tokens,
00:03:03e ele até destacou exatamente o que cobrem nele.
00:03:06Você já deve saber sobre os diferentes modos que você pode usar com o Claude Code,
00:03:09sendo o modo de planejamento especificamente para planejar.
00:03:12Voltaremos a isso mais tarde, pois é um ponto importante.
00:03:15Depois há o modo de auto-aceitação,
00:03:16que basicamente auto-aceita todas as edições de arquivo.
00:03:19Mas há outra opção também,
00:03:20que é o modo de pular permissões perigosamente,
00:03:22onde o Claude essencialmente tem permissão para executar tudo.
00:03:26O Boris diz que não usa isso,
00:03:27e ele está certo,
00:03:28especialmente em ambientes de produção,
00:03:29onde um único comando de terminal pode bagunçar o projeto inteiro.
00:03:33Em vez disso,
00:03:33ele usa as permissões no Claude Code para configurar quais comandos são permitidos,
00:03:36quais comandos ele deve perguntar antes de executar e quais comandos são completamente negados.
00:03:41Você pode praticamente adicionar qualquer regra que quiser e defini-la no nível do projeto,
00:03:44e o Claude vai seguir isso.
00:03:46Para compartilhar isso com sua equipe,
00:03:47a pasta .Claude também contém um arquivo settings.json onde todos esses comandos estão escritos,
00:03:52e ele pode então compartilhar esse arquivo com o resto da equipe.
00:03:56De certa forma,
00:03:56o Claude Code foi um dos produtos com o nome mais mal escolhido da Anthropic,
00:04:00porque não é usado apenas para código.
00:04:02Você pode até ter visto pessoas gerando fluxos de trabalho completos da Anetian com ele,
00:04:06ou até configurando pipelines de SEO inteiros ou diferentes agentes para analisar mercados comerciais e outras coisas.
00:04:12O ponto é que é um sistema completo para as pessoas controlarem muitos fluxos de trabalho diferentes.
00:04:16O exemplo que o Boris dá é que o Claude praticamente usa todas as outras ferramentas dele também.
00:04:21Por exemplo,
00:04:21ele usa o Slack com o Claude Code usando o servidor MCP,
00:04:24junto com várias outras ferramentas como BigQuery e Sentry,
00:04:27todas através de suas CLIs dentro do Claude Code.
00:04:30Novamente,
00:04:30isso só mostra que você pode usar o Claude Code como uma forma de orquestrador.
00:04:33Para mim especificamente,
00:04:34uma das maiores maneiras que uso nessa orquestração é dentro do Notion,
00:04:37onde o Claude se conecta ao Notion via MCP.
00:04:40Ele é capaz de criar bancos de dados,
00:04:41preenchê-los e entender o contexto de todas as nossas ideias de vídeo.
00:04:45Claro,
00:04:45você vai vê-las desfocadas porque são ideias de vídeos futuros,
00:04:48mas espero que você entenda o ponto.
00:04:50Agora,
00:04:50se você está se perguntando como o Boris realmente usa o Claude Code antes de começar a implementar qualquer recurso ou tarefa,
00:04:56ele primeiro muda para o modo de planejamento e descreve claramente o que quer.
00:05:00Uma vez que o Claude tem um plano,
00:05:01ele continua a partir daí.
00:05:02Ele argumenta que ter um bom plano é extremamente importante e que toda a ida e vinda que ele precisa fazer com o agente acontece durante o modo de planejamento.
00:05:09Ele só inicia o agente depois de verificar que o plano é realmente válido.
00:05:13Depois disso,
00:05:13ele o inicia no modo de auto-aceitação de edições,
00:05:15não no modo de pular permissões perigosamente.
00:05:17Quanto a como ele usa em escala,
00:05:18ele também menciona que executa cinco dessas sessões do Claude Code em paralelo.
00:05:23Ao trabalhar com elas, ele basicamente numera suas abas.
00:05:26Ele faz isso para que quando recebe notificações de diferentes abas,
00:05:29ele saiba de qual aba do terminal elas estão vindo.
00:05:32Além disso,
00:05:32ele também usa muito as sessões web do Claude Code.
00:05:35É onde você conecta a versão web do Claude Code ao seu GitHub,
00:05:38dá acesso a um repositório demo,
00:05:40e ele é capaz de trabalhar nisso na nuvem.
00:05:43A maneira como o Boris trabalha com isso é que ele usa o recurso de agentes em segundo plano para colocar qualquer tarefa de longa duração no segundo plano.
00:05:49Às vezes,
00:05:49ele até usa no celular,
00:05:50onde o Claude pode automaticamente fazer todo o trabalho em uma sessão na nuvem,
00:05:54e quando termina,
00:05:55cria uma nova branch e envia todas as mudanças de código lá para você revisar.
00:05:59Também há o comando teleport,
00:06:00que traz as sessões da nuvem de volta para o terminal local e permite que você visualize e trabalhe nele você mesmo.
00:06:06E essa é realmente a definição de trabalhar com qualquer agente de IA,
00:06:08onde ele está basicamente tratando-o como um desenvolvedor júnior.
00:06:11Outro ponto interessante que ele mencionou é que ele praticamente usa o Opus 4.5 com pensamento ativado para tudo.
00:06:17Ele argumenta que mesmo sendo um modelo maior e mais lento e levando mais tempo do que o Sonnet e significativamente mais tempo do que os modelos Haiku,
00:06:23ele tem uma chance muito menor de cometer erros.
00:06:26Como resultado,
00:06:26o tempo total gasto trabalhando com o modelo e guiando-o é na verdade muito menor com o Opus 4.5.
00:06:33Ele também usa a ação do GitHub Claude Code,
00:06:35que é basicamente um bot que você pode chamar dentro dos seus repositórios autorizados do GitHub.
00:06:40Ele forneceu um caso de uso muito forte para isso também.
00:06:43Durante as revisões de PR,
00:06:44sempre que ele encontra erros,
00:06:45ele simplesmente pede ao Claude para adicionar esses erros ao arquivo Claude.md.
00:06:49Quanto às tarefas de longa duração,
00:06:50ele usa três abordagens diferentes.
00:06:52A primeira é pedir ao Claude para verificar seu trabalho usando diferentes testes que o próprio Claude Code cria e então colocar essas tarefas em segundo plano.
00:07:00Estes não são os agentes em nuvem de que estamos falando.
00:07:02São apenas tarefas em segundo plano que executam silenciosamente e relatam de volta ao agente principal quando concluídas.
00:07:07A segunda abordagem é usar um gancho de parada para acionar automaticamente essa verificação quando o Claude para de produzir resultados.
00:07:12A terceira opção que ele menciona também é baseada nessa ideia,
00:07:15que é o que o plugin Ralph Wiggum utiliza.
00:07:17Fizemos um vídeo bastante extenso sobre o plugin Ralph Wiggum.
00:07:20Mostramos como usamos o plugin Ralph e como testamos durante o desenvolvimento para verificar se a UI que o Claude Code está produzindo está realmente correta.
00:07:28Isso essencialmente remove o humano do processo por completo.
00:07:31Novamente,
00:07:31repetindo o padrão de verificação de que ele falou,
00:07:34ele também usa para verificar o formato do código sendo escrito usando diferentes tipos de linters e formatadores para várias linguagens.
00:07:41Ele basicamente diz que,
00:07:42embora os modelos gerem código correto,
00:07:44esses formatadores ajudam a limpar os 10% restantes.
00:07:47E isso é importante para que não haja erros quando o código é executado no CI como parte dos pipelines de integração do GitHub.
00:07:53Agora passando para algumas das funcionalidades mais simples que estão no Claude Code há muito tempo,
00:07:57mas ainda economizam muito tempo e que muitos iniciantes não conhecem muito bem.
00:08:01Como ele já mencionou,
00:08:01seu próprio fluxo de trabalho é surpreendentemente simples.
00:08:04Isso se aplica à maioria de nós.
00:08:06Não precisamos complicar demais tudo no Claude Code para ser verdadeiramente produtivos.
00:08:09Essas funcionalidades simples integradas já proporcionam cerca de 90% da produtividade que você está tentando alcançar.
00:08:15Começando com /comandos,
00:08:15ele se refere aos seus fluxos de trabalho repetitivos como seus fluxos de trabalho de
00:08:19"ciclo interno"
00:08:19,
00:08:20coisas que ele tem que repetir muitas vezes por dia.
00:08:22Ele dá um exemplo muito simples de um /comando do GitHub que usa frequentemente.
00:08:26Como todos esses /comandos são armazenados dentro da sua pasta .claud em uma subpasta de comandos,
00:08:31você pode realmente commitá-los no git.
00:08:33É assim também que ele os compartilha com toda a sua equipe.
00:08:36Depois disso,
00:08:36outra funcionalidade integrada muito simples são os subagentes.
00:08:39As pessoas ficaram um pouco obcecadas com essa funcionalidade,
00:08:41construindo subagentes para quase todos os casos de uso imagináveis,
00:08:44como pesquisadores de mercado ou validadores de produtos.
00:08:47Cada um tem seus próprios casos de uso,
00:08:49mas Boris usa subagentes para automatizar fluxos de trabalho simples que exigem instruções completamente diferentes.
00:08:55Por exemplo,
00:08:55a maioria dos seus agentes é usada para verificar se a arquitetura do seu código está correta,
00:08:59para refatorar o código que foi escrito e para validar se as compilações finais realmente funcionam.
00:09:04Vamos falar sobre a Automata agora.
00:09:05Depois de ensinar milhões de pessoas a construir com IA,
00:09:07começamos a implementar esses fluxos de trabalho nós mesmos.
00:09:11Descobrimos que poderíamos construir produtos melhores,
00:09:13mais rápido do que nunca.
00:09:14Ajudamos a dar vida às suas ideias,
00:09:16sejam aplicativos ou sites.
00:09:18Talvez você tenha assistido nossos vídeos pensando:
00:09:19"Eu tenho uma ótima ideia,"
00:09:20mas não tenho uma equipe técnica para construí-la.
00:09:22"É exatamente aí que entramos."
00:09:24Pense em nós como seu copiloto técnico.
00:09:26Aplicamos os mesmos fluxos de trabalho que ensinamos a milhões diretamente ao seu projeto,
00:09:30transformando conceitos em soluções reais e funcionais sem as dores de cabeça de contratar ou gerenciar uma equipe de desenvolvimento.
00:09:36Pronto para acelerar sua ideia em realidade?
00:09:39Entre em contato em hello@automata.dev Isso nos traz ao fim deste vídeo.
00:09:43Se você quiser apoiar o canal e nos ajudar a continuar fazendo vídeos como este,
00:09:47pode fazê-lo usando o botão super obrigado abaixo.
00:09:50Como sempre, obrigado por assistir e te vejo no próximo.

Key Takeaway

Boris, criador do Claude Code, revela que a chave para usar o Claude Code efetivamente é sempre dar ao modelo formas de verificar seu próprio trabalho através de testes, planejamento cuidadoso e configuração adequada de permissões.

Highlights

Boris, criador do Claude Code na Anthropic, enfatiza que dar ao Claude formas de verificar seu próprio trabalho (como testes) aumenta instantaneamente a qualidade dos resultados

O arquivo Claude.md deve ser único para cada repositório e conter informações essenciais como pilha de tecnologia, estrutura do projeto, convenções de código e erros a evitar

Boris nunca usa o modo 'pular permissões perigosamente' e em vez disso configura permissões específicas para comandos permitidos, negados ou que requerem aprovação

O modo de planejamento é crucial - Boris sempre planeja primeiro e só inicia a implementação após validar que o plano está correto

Boris usa Opus 4.5 com pensamento ativado para tudo, argumentando que apesar de ser mais lento, comete menos erros e economiza tempo total

Executar cinco sessões do Claude Code em paralelo e usar agentes em segundo plano são técnicas essenciais para escalar a produtividade

Comandos personalizados (/comandos) e subagentes são funcionalidades simples mas poderosas para automatizar fluxos de trabalho repetitivos

Timeline

Introdução e a Importância da Verificação

O vídeo apresenta Boris, criador do Claude Code na Anthropic, como a pessoa que responde dúvidas sobre o uso da ferramenta. Boris corrige um grande equívoco: pessoas ficam desapontadas quando há erros menores, mas deveriam tratar o Claude como um desenvolvedor júnior que precisa de feedback. A dica mais importante é sempre dar ao Claude formas de verificar seu trabalho, como usar testes em projetos Python. O ciclo de feedback através de testes aumenta instantaneamente a qualidade do resultado final, e você pode até editar o arquivo Claude.md para instruir o modelo a mencionar como verificaria seu trabalho antes de começar qualquer tarefa.

Verificação em Diferentes Domínios

Boris explica que a verificação varia conforme o domínio do projeto. Pode ser simples como executar comandos bash, ou mais complexa para interfaces de usuário, onde a extensão de navegador do Claude pode navegar e verificar sites inteiros. Para aplicativos móveis, existem MCPs de simuladores iOS e Android disponíveis. Se os MCPs consomem muitos tokens, é possível usar técnicas orientadas por verificação, como desenvolvimento orientado por testes (TDD), onde os testes são escritos primeiro e depois vem a implementação. Capturas de tela também podem ser usadas para verificar a interface do usuário durante esse processo.

Otimização do Arquivo Claude.md

O arquivo Claude.md é extremamente importante e deve ser único para cada repositório, contendo todas as informações básicas que uma nova sessão do Claude precisa saber sobre o projeto. Isso inclui pilha de tecnologia, estrutura do projeto, estilos de código, convenções da equipe e especialmente as coisas que o Claude não deve fazer. Boris criou o hábito de pedir à equipe para contribuir com o Claude.md várias vezes por semana, adicionando erros que encontram para evitar repetição. Cada membro da equipe tem responsabilidade por manter um arquivo específico, e em aplicativos full stack, cada microsserviço pode ter seu próprio Claude.md. O próprio arquivo de Boris tem cerca de 2.5K tokens, e ele alerta para não sobrecarregá-lo.

Modos de Operação e Gerenciamento de Permissões

Boris discute os diferentes modos do Claude Code: modo de planejamento, modo de auto-aceitação de edições e modo de pular permissões perigosamente. Ele nunca usa o último, especialmente em ambientes de produção, onde um único comando pode bagunçar o projeto inteiro. Em vez disso, usa as permissões do Claude Code para configurar quais comandos são permitidos, quais requerem aprovação e quais são completamente negados. Essas configurações podem ser definidas no arquivo settings.json dentro da pasta .Claude e compartilhadas com a equipe. Essa abordagem oferece controle granular sobre as ações do Claude sem comprometer a segurança do projeto.

Claude Code como Orquestrador Universal

Boris argumenta que Claude Code foi mal nomeado porque não serve apenas para código - é um sistema completo para controlar fluxos de trabalho diversos. Ele usa Claude Code para integrar todas as suas outras ferramentas através de servidores MCP, incluindo Slack, BigQuery e Sentry via suas CLIs. Isso demonstra que o Claude Code funciona como orquestrador de múltiplas ferramentas e processos. O exemplo pessoal do narrador mostra integração com Notion via MCP, onde o Claude cria bancos de dados, preenche dados e entende o contexto de ideias de vídeos. Essa capacidade de orquestração transforma o Claude Code em uma ferramenta central para gerenciar ecossistemas inteiros de trabalho.

Fluxo de Trabalho com Planejamento e Execução em Escala

Antes de implementar qualquer recurso, Boris sempre muda para o modo de planejamento e descreve claramente o que quer, fazendo toda a ida e vinda durante essa fase. Só inicia o agente após verificar que o plano é válido, usando modo de auto-aceitação (não o perigoso). Para escalar, ele executa cinco sessões do Claude Code em paralelo, numerando suas abas para identificar de onde vêm as notificações. Também usa muito as sessões web do Claude Code conectadas ao GitHub, permitindo trabalho em repositórios demo na nuvem. O recurso de agentes em segundo plano permite colocar tarefas longas no background, e ele às vezes usa no celular, onde o Claude trabalha automaticamente e cria branches com as mudanças para revisão. O comando teleport traz sessões da nuvem de volta ao terminal local.

Escolha do Modelo e Ação do GitHub

Boris usa Opus 4.5 com pensamento ativado para praticamente tudo, argumentando que embora seja mais lento que Sonnet e significativamente mais lento que Haiku, tem chance muito menor de cometer erros. Como resultado, o tempo total gasto trabalhando com o modelo é menor com Opus 4.5 devido à redução de retrabalho. Ele também usa a ação do GitHub Claude Code, um bot que pode ser chamado dentro de repositórios autorizados. Um caso de uso forte é durante revisões de PR: sempre que encontra erros, ele pede ao Claude para adicionar esses erros ao arquivo Claude.md, criando um ciclo de melhoria contínua.

Abordagens para Tarefas de Longa Duração

Boris usa três abordagens para tarefas longas. Primeira: pedir ao Claude para criar testes de verificação e colocar tarefas em segundo plano (não agentes em nuvem, mas tarefas que executam silenciosamente e relatam ao agente principal). Segunda: usar um gancho de parada para acionar verificação automaticamente quando o Claude para de produzir resultados. Terceira: usar o plugin Ralph Wiggum, que remove o humano do processo completamente ao testar automaticamente se a UI está correta durante o desenvolvimento. Repetindo o padrão de verificação, ele também usa linters e formatadores para verificar o formato do código em várias linguagens. Embora os modelos gerem código correto, esses formatadores limpam os 10% restantes, evitando erros nos pipelines de CI do GitHub.

Funcionalidades Simples e Fluxos de Trabalho do Ciclo Interno

Boris enfatiza que funcionalidades simples integradas no Claude Code proporcionam cerca de 90% da produtividade desejada, sem necessidade de complicar demais. Ele se refere a fluxos de trabalho repetitivos como 'ciclo interno' - coisas repetidas muitas vezes por dia. Os /comandos são essenciais para isso, armazenados na pasta .claud/comandos e podendo ser commitados no git para compartilhamento com a equipe. Subagentes são outra funcionalidade poderosa: embora pessoas construam subagentes para casos de uso diversos (pesquisadores de mercado, validadores de produtos), Boris os usa para automatizar fluxos simples com instruções diferentes, como verificar arquitetura de código, refatorar código escrito e validar se compilações finais funcionam corretamente.

Promoção da Automata e Encerramento

O vídeo encerra com uma promoção da Automata, a empresa do narrador que implementa fluxos de trabalho de IA em produtos reais. Eles se posicionam como copiloto técnico para pessoas com ideias mas sem equipe técnica para construí-las, aplicando os mesmos fluxos de trabalho ensinados no canal diretamente aos projetos dos clientes. Transformam conceitos em soluções funcionais sem as dificuldades de contratar ou gerenciar equipe de desenvolvimento. O contato é hello@automata.dev. O narrador agradece os espectadores e menciona o botão 'super obrigado' para apoiar o canal e continuar produzindo conteúdo similar.

Community Posts

View all posts