Sua configuração do claude.md está deixando sua codificação com IA 99% mais lenta
AAI LABS
컴퓨터/소프트웨어경영/리더십AI/미래기술
Transcript
00:00:00Um único arquivo decide se o produto que você recebe é realmente a implementação correta
00:00:04que você precisava.
00:00:05Para usuários do Claude Code, esse arquivo é o claud.md, e outros têm seus próprios arquivos, mas o mais comum
00:00:10é usarem o agents.md.
00:00:11Mas não importa qual você esteja usando, a menos que o configure corretamente, você continuará lutando contra o seu
00:00:15agente em cada tarefa.
00:00:17E se você acha que executar um simples comando de inicialização é o bastante, você está na verdade
00:00:20enganado.
00:00:21Você precisa seguir um padrão estruturado adaptado ao projeto que realmente faça seu agente
00:00:26ter um desempenho melhor.
00:00:27Por esse motivo, compilamos as melhores práticas que você precisa seguir, vindas de outras fontes confiáveis
00:00:31bem como da nossa própria experiência de horas com o Claude Code, para que você possa aplicá-las diretamente
00:00:35ao seu fluxo de trabalho.
00:00:36E a última é importante porque determina como seu agente realmente segue suas instruções
00:00:41e, se não for seguida, as outras instruções no seu arquivo não serão tão impactantes.
00:00:45A primeira coisa que você precisa adicionar ao seu arquivo claud.md é algo que vem diretamente
00:00:49do repositório de habilidades de Andrej Karpathy, que contém os melhores padrões de claud.md sobre os quais ele fala.
00:00:54Você precisa adicionar uma instrução explícita para o Claude pensar antes de codificar.
00:00:58Isso faz com que o Claude declare as suposições explicitamente.
00:01:01Se existirem múltiplas interpretações, ele deve apresentar todas, para que possamos decidir a partir
00:01:05do conjunto de implementações.
00:01:07Isso força o Claude a pensar a partir de uma perspectiva diferente antes de realmente mergulhar na
00:01:11solução.
00:01:12Isso garante que a solução implementada esteja alinhada com o que você queria.
00:01:15Essa linha corta uma enorme quantidade de correções de curso do nosso fluxo de trabalho, e é por isso que a achamos
00:01:20tão útil.
00:01:21Com essa instrução adicionada, sempre que você pedir ao Claude para implementar um recurso, ele basicamente
00:01:25fará um conjunto de perguntas relacionadas à tarefa que você deu, para que suas respostas o guiem
00:01:29sobre como realmente realizar a tarefa.
00:01:31Essa parte, em particular, será útil porque agora o Claude não vai adivinhar as implementações
00:01:35e mergulhar de cabeça no que ele memorizou a partir dos dados de treinamento.
00:01:39Ele pensará profundamente sobre qual é a implementação correta e confirmará com você se essa é
00:01:43a implementação pretendida e, então, trabalhará no recurso em vez de apenas adivinhá-lo
00:01:48e você ter que interromper o Claude porque ele não seguiu as implementações corretas
00:01:52que você tinha em mente, o que ocorre com muita frequência e exige que você corrija o rumo
00:01:56bastante.
00:01:57A próxima regra é escolher a simplicidade primeiro.
00:01:59É algo tão simples, mas que ainda precisa ser declarado especificamente no claud.md para que
00:02:04o agente seja devidamente lembrado desse princípio.
00:02:07O Claude, ou qualquer outro agente, tende a escrever soluções grandes para problemas que podem ser resolvidos com
00:02:11soluções simples.
00:02:12Mas isso não é problemático apenas porque causa atrasos.
00:02:15Também torna difícil refatorar o código mais tarde e ainda mais difícil adicionar recursos, porque
00:02:19a implementação é tão verbosa que consome muitos tokens para implementar coisas simples.
00:02:24Portanto, essa linha literalmente força o Claude a iterar em direção à simplicidade.
00:02:27Também adicionamos isso em todos os projetos, especialmente ao trabalhar em aplicativos de grande escala, porque
00:02:32nessa escala, fazer isso se torna mais importante.
00:02:35Isso diz especificamente ao Claude para não adicionar nenhum recurso além do que foi solicitado e para garantir
00:02:39um tratamento de erro adequado para a implementação.
00:02:41A estrutura disciplinada ao redor disso é basicamente um limite rígido.
00:02:44Se a solução para qualquer problema que você pedir puder ser tratada em 200 linhas e puder ser refatorada
00:02:49para 50, então o Claude precisa reescrever a solução porque sua abordagem está errada.
00:02:54Isso impedirá que o Claude escreva um monte de código inútil com coisas
00:02:58que nem são implementáveis e que refletem o sentido errado de direção que o Claude selecionou.
00:03:03A terceira parte do claud.md é implementar mudanças cirúrgicas ou, em palavras simples, tocar
00:03:08apenas naquelas partes que o agente deve absolutamente tocar.
00:03:11Isso resolve algo que enfrentamos muito quando o Claude escreve uma grande quantidade de código de
00:03:15uma vez só, e a correção precisa ser explicitamente declarada no arquivo claud.md.
00:03:19O Claude, ou agentes em geral, quando solicitados a fazer uma tarefa, tendem a tentar melhorar as coisas
00:03:24ao redor dessa tarefa também.
00:03:25Essas melhorias podem parecer mudanças de código adjacentes ou formatação da base de código, nas quais
00:03:29não queremos que ele foque no momento.
00:03:32Mas isso é irritante porque a atenção do Claude fica dividida entre as várias coisas que ele está
00:03:36tentando implementar ao mesmo tempo.
00:03:37Definir esse tipo de mudança não é bom porque o Claude está basicamente incluindo coisas
00:03:41que não queríamos que ele fizesse agora.
00:03:43Então, precisamos declarar as instruções explicitamente no claud.md para que ele não faça isso.
00:03:47Se o agente notar qualquer código morto não relacionado, ele deve mencioná-lo em vez de corrigi-lo sozinho.
00:03:52Às vezes, esse tipo de coisa está lá por razões específicas que devem ser abordadas mais tarde,
00:03:56não no estágio em que o aplicativo está atualmente.
00:03:58A estrutura mental que permite ao Claude decidir como agir corretamente é verificar cada mudança
00:04:03e ver se ela realmente remete ao que o usuário pediu.
00:04:06Se for o caso, ele deve fazer essa mudança.
00:04:08Se não, ele não deve tocar nesse recurso.
00:04:10Se essa linha for adicionada, sempre que o Claude tiver qualquer problema na implementação, ele basicamente
00:04:14mudará apenas a coisa que o usuário pediu para consertar.
00:04:17Portanto, ele dirá a você todos os outros problemas que encontrou no mesmo arquivo e você poderá decidir
00:04:21a partir daí se realmente quer que ele corrija esses ou não.
00:04:24O último padrão extraído de Andrej Karpathy é a execução orientada a objetivos.
00:04:29Os agentes não sabem como é a saída correta, o que é o problema central.
00:04:33Eles trabalhariam de forma muito mais eficaz se soubessem, e é isso que essa regra corrige.
00:04:36No arquivo claud.md, precisamos dizer explicitamente ao Claude para definir os critérios de sucesso
00:04:41para cada tarefa que lhe damos.
00:04:43Portanto, para qualquer tarefa que entregarmos, o Claude precisa convertê-la em um objetivo verificável.
00:04:47Por exemplo, se você der a tarefa de adicionar validação, ele escreverá testes para as entradas inválidas
00:04:52e garantirá que esses casos de teste realmente passem com os valores de retorno certos para as entradas certas.
00:04:57Então, toda a ideia é fazer com que o agente implemente casos de teste e, em seguida, itere até que todos os casos de teste
00:05:01passem e, no final, o projeto tenha o mesmo comportamento que realmente precisamos dele.
00:05:06Se você lhe der qualquer prompt sobre uma tarefa, ele definirá o objetivo verificável e planejará a implementação.
00:05:11Então, ele verificará o trabalho para você adicionando todos os casos de teste e mostrando como
00:05:15lidará com todo o aplicativo, em essência.
00:05:17Agora, isso pode funcionar para raciocínio lógico, mas se você quiser que o agente verifique como a sua
00:05:21interface (UI) parece, o agente não pode escrever casos de teste para isso.
00:05:23Então, para isso, você pode adicionar a extensão Claude Chrome ou Puppeteer MCP para que ele possa verificar
00:05:28como a UI parece usando essas ferramentas.
00:05:30Isso ajuda porque mudanças na UI são difíceis de julgar olhando apenas para o código, e dar ao
00:05:35agente uma maneira verificável de deixá-lo ver o visual atual do aplicativo e, usando isso, ele pode corrigir
00:05:40os problemas.
00:05:41Portanto, você pode adicionar explicitamente uma linha para que ele saiba que, após a implementação da UI, ele
00:05:45também precisa verificar o resultado por meio do MCP.
00:05:48Se você criou um arquivo claud.md usando o próprio comando de inicialização do Claude Code, veria que
00:05:53ele adiciona comandos para rodar o servidor de desenvolvimento e o servidor de build.
00:05:57Mas esses já estão em seus dados de treinamento e o Claude já conhece esses comandos e
00:06:01não precisamos desperdiçar linhas explicitamente no claud.md dizendo a ele o que ele já sabe.
00:06:05Portanto, em seu arquivo, você só precisa mencionar as ferramentas que deseja que o Claude use, em vez das
00:06:09aquelas que ele usa por padrão.
00:06:11Existem certas ferramentas de CLI que tornam o fluxo de trabalho mais rápido, mas não estão nos dados de treinamento padrão do Claude
00:06:16ou nos padrões nos quais ele já confia.
00:06:18Portanto, você precisa adicioná-las explicitamente para que o Claude saiba que essas ferramentas estão instaladas
00:06:22e não recorra ao que ele usa por conta própria o tempo todo.
00:06:26Por exemplo, se você instalou o CLI do GitHub em vez de usar o git para trabalhar, você pode
00:06:30adicionar uma instrução no claud.md para usar o CLI dele em vez dos comandos git padrão para todas
00:06:36as operações.
00:06:37Da mesma forma, você pode adicionar mais comandos que não são os padrão.
00:06:41Você também precisa adicionar as instruções de execução para o projeto neste arquivo, se elas forem diferentes
00:06:45das usuais.
00:06:46Por exemplo, a maioria dos projetos na configuração padrão são executados por npm, e se seu projeto roda com
00:06:51pnpm, você precisa adicionar essa informação para que o agente saiba quais comandos devem ser
00:06:56executados.
00:06:57Qualquer outra coisa além dos comandos que o Claude já conhece não deve ser incluída no arquivo claud.md
00:07:01arquivo.
00:07:02A próxima menção no claud.md é inspirada no criador do Claude Code e no fluxo de trabalho
00:07:07que ele revelou.
00:07:08Ele falou sobre como claud.md não é um arquivo para escrever uma vez e usar para sempre.
00:07:12É algo que precisa ser constantemente alterado, atualizado e melhorado ao longo do processo
00:07:16de construção, como um processo contínuo que precisa ser iterado repetidamente.
00:07:20Portanto, você precisa adicionar uma instrução de que, se o Claude tivesse que ser avisado pelo usuário que sua implementação
00:07:25não estava correta, ele deveria primeiro aplicar as correções conforme apontado pelo usuário.
00:07:29Uma vez que o Claude tenha aplicado essas correções, ele também deve adicionar esses aprendizados a um arquivo dedicado
00:07:33para que o Claude possa construir gradualmente uma base de conhecimento do que não deve fazer e de qual é a
00:07:38maneira correta de fazer as coisas, a qual ele pode consultar mais tarde, conforme necessário.
00:07:42Mas antes de avançarmos, vamos ter uma palavra do nosso patrocinador.
00:07:45Klaus, você provavelmente já ouviu falar de agentes de IA.
00:07:47Talvez você tenha tentado configurar um sozinho; 15 minutos depois, você está olhando para um terminal
00:07:51colando chaves de API em arquivos de configuração, perguntando-se se acabou de vazar algo importante.
00:07:56Klaus pula tudo isso.
00:07:57Klaus roda o OpenClaw, o agente de IA de código aberto na nuvem.
00:08:00Você se inscreve, ganha US$ 15 em créditos do OpenRouter e começa a fazer prompts.
00:08:04Sem terminal, sem docker, sem caça ao tesouro de chave de API.
00:08:07Eu testei pedindo ao Klaus para extrair um diretório de startups, organizar os resultados em uma tabela
00:08:12e enviar por e-mail para mim.
00:08:13Um prompt na janela de chat, pronto.
00:08:15Sem código, sem extensões de navegador.
00:08:17Ele vem com ferramentas integradas como Exa e Apollo e se conecta ao Slack, WhatsApp, até mesmo
00:08:21ao iMessage.
00:08:22Tudo roda em uma máquina protegida por firewall, completamente isolada das suas contas pessoais.
00:08:27Se algo quebrar, o agente de autocorreção deles, o Clawbert, corrige sem você tocar em nada.
00:08:31Clique no link no comentário fixado e experimente o Klaus gratuitamente.
00:08:35Como a maioria dos projetos de codificação são gerenciados pelo Git, você precisa adicionar explicitamente uma instrução
00:08:39no claud.md de que o Claude não deve executar comandos irreversíveis sem confirmação.
00:08:44E se houver necessidade de executar tal comando, o agente deve pedir permissão primeiro.
00:08:48Esses comandos são perigosos porque, uma vez executados, as consequências são irreversíveis
00:08:53e podem causar danos à produção.
00:08:55Coisas como forçar push, redefinir a cabeça (reset head), mesclar ramos (branches) ou executar remoção forçada
00:09:00comandos.
00:09:01Você também precisa adicionar uma instrução de que, se o Claude não tiver certeza se um comando é destrutivo
00:09:04ou não, ele deve perguntar em vez de presumir.
00:09:07Isso vai te poupar muitos problemas.
00:09:08Por exemplo, se o Claude tentar acidentalmente mesclar um branch que você não quer que ele mescle,
00:09:12ele pedirá permissão antes de fazer isso, e você pode negar para que seu trabalho
00:09:16permaneça seguro.
00:09:17Não há necessidade de colocar todos os aspectos de informação em um único arquivo claud.md, porque isso vai
00:09:22apenas inflá-lo desnecessariamente e distrair o agente do que ele realmente precisa fazer.
00:09:27Portanto, você precisa criar arquivos de regra com escopo de caminho que declarem seu escopo na primeira linha
00:09:31e contenham instruções adaptadas exatamente para esses arquivos.
00:09:34Você também precisa mencionar a localização desses arquivos no claud.md para que o Claude saiba que eles existem.
00:09:40Por exemplo, se você quiser que o Claude siga certas instruções específicas ao escrever APIs, você
00:09:44pode adicioná-las em um arquivo de regra para elas, de modo que quando o Claude estiver trabalhando nelas, ele possa carregar
00:09:48essas instruções e usá-las diretamente.
00:09:50Mas, tão importante quanto, isso também garante que as instruções relacionadas à API não interfiram
00:09:55quando o Claude não estiver trabalhando nelas.
00:09:56Você pode ter vários arquivos de regra para diferentes partes do projeto, cada um contendo instruções
00:10:00adaptadas a essa área específica.
00:10:02Dessa forma, o Claude só carrega as instruções relevantes quando está trabalhando nessa parte.
00:10:06Portanto, evita inchaço de contexto e mantém o agente focado na tarefa atual em vez de
00:10:11ser distraído por regras não relacionadas.
00:10:13A maioria dos aplicativos de grande escala está em um mono repo, que é um único grande repositório onde
00:10:18todos os diferentes componentes são mantidos juntos, com cada pasta agindo como uma parte separada
00:10:22por si mesma, e cada parte sendo gerenciada de forma independente enquanto contribui para um aspecto diferente do
00:10:27aplicativo principal.
00:10:28Então, se você estiver executando um projeto a partir de um mono repo, você precisa ter certeza de que cada sub
00:10:32repo contenha seu próprio arquivo claud.md, para que contenha instruções específicas
00:10:37para ele e não precise confiar apenas nas instruções do claud.md global.
00:10:42O arquivo global deve consistir apenas em instruções que são amplamente aplicáveis a todas as partes do
00:10:47sistema.
00:10:48Mas arquivos claud.md com escopo funcionam melhor porque podem conter instruções que são específicas
00:10:52para aquele aplicativo ou módulo em particular.
00:10:54Isso permite que o agente tenha um desempenho melhor porque terá uma orientação mais focada.
00:10:58Portanto, colocar todas as instruções de grandes projetos no arquivo principal é o movimento errado.
00:11:02Isso vai inflar o arquivo com informações e, quando o Claude passar por áreas com instruções
00:11:07que não dizem respeito à tarefa atual, pode fazer com que sua atenção divirja do que
00:11:11ele realmente precisa fazer.
00:11:12Além disso, se você estiver gostando do nosso conteúdo, considere pressionar o botão de curtir, porque ele nos ajuda a
00:11:16criar mais conteúdo como este e alcançar mais pessoas.
00:11:19Você também precisa adicionar a descrição do projeto no seu arquivo claud.md e garantir que essa
00:11:24instrução seja colocada bem no início dele, não enterrada dentro do resto das
00:11:29instruções.
00:11:30Porque o agente entende o essencial sobre o que o aplicativo trata ao lê-lo primeiro.
00:11:33Então, ele entende o contexto de como o aplicativo é estruturado, o que ele faz em geral, quais
00:11:38são os diferentes serviços e dependências e como o aplicativo roda.
00:11:41Dessa forma, ele sabe desde o início, em vez de olhar para o código para deduzir o que o
00:11:45aplicativo faz.
00:11:46Outra seção que precisamos adicionar no seu arquivo claud.md é que o Claude precisa verificar
00:11:50não apenas que o recurso existe, mas também que ele funciona corretamente conforme pretendido antes de relatar
00:11:55qualquer tarefa como concluída.
00:11:57Ele deve usar todos os mecanismos de verificação disponíveis para confirmar que a compilação e os testes passam corretamente,
00:12:02mas o ponto desta seção é garantir que a tarefa esteja realmente concluída usando etapas reais
00:12:07de verificação, não apenas verificando se o código para o recurso existe.
00:12:11Portanto, essa instrução força o Claude a relatar com mais fidelidade e a usar vários
00:12:15tipos de verificações, como testes unitários, linting e verificações de tipo, para garantir que o aplicativo seja implementado
00:12:20corretamente e funcione conforme o pretendido.
00:12:23Por último, mas não menos importante, a maneira como você ordena suas instruções no arquivo claud.md também é
00:12:27muito importante para garantir um alto desempenho do agente.
00:12:29Você precisa ordená-las por prioridade.
00:12:31As primeiras instruções devem ser regras rígidas, o que significa sempre inegociáveis, sem exceções
00:12:36de forma alguma.
00:12:37Essas regras rígidas devem sempre vir primeiro, antes de quaisquer outras regras.
00:12:40Então vêm as regras de média prioridade, que não são tão rigorosas quanto as anteriores.
00:12:44Elas são um tanto negociáveis, mas ainda importantes e não devem ser violadas.
00:12:48Depois disso, vêm as instruções de baixa prioridade, que incluem principalmente referências e conveniências,
00:12:52para que o agente não precise voltar e usar esta seção como fonte principal de decisão.
00:12:57Mais uma coisa importante é que você precisa ter certeza de que o arquivo claud.md seja mantido curto.
00:13:01Uma boa prática é mantê-lo sob um limite rígido de 300 linhas, que é considerado ideal
00:13:06para o desempenho do agente.
00:13:07Mas quando fica mais longo que isso, o desempenho começa a degradar.
00:13:10O arquivo claud.md mencionado aqui e todos os outros recursos aqui mencionados estão disponíveis
00:13:15no AI Labs Pro para este vídeo e para todos os nossos vídeos anteriores, de onde você pode baixar
00:13:20e usar para seus próprios projetos.
00:13:21Se você encontrou valor no que fazemos e deseja apoiar o canal, essa é a melhor maneira
00:13:25de fazê-lo.
00:13:26O link está na descrição.
00:13:27Isso nos leva ao fim deste vídeo.
00:13:29Se você gostaria de apoiar o canal e nos ajudar a continuar fazendo vídeos como este, você pode fazer
00:13:33isso usando o botão de super obrigado abaixo.
00:13:35Como sempre, obrigado por assistir e vejo você no próximo.