Agentes em Cluster São Ótimos... Os Workflows de IA para Coding Acabaram Agora

AAI LABS
Computing/SoftwareInternet Technology

Transcript

00:00:00Os desenvolvedores do Claude Code anunciaram silenciosamente atualizações massivas que quase ninguém está comentando.
00:00:05A maior delas é o lançamento de agentes assíncronos em segundo plano.
00:00:09O estranho é que você não vai encontrar esses recursos mencionados em lugar nenhum no site principal da Anthropic ou até no blog deles.
00:00:15Agora você pode estar se perguntando se esses recursos são realmente úteis,
00:00:18e honestamente eu também não tinha certeza no começo,
00:00:20mas descobri um ângulo inesperado que mudou completamente como os uso.
00:00:23Então neste vídeo,
00:00:24vou explicar exatamente o que é,
00:00:26por que torna a maioria dos frameworks de codificação IA desnecessários,
00:00:30e depois vou mostrar vários outros recursos do Claude.
00:00:33Eles anunciaram esses novos recursos nos changelogs no repositório GitHub do Claude Code.
00:00:37Mencionaram que esses agentes e comandos bash podem ser executados de forma assíncrona e enviar mensagens para despertar o agente principal.
00:00:43A ideia aqui é alcançar um trabalho genuinamente paralelo.
00:00:46É bem simples usá-los.
00:00:48Primeiro pedimos ao Claude para lidar com uma tarefa que se beneficia de um subagentte,
00:00:52e então o agente principal cria um subagentte para a tarefa.
00:00:55Quando o agente começar a ser executado,
00:00:57movemos para segundo plano usando Ctrl+B e continuamos trabalhando com o agente principal em outras tarefas.
00:01:02Quando o subagentte concluir a tarefa,
00:01:04ele desperta o agente principal com os resultados.
00:01:06Também podemos verificar nossos agentes em execução usando o comando tasks.
00:01:10Por baixo dos panos,
00:01:11o agente de segundo plano funciona como um processo separado capaz de executar tarefas complexas de múltiplas etapas de forma autônoma,
00:01:17ou seja,
00:01:18pode lidar independentemente com tarefas em larga escala.
00:01:21Eles permitem que você continue interagindo com a thread principal do Claude Code sem bloquear a execução deles,
00:01:26então você pode usar seu tempo efetivamente em vez de esperar.
00:01:28Quando terminam a execução,
00:01:29eles relatam os resultados de volta para o agente principal.
00:01:32Anteriormente,
00:01:33você tinha que abrir múltiplos terminais com instâncias separadas do Claude para isso.
00:01:37Agora o Claude faz isso sozinho,
00:01:39gerenciando agentes em segundo plano internamente,
00:01:41coordenando múltiplos agentes e integrando os resultados por conta própria,
00:01:45sem a configuração manual que usávamos antes.
00:01:47Segundo eles,
00:01:48agentes em segundo plano são ideais para pesquisar enquanto codifica,
00:01:51revisar fluxos de trabalho,
00:01:52executar tarefas paralelas e lidar com qualquer tarefa que não deveria poluir sua janela de contexto principal.
00:01:57Antes de discutirmos se esses agentes realmente nos economizam tempo,
00:02:00vamos fazer uma pausa rápida para falar sobre Automata.
00:02:02Depois de ensinar milhões de pessoas como construir com IA,
00:02:05começamos a implementar esses fluxos de trabalho nós mesmos.
00:02:08Descobrimos que poderíamos construir produtos melhores,
00:02:10mais rápido do que nunca.
00:02:11Ajudamos a transformar suas ideias em realidade,
00:02:13sejam aplicativos ou sites.
00:02:14Talvez você tenha assistido nossos vídeos pensando: 'Tenho uma ótima ideia,
00:02:17mas não tenho um time técnico para construí-la.' É exatamente aí que entramos.
00:02:21Pense em nós como seu co-piloto técnico.
00:02:23Aplicamos os mesmos fluxos de trabalho que ensinamos para milhões diretamente ao seu projeto,
00:02:27transformando conceitos em soluções reais e funcionais sem as dores de cabeça de contratar ou gerenciar um time de desenvolvimento.
00:02:33Pronto para acelerar sua ideia até virar realidade?
00:02:36Fale conosco em hello@automata.dev.
00:02:38Então testei o que eles sugeriram,
00:02:40e com o tempo que passei com eles até agora,
00:02:42realmente gosto do que estou vendo.
00:02:44Acho que esses agentes têm muito potencial.
00:02:46Esses agentes em segundo plano podem lidar com qualquer tarefa de pesquisa que leva muito tempo ou pode inchar sua janela de contexto.
00:02:52Você pode simplesmente mover essa pesquisa para segundo plano e atribuir uma tarefa separada ao agente principal.
00:02:57Isso permite que o agente principal trabalhe em algo completamente diferente enquanto permanece totalmente isolado da tarefa de pesquisa.
00:03:04Esses agentes facilitam muito a implementação de mudanças em páginas separadas ao mesmo tempo ao paralelizar tarefas.
00:03:10Em vez de esperar um agente lidar com tudo sequencialmente,
00:03:13você pode atualizá-los simultaneamente.
00:03:15Por exemplo,
00:03:15se você está mudando todos seus componentes para uma nova biblioteca,
00:03:18pode usar agentes em segundo plano para atualizá-los todos de uma vez.
00:03:21Além disso,
00:03:22você frequentemente se vê com tarefas como revisões que consomem muito tempo.
00:03:26Você pode usar agentes assíncronos para lançar vários deles simultaneamente,
00:03:29um para revisão de segurança,
00:03:31um para identificar gargalos de desempenho,
00:03:33um para refatorar código e outro para verificar duplicações ou código não utilizado.
00:03:37Você pode executar todas essas tarefas em segundo plano enquanto seu agente principal fica focado em uma atualização de recurso completamente diferente.
00:03:43Dessa forma,
00:03:44cada agente trabalha separadamente e gerencia sua própria tarefa independentemente dos outros.
00:03:49Agora aqui está o ângulo inesperado que mencionei antes.
00:03:51Você pode até equipar agentes em segundo plano com a capacidade de gerenciar seu trabalho em uma árvore de trabalho do Git,
00:03:56permitindo que eles façam commit e push de mudanças isoladamente.
00:03:59Alguns de vocês talvez já tenham pensado nisso,
00:04:01mas para quem não sabe,
00:04:02árvores de trabalho do Git são um recurso extremamente subutilizado que permite trabalhar em múltiplas branches em diretórios separados.
00:04:09Isso significa que você pode evitar constantes trocas de branch em um único workspace e simplesmente gerar quantos agentes quiser para quantos recursos quiser.
00:04:16Para usar esse fluxo de trabalho,
00:04:17configurei um comando slash personalizado que cria um agente em segundo plano para trabalhar em tarefas em árvores de trabalho separadas.
00:04:23Todas as instruções para este comando estão direto na pasta commands,
00:04:26que você pode encontrar dentro da pasta .claud.
00:04:29Digamos que estou trabalhando em um aplicativo,
00:04:30mas não estou feliz com o tema.
00:04:32Tenho 3 ideias diferentes de tema,
00:04:34e quero implementar todas elas para ver qual fica melhor.
00:04:37Sem árvores de trabalho,
00:04:38eu teria que clonar o repositório separadamente,
00:04:40criar 3 branches diferentes ou abrir instâncias separadas do .claud apenas para manter as tarefas apartadas,
00:04:45mas com agentes em segundo plano,
00:04:47tudo isso muda.
00:04:47Os 3 agentes trabalharam em paralelo para implementar esses temas separadamente,
00:04:51tudo isso deixando meu design principal completamente intacto.
00:04:54Isso me permite simplesmente fazer merge do tema que gosto no projeto principal e descartar os outros.
00:04:59Isso tornou o processo de implementação significativamente mais rápido.
00:05:02Como todas as mudanças estão isoladas,
00:05:04posso escolher o tema que mais gosto entre as diferentes opções.
00:05:08Isso me dá a liberdade de experimentar e executar sem me preocupar em quebrar o design principal ou ter que reverter mudanças indesejadas.
00:05:15Nos changelogs,
00:05:16eles anunciaram alguns outros recursos realmente legais,
00:05:19e um pelo qual sou particularmente grato é o Instant Autocompact.
00:05:23A compactação costumava levar uns 2-3 minutos,
00:05:25mas agora acontece significativamente mais rápido porque provavelmente está mantendo históricos para cada projeto direto na pasta .claud.
00:05:32Claude Code também adicionou um recurso de sugestão de prompt onde você pode simplesmente pressionar enter para aceitar uma sugestão ou apenas digitar um novo prompt no lugar dela.
00:05:39Você pode usar a flag agent ao iniciar o Claude para executá-lo como o agente específico que você tem no seu projeto,
00:05:45permitindo que você delegue tarefas para ele diretamente.
00:05:47Claude Code agora permite que você fork de sessões e escolha entre elas quando lança o Claude com a flag resume.
00:05:53Tudo que você precisa fazer é pressionar a tecla escape duas vezes,
00:05:56e sua sessão atual será feita fork.
00:05:57Agora,
00:05:58mesmo que agentes em segundo plano sejam ótimos,
00:06:00existem certas áreas onde você não deveria usá-los,
00:06:02pois vão prejudicar seu fluxo de trabalho em vez de melhorá-lo.
00:06:05Por exemplo,
00:06:06você não quer colocar em segundo plano nenhuma tarefa que exija sua entrada,
00:06:09pois isso faria o agente ficar bloqueado e incapaz de prosseguir.
00:06:13Você também não quer colocar em segundo plano nenhuma tarefa que exija sua aprovação enquanto está sendo executada.
00:06:17Ela apenas ficaria bloqueada em segundo plano e você poderia realmente perder o controle dela se o agente principal estiver ocupado com outra tarefa.
00:06:23Também é altamente recomendado não atribuir tarefas que dependem uma da outra,
00:06:27pois isso pode criar conflitos no trabalho de seus agentes.
00:06:30Em vez disso,
00:06:30é muito melhor atribuir tarefas isoladas para cada agente.
00:06:34Existem algumas boas práticas que você precisa manter em mente para aproveitar ao máximo esse fluxo de trabalho.
00:06:38Ao usar agentes em segundo plano,
00:06:39você precisa manter em mente o uso de tokens.
00:06:41Mesmo que acelerem seu trabalho,
00:06:43cada agente consome um número significativo de tokens,
00:06:46então é importante rastrear isso se você quer evitar contas altas.
00:06:49Como agentes retornam sua saída para o agente principal,
00:06:51você tem que se certificar de que suas tarefas estão isoladas.
00:06:54Também,
00:06:55quando você está gerando um agente,
00:06:56dê um nome descritivo.
00:06:57Dessa forma,
00:06:58se você está gerenciando múltiplos agentes ao mesmo tempo,
00:07:00você saberá exatamente o que cada um está fazendo.
00:07:02Isso nos leva ao final deste vídeo.
00:07:04Se você quer apoiar o canal e nos ajudar a continuar fazendo vídeos como este,
00:07:08você pode fazer isso usando o botão super thanks abaixo.
00:07:10Como sempre, obrigado por assistir e até o próximo vídeo.

Key Takeaway

Agentes assíncronos em segundo plano do Claude Code revolucionam o desenvolvimento paralelo ao permitir trabalho genuinamente simultâneo isolado, eliminando frameworks de IA de coding anteriormente necessários.

Highlights

Agentes assíncronos em segundo plano do Claude Code permitem trabalho genuinamente paralelo sem usar múltiplas instâncias do aplicativo

Integração com Git worktrees permite que agentes trabalhem em branches separadas simultaneamente, isolando completamente as mudanças

O recurso Instant Autocompact foi otimizado para ser significativamente mais rápido, melhorando a performance geral

Agentes em segundo plano facilitam tarefas de pesquisa, revisão paralela e testes de múltiplas implementações sem bloquear o agente principal

Importante evitar colocar em segundo plano tarefas que exigem entrada do usuário, aprovação ou dependências entre elas

Cada agente em segundo plano consome tokens significativos, exigindo rastreamento cuidadoso para evitar custos elevados

O novo sistema elimina a necessidade de abrir múltiplos terminais ou instâncias separadas do Claude para trabalhar em paralelo

Timeline

Introdução aos Agentes Assíncronos em Segundo Plano

O vídeo apresenta atualizações massivas do Claude Code anunciadas silenciosamente no repositório GitHub, com a maior sendo o lançamento de agentes assíncronos em segundo plano. O apresentador destaca que esses recursos não foram publicados no site principal da Anthropic ou em seu blog oficial. Ele explica que inicialmente tinha dúvidas sobre a utilidade desses recursos, mas descobriu um ângulo inesperado que transformou completamente seu fluxo de trabalho. O vídeo promete explicar o que são esses agentes, por que tornam a maioria dos frameworks de codificação IA desnecessários, e demonstrar outros recursos do Claude Code. A ideia principal é alcançar trabalho genuinamente paralelo, permitindo que agentes e comandos bash sejam executados de forma assíncrona e enviem mensagens para despertar o agente principal.

Como Utilizar Agentes em Segundo Plano

O apresentador explica o funcionamento prático dos agentes em segundo plano, começando com um pedido simples ao Claude para delegar uma tarefa a um subagentte. O agente principal cria esse subagentte para a tarefa específica, e enquanto ele se executa, você pode mover para segundo plano usando Ctrl+B e continuar trabalhando com o agente principal em outras tarefas simultâneas. Quando o subagentte conclui sua tarefa, ele desperta o agente principal com os resultados obtidos. É possível verificar agentes em execução usando o comando tasks. Por trás dos panos, o agente em segundo plano funciona como um processo separado capaz de executar tarefas complexas de múltiplas etapas de forma autônoma, permitindo lidar independentemente com tarefas em larga escala sem bloquear a thread principal do Claude Code.

Vantagens em Relação ao Fluxo de Trabalho Anterior

Antes dessa atualização, para trabalhar em paralelo era necessário abrir múltiplos terminais com instâncias separadas do Claude, um processo manual e tedioso. Agora, o Claude gerencia agentes em segundo plano internamente, coordenando múltiplos agentes e integrando resultados automaticamente, sem necessidade de configuração manual prévia. Segundo os desenvolvedores, agentes em segundo plano são ideais para pesquisar enquanto codifica, revisar fluxos de trabalho, executar tarefas paralelas e lidar com qualquer tarefa que não deveria poluir a janela de contexto principal. O apresentador testou o que foi sugerido e, com o tempo que passou com esses agentes, realmente gosta do potencial que viu. Esses agentes podem lidar com qualquer tarefa de pesquisa que leva muito tempo ou pode inchar a janela de contexto, permitindo que o agente principal trabalhe em algo completamente diferente e totalmente isolado da tarefa de pesquisa.

Casos de Uso Prático: Paralelização de Tarefas

O apresentador demonstra como agentes em segundo plano facilitam muito a implementação de mudanças em páginas separadas ao paralelizar tarefas, em vez de esperar que um agente lidasse com tudo sequencialmente. Por exemplo, se você está mudando todos seus componentes para uma nova biblioteca, pode usar agentes em segundo plano para atualizá-los todos de uma vez. Tarefas que consomem muito tempo, como revisões, podem ser executadas com múltiplos agentes assíncronos lançados simultaneamente: um para revisão de segurança, outro para identificar gargalos de desempenho, um para refatorar código e outro para verificar duplicações ou código não utilizado. Todas essas tarefas rodam em segundo plano enquanto o agente principal fica focado em uma atualização de recurso completamente diferente. Dessa forma, cada agente trabalha separadamente e gerencia sua própria tarefa independentemente dos outros, aumentando significativamente a eficiência geral.

Integração com Git Worktrees - O Ângulo Inesperado

O apresentador revela o ângulo inesperado mencionado anteriormente: equipar agentes em segundo plano com a capacidade de gerenciar trabalho em uma árvore de trabalho do Git, permitindo que façam commit e push de mudanças isoladamente. Git worktrees são um recurso extremamente subutilizado que permite trabalhar em múltiplas branches em diretórios separados, evitando constantes trocas de branch em um único workspace. O apresentador configurou um comando slash personalizado que cria um agente em segundo plano para trabalhar em tarefas em árvores de trabalho separadas, com instruções disponíveis na pasta commands dentro da pasta .claud. Ele demonstra um caso prático: trabalhando em um aplicativo mas não feliz com o tema, decidiu implementar 3 ideias diferentes de tema simultaneamente através de 3 agentes em segundo plano, tudo deixando o design principal completamente intacto. Isso permite simplesmente fazer merge do tema preferido no projeto principal e descartar os outros, tornando o processo de implementação significativamente mais rápido e oferecendo liberdade para experimentar sem quebrar o projeto.

Outros Recursos Anunciados do Claude Code

Além dos agentes em segundo plano, o apresentador destaca vários outros recursos anunciados nos changelogs que consideram particularmente úteis. O Instant Autocompact foi otimizado para ser significativamente mais rápido, reduzindo o tempo de compactação que costumava levar 2-3 minutos, provavelmente mantendo históricos para cada projeto direto na pasta .claud. Claude Code também adicionou um recurso de sugestão de prompt onde você pode simplesmente pressionar enter para aceitar uma sugestão ou digitar um novo prompt no lugar dela. É possível usar a flag agent ao iniciar o Claude para executá-lo como o agente específico que você tem no seu projeto, permitindo delegar tarefas para ele diretamente. Finalmente, Claude Code agora permite fazer fork de sessões e escolher entre elas quando se lança o Claude com a flag resume, bastando pressionar a tecla escape duas vezes para fazer fork da sessão atual.

Limitações e Boas Práticas

O apresentador ressalta áreas onde agentes em segundo plano não devem ser usados, pois prejudicariam o fluxo de trabalho em vez de melhorá-lo. Não se deve colocar em segundo plano nenhuma tarefa que exija entrada do usuário, pois isso faria o agente ficar bloqueado e incapaz de prosseguir. Também é importante evitar tarefas que exigem aprovação enquanto estão sendo executadas, pois ficariam bloqueadas em segundo plano e poderiam sair do controle se o agente principal estiver ocupado com outra tarefa. É altamente recomendado não atribuir tarefas que dependem uma da outra, pois isso pode criar conflitos no trabalho dos agentes; é muito melhor atribuir tarefas isoladas para cada um. Outras boas práticas incluem rastrear cuidadosamente o uso de tokens, pois cada agente consome um número significativo deles e isso pode resultar em contas altas. Ao gerar um agente, é importante dar um nome descritivo para saber exatamente o que cada um está fazendo quando se gerencia múltiplos agentes simultaneamente.

Community Posts

View all posts