00:00:00O Claude Code foi lançado oficialmente em 22 de maio do ano passado, junto com o Claude 3.5 Sonnet.
00:00:06Mas já havia uma versão de testes antes disso, então eu venho usando a ferramenta
00:00:11há pouco mais de um ano. Eu até fiz as contas: se você somar todo o tempo
00:00:15que passei criando prompts, revisando e monitorando o código, já usei a ferramenta por mais de 2.000
00:00:21horas. Então, sim, eu tenho algo a ensinar. É isso que quero fazer neste vídeo.
00:00:27Agora, quero compartilhar com vocês todas as minhas estratégias testadas em campo que levarão você
00:00:31de um usuário básico de Claude Code a um usuário avançado. Reuni tudo no que
00:00:37eu chamo de framework WISC. E olha, essas estratégias são sérias. Não sou um daqueles
00:00:43criadores de conteúdo de IA que entraram na onda do Claude Code nos últimos meses. Eu uso
00:00:48esta ferramenta diariamente há mais de um ano. Por isso, essas estratégias vão funcionar em
00:00:54qualquer base de código, mesmo as imensas ou projetos com múltiplas bases. Já vi isso
00:01:00ser aplicado em nível corporativo; então, não importa no que esteja trabalhando, isso é para você. Isso
00:01:05também funciona para qualquer assistente de codificação por IA. Foquei no Claude Code porque ele é o melhor no momento.
00:01:10Estou assumindo que você já tem uma compreensão básica do Claude Code e agora
00:01:15quer elevar o nível. Se você quer o básico sobre como criar um sistema para codificação com IA,
00:01:21deixarei um link para esse vídeo aqui. Todas essas estratégias são para quando queremos
00:01:25trabalhar em bases de código reais que ficam complexas, pois temos várias táticas aqui sobre
00:01:32gestão de contexto. Isso é importante porque a degradação do contexto é o maior problema dos assistentes atuais.
00:01:38Não importa que o Claude Code tenha o novo limite de 1 milhão de tokens; ainda
00:01:43precisamos tratar nosso contexto como o recurso mais precioso, que deve ser planejado com cuidado
00:01:49ao usar assistentes de IA. As letras W, I, S e C do framework e todas as suas estratégias
00:01:56se aplicam a isso, e são coisas que você pode aplicar aos seus projetos imediatamente.
00:02:00Vou explicar tudo de forma bem simples aqui. Agora, a pergunta que você pode estar se fazendo é:
00:02:05"Cole, por que focar tanto na gestão de contexto? Depois de 2.000 horas usando
00:02:11o Claude Code, é nisso que você quer focar?" E minha resposta é: sim. Eu sei que é muito específico,
00:02:17mas precisamos lidar agora com a degradação do contexto e como evitá-la. Eu diria até
00:02:23que cerca de 80% das vezes que seu agente de IA erra no código, é porque você
00:02:28não está gerenciando bem o seu contexto. Por isso, quero começar pelo problema da degradação,
00:02:33e logo passaremos à prática mergulhando em cada parte do framework WISC. Mas quero
00:02:38começar pela degradação do contexto como um prelúdio para que vejam o porquê. Assim que aplicarem o WISC,
00:02:45vocês verão saltos imediatos na confiabilidade da codificação com IA, mesmo em bases de código
00:02:50mais complexas. Eu enfatizo bases maiores e mais bagunçadas porque é nelas que a degradação
00:02:56do contexto se torna um problema cada vez maior. Tem havido muita pesquisa na indústria sobre
00:03:02degradação do contexto, mas a minha favorita, a mais prática e talvez a mais popular,
00:03:07é o Relatório Técnico da Chroma sobre como o aumento de tokens de entrada afeta o desempenho dos LLMs.
00:03:13A ideia principal aqui é: só porque você pode colocar uma certa quantidade de tokens na janela de contexto
00:03:18de um LLM, não significa que você deva fazer isso. E sim, isso vale para o Claude Code com o novo limite.
00:03:24Pois modelos de linguagem de grande escala ficam sobrecarregados com informações, assim como as pessoas.
00:03:30É o chamado problema da "agulha no palheiro". Quando você tem uma informação muito específica ou,
00:03:35no caso de agentes de código, um arquivo específico que ele leu e que você precisa que ele lembre,
00:03:41ele fará um bom trabalho recuperando isso da memória de curto prazo, mas só se a janela não estiver lotada.
00:03:47Quando você começa a ter uma quantidade massiva de contexto carregado, surgem os chamados
00:03:52"distratores". São informações próximas ou semelhantes ao que você precisa que o LLM
00:03:58lembre, mas não exatamente o que você quer. Vemos muito isso na codificação com IA, especialmente em bases
00:04:04grandes. Seguimos os mesmos padrões em todo o projeto. Há muita semelhança
00:04:09na forma como diferentes partes do código são implementadas. Assim, os modelos de linguagem
00:04:14podem puxar a informação errada e ainda assim ter muita confiança na correção ou implementação sugerida.
00:04:19Tenho certeza de que você já viu isso. Esse problema da agulha no palheiro acontece o tempo todo
00:04:24na codificação com IA. Essa é a ideia da degradação do contexto. Quanto maior a nossa janela,
00:04:30mais difícil fica para o modelo extrair exatamente o que precisamos para a tarefa atual
00:04:36com o agente de código. Voltando ao diagrama, serei bem específico: o que estamos abordando com
00:04:42todas essas estratégias é a pergunta: "Como manter nossa janela de contexto o mais enxuta possível,
00:04:48dando ao agente de código todo o contexto necessário?" Essa é a engenharia de contexto
00:04:53que estamos fazendo aqui. Vou passar por cada estratégia. Eu até tenho
00:04:57um exemplo para cada uma que farei ao vivo com vocês em uma base de código complicada, e todos
00:05:02os comandos, regras e documentos que uso como exemplo estão nesta pasta que deixarei no link
00:05:06na descrição. Assim, você pode usar as estratégias conceitualmente, mas também com esses
00:05:12comandos de exemplo que tenho na pasta ".claude" aqui. Certo, vamos para as estratégias individuais.
00:05:17W significa "Write" (Escrever), I para "Isolate" (Isolar), S para "Select" (Selecionar) e C para "Compress" (Comprimir).
00:05:24Começaremos com o W, que é escrever, externalizando a memória do nosso agente.
00:05:30Queremos capturar o máximo possível as decisões importantes e no que o agente esteve trabalhando,
00:05:34para que, em sessões futuras, possamos atualizá-lo muito mais rápido e gastar menos
00:05:40tokens iniciais para que ele entenda o que realmente precisamos que ele faça. A primeira estratégia
00:05:46aqui é usar o log do Git como memória de longo prazo. Eu adoro isso porque há muita
00:05:52gente que gosta de complicar demais, criando estruturas de memória complexas para seus agentes,
00:05:56mas na verdade todo mundo já usa Git e GitHub para controle de versão. Então, podemos
00:06:01aproveitar uma ferramenta que já usamos para dar memória de longo prazo ao agente. Vamos
00:06:07até a nossa base de código e eu mostrarei o que quero dizer. A base que usarei para todos os
00:06:12exemplos aqui é o novo Archon. Tenho trabalhado duro nisso nos últimos meses,
00:06:18nos bastidores. Este é o seu centro de comando de IA, onde você cria, gerencia e executa fluxos
00:06:23de codificação de IA de longa duração. Estamos até criando um construtor de fluxos. Será como um
00:06:28n8n para codificação com IA. Podemos iniciar fluxos, ver os logs e monitorá-los em nossa
00:06:33central de controle. Podemos olhar execuções passadas para ver exatamente o que aconteceu. Como este,
00:06:39que é um fluxo bem longo que tenho para validar pull requests inteiros na minha base de código.
00:06:44Dá para notar por aqui (e tem muito mais vindo no Archon, inclusive), dá para notar
00:06:47ao olhar para isso que há muitas partes móveis. É uma base de código bem complexa. Então,
00:06:51serve como um ótimo exemplo para tudo o que vou cobrir com vocês, todas as estratégias.
00:06:57Sobre o Git como memória de longo prazo, vou mostrar um exemplo aqui de um comando simples
00:07:03para todas as minhas mensagens de commit recentes. O que quero destacar aqui é que temos uma
00:07:09forma bem padronizada de criar essas mensagens de commit. Temos os merges, mas também todas estas
00:07:13implementações de recursos e correções. Eu mantenho tudo padronizado porque assim posso confiar
00:07:19nas mensagens de commit para dizer ao agente o que fiz recentemente, já que muitas vezes
00:07:24isso guiará o que queremos fazer a seguir. E a razão de eu ter isso tão
00:07:29padronizado é porque existe um comando de commit que eu executo. Fazer um git commit é fácil,
00:07:36mas se quisermos padronizar a mensagem e ter o agente de IA nos ajudando nisso,
00:07:40ter um comando específico é muito poderoso. Eu fiz essa implementação completa aqui
00:07:46em uma única janela de contexto com o agente. Estou no final agora e pronto para fazer meu
00:07:51commit. Se eu apenas digitar "/commit", é tudo o que preciso fazer. Ele executa esse comando que
00:07:55tem a padronização de como documento qualquer trabalho feito. E também tudo o que fiz para melhorar
00:08:01minhas regras ou comandos. É um comando em duas partes: o que construímos e como melhoramos a
00:08:06camada de IA. Ele vai fazer o commit e eu mostrarei como fica depois.
00:08:10Certo. Agora, olhando nossa mensagem de commit, vemos que fizemos melhorias nos testes
00:08:14da CLI. Um prefixo bem legal e depois os detalhes. Além disso, para que o agente
00:08:19saiba como suas próprias regras e comandos evoluem, incluímos isso na mensagem
00:08:23sempre que encontramos uma oportunidade de melhorar, por exemplo, nosso comando de planejamento. É claro
00:08:29que esse comando de commit é um dos recursos que disponibilizei para você no repositório. Caso queira
00:08:33usar como ponto de partida, mas também encorajo você a personalizar como suas mensagens
00:08:37de commit devem parecer. O importante é padronizá-las e deixá-las bem
00:08:41detalhadas para servirem como memória de longo prazo. Bem, a segunda estratégia de escrita é
00:08:47sempre começar uma janela de contexto novinha em folha sempre que for escrever código. Não importa no que eu esteja
00:08:53trabalhando, meu fluxo é sempre: uma conversa para planejar com o agente. Eu crio algum
00:08:57arquivo Markdown com meu plano estruturado e depois envio isso como o único contexto para uma nova
00:09:03sessão de implementação. É fundamental que sua especificação tenha todo o
00:09:08contexto que o agente precisa para escrever o código e validá-lo. Por exemplo, nesta conversa,
00:09:14estou apenas planejando. Eu executo meu "prime" para começar (falarei disso logo).
00:09:18Carrego o contexto e crio meu plano com este comando. É outro recurso que deixei para você.
00:09:24Isso basicamente orienta o agente sobre a estrutura exata
00:09:28que queremos criar para o nosso documento Markdown único. Passando da nossa memória de curto prazo
00:09:33para um documento único. Então encerramos a sessão, vamos para uma janela de contexto nova
00:09:38e partimos para a implementação. Eu tenho meu comando de execução onde posso
00:09:42especificar o caminho do meu plano estruturado. Sem nenhum outro contexto, pois ele deve ter tudo
00:09:48o que precisa. Isso é vital porque mantém o agente focado na tarefa atual.
00:09:53Pesquisas e outras coisas podem poluir a janela de contexto se implementarmos no mesmo lugar onde planejamos.
00:09:57A última estratégia de escrita que tenho para externalizar a memória do agente
00:10:03são os arquivos de progresso e logs de decisão. Você verá isso sempre em frameworks de codificação
00:10:08mais elaborados, com arquivos como "handoff.md" ou "todo.md" servindo para a comunicação
00:10:13entre diferentes subagentes ou equipes de agentes, ou até entre sessões diferentes do mesmo agente. Quando
00:10:17o contexto está acabando, muitas vezes você quer criar esse resumo do que acabou de ser feito.
00:10:22Assim você pode ir para uma sessão limpa, já que começa a notar a degradação e o agente
00:10:27alucinando em conversas muito longas. Obviamente, o ideal é evitar conversas longas,
00:10:33mas às vezes elas são necessárias. Por exemplo, algo que faço muito no Archon é
00:10:38usar a CLI do agente de navegador da Vercel para realizar testes de ponta a ponta no navegador.
00:10:44Ele passa por várias jornadas de usuário e testa casos extremos. Isso consome muito
00:10:49contexto. Veja aqui embaixo, eu verifiquei o contexto e já estamos em 200.000 do limite
00:10:56de 1 milhão. Isso enche muito rápido. E quando você tem algumas centenas de milhares
00:11:01de tokens na janela, o desempenho do agente começa a cair. Então,
00:11:05posso simplesmente rodar um "/handoff". Esse comando cria um resumo que pode ser passado para
00:11:11outra sessão para continuar o trabalho. Mas agora o agente não tem centenas de milhares
00:11:16de tokens de chamadas de ferramentas e coisas do tipo poluindo a janela. Esse comando de handoff
00:11:21apenas segue um processo do que exatamente queremos colocar no documento para que o próximo
00:11:25agente tenha o necessário. Isso encerra o nosso W, e cada uma dessas estratégias é muito
00:11:31importante porque estamos registrando decisões-chave para que sessões futuras as entendam rápido.
00:11:36Eu sei que estou indo rápido. Digam nos comentários se querem que eu faça um vídeo inteiro
00:11:40sobre qualquer uma dessas estratégias, porque eu certamente poderia fazer para cada uma delas.
00:11:45Agora chegamos ao I de Isolate (Isolar), usando subagentes. Eu adoro usar subagentes para
00:11:52tudo o que envolve pesquisa; uso em quase todas as sessões. O segredo aqui é manter
00:11:56seu contexto principal limpo. Podemos usar subagentes para realizar dezenas ou centenas de milhares
00:12:03de tokens de pesquisa na base de código ou na web, e então passar apenas o resumo necessário
00:12:10para a nossa janela principal do Claude Code. Em vez de carregar dezenas de milhares de tokens de pesquisa
00:12:16no contexto principal, agora temos algo como apenas 500 tokens. Ainda temos a informação essencial,
00:12:21mas com uma melhoria de 90,2% (segundo pesquisas da Anthropic) ao usar subagentes
00:12:28para carregar o contexto de pesquisa previamente, em vez de deixar o agente principal cuidando de
00:12:33tudo. Deixe-me dar um exemplo rápido. Isso é sempre no início da conversa
00:12:38ou antes daquele plano estruturado que mostrei, na fase de planejamento. É nela que
00:12:43uso subagentes intensamente. Veja só: eu quero criar um construtor de fluxos no Archon.
00:12:50Então, quero que você inicie dois subagentes: um para fazer uma pesquisa extensa na base de código
00:12:55e ver como implementaríamos isso e o que significa para o Archon; e outro subagente para
00:13:01pesquisar na web as melhores práticas para a stack tecnológica. Se eu quiser usar React,
00:13:06qual biblioteca usar? E, no geral, como se constroem ferramentas como Dify ou n8n? Estou
00:13:12usando minha ferramenta de voz aqui. Envio o prompt. Pronto. Além do benefício do
00:13:16isolamento, ganhamos velocidade, pois ele usará os subagentes em paralelo. Eles voltam
00:13:21com um resumo e meu agente principal sintetiza tudo para me dar o resultado final.
00:13:26Lá vamos nós. Ambos os subagentes estão rodando em paralelo nos bastidores. Podemos até
00:13:31ver os logs de cada um. E no final eles retornam com o relatório completo.
00:13:36Certo, os subagentes terminaram. Em vez de gastar centenas de milhares de tokens
00:13:41em nossa janela principal (que foi o volume de pesquisa que os subagentes realizaram),
00:13:46usamos apenas 44.000 tokens, apenas 4% da nossa janela até agora. Esse é o poder dos subagentes.
00:13:53Não os recomendo para implementação porque geralmente você quer todo o contexto do que foi feito,
00:13:57mas para pesquisa é muito poderoso. Então, isolamento e subagentes são essenciais para o seu
00:14:04planejamento. Outra forma de usá-los é com o que chamo de "padrão batedor" (scout pattern).
00:14:09Queremos enviar batedores antes de comprometer nosso contexto principal. Pode haver partes do código
00:14:14ou da documentação que você quer que os subagentes explorem para ver se vale a pena carregar
00:14:21na sua sessão principal do Claude Code. Ele pode decidir antecipadamente: "Sim, devemos
00:14:25trazer isso para o planejamento maior" ou "Não, pule isso, não é relevante". Por exemplo,
00:14:30no Archon, tenho alguns documentos Markdown que são mergulhos profundos em certas partes da base,
00:14:36tipo de contexto que não queremos nas regras globais porque não precisamos sempre. Mas às vezes
00:14:41você pode querer carregar isso (imagine algo no Confluence ou Google Drive, onde você guarda seu contexto).
00:14:45Voltando a esta conversa principal, eu posso dizer: "Inicie um subagente para pesquisar tudo
00:14:48na minha pasta '.claude/docs'. Há alguma documentação aqui que seria
00:14:54importante carregar no contexto principal para o planejamento?" Envio isso, ele decide
00:14:59e carrega só o que me interessa. Veja só, iniciamos um subagente explorador.
00:15:04Ele encontrou toda a documentação e recomendou carregar um arquivo. Eu disse: "Sim, pode carregar".
00:15:09Isso é crucial para o planejamento. Em vez de usar subagentes só para pesquisa geral, às vezes
00:15:13temos documentos específicos que acreditamos ser vitais para a janela principal.
00:15:18É aí que usamos o padrão batedor. Isso é tudo sobre isolamento.
00:15:23Lembre-se de usar subagentes extensivamente para pesquisa e planejamento. E agora
00:15:28chegamos ao S de Select (Selecionar). Carregue seu contexto na hora certa, não "por precaução".
00:15:34O que quero dizer é: se você não tem 100% de certeza de que uma informação é
00:15:40importante para o agente agora, não se dê ao trabalho de carregá-la. E temos uma abordagem em camadas para ajudar.
00:15:46Começamos com nossas regras globais. São as restrições e convenções
00:15:51que sempre queremos que o agente conheça. Este arquivo deve ser bem conciso,
00:15:57geralmente entre 500 e 700 linhas. Muitos defendem até menos, mas nele você coloca
00:16:02arquitetura, comandos para rodar, estratégias de teste e logs. Este é o meu exemplo do Archon,
00:16:08mas são coisas que você quer que o agente saiba o tempo todo. Depois temos a camada 2.
00:16:12O contexto sob demanda, como eu chamo: são regras que se aplicam apenas a partes específicas da base.
00:16:18Se estivermos trabalhando no front-end (o que nem sempre ocorre), aqui estão as regras
00:16:23globais do front-end, ou as regras para criar endpoints de API. Adicionamos isso
00:16:28às regras globais apenas para tipos específicos de tarefas, já que não vamos trabalhar
00:16:33no front-end o tempo todo, por exemplo. Para dar um exemplo, temos a referência YAML de fluxos
00:16:38que puxei agora pouco com o subagente explorador. Quando trabalhamos nos fluxos,
00:16:43isso nos interessa, mas não queremos isso nas regras globais porque, na maior parte do tempo
00:16:48em que mexemos no Archon, não estamos mexendo nessa parte específica. Portanto, é
00:16:52contexto sob demanda. A terceira camada que temos aqui são as habilidades (skills). Isso é bem
00:16:57popular no Claude Code e além. Temos diferentes estágios onde o agente vai
00:17:05explorar as instruções e capacidades daquela habilidade conforme julgar necessário. Começamos
00:17:10com a descrição. É uma quantidade mínima de tokens carregada junto com as regras globais.
00:17:15Se o agente decidir que quer usar a habilidade, ele carrega o "skill.md" completo,
00:17:20que também pode apontar para outros scripts ou documentos de referência caso queiramos
00:17:25aprofundar na habilidade. Como exemplo, tenho minha habilidade de navegador (agent browser).
00:17:29É o que uso para automação de navegador nos testes de ponta a ponta que mostrei. Uso
00:17:35isso todo santo dia. Sempre que vou fazer esses testes, quero carregar esse
00:17:40conjunto de instruções para o agente entender como operar o navegador. E, finalmente, para a quarta
00:17:46camada, tenho os comandos de "prime". Tudo o que cobri até agora é documentação estática
00:17:52que atualizamos de vez em quando. Mas às vezes precisamos que o agente explore
00:17:57a base de código ao vivo. Precisamos garantir que todas as informações dele estejam totalmente atualizadas
00:18:02e estamos dispostos a gastar alguns tokens com subagentes antecipadamente para isso. É isso que o
00:18:07comando prime faz: explora a base de código no início do planejamento para que ele
00:18:11entenda o projeto antes de decidirmos o que construir a seguir. Como podem ver na minha
00:18:16pasta de comandos, tenho vários comandos prime diferentes, pois há partes distintas que quero que o
00:18:22agente entenda dependendo do que vou construir. Meu comando prime genérico é
00:18:27este que estamos vendo. Eu digo para ele obter uma visão de alto nível do Archon.
00:18:32O passo a passo inclui a leitura do log do Git, pois isso é importante para
00:18:36usar o Git como memória de longo prazo. Tenho também um especializado, o "prime-workflows",
00:18:41para quando sei que vou mexer no motor de fluxos do Archon. É um comando similar,
00:18:47mas mais focado. Uso isso no início da conversa para o agente carregar logo
00:18:53tudo o que precisa. Confirmo que ele entendeu e aí entro no processo de planejamento
00:18:58que mostrei antes. Resumindo rápido: regras globais estão sempre lá. Contexto sob demanda
00:19:03quando você vai mexer em uma parte documentada à parte. Habilidades quando precisa de
00:19:09capacidades extras, tipo: "hora de testar no navegador, carregue a habilidade correspondente".
00:19:13E os comandos prime eu rodo logo no início da conversa para preparar o terreno para o planejamento.
00:19:18Isso é tudo sobre selecionar. Agora vamos para Comprimir (Compress), que é a parte mais rápida
00:19:22porque você não deveria precisar comprimir com frequência se estiver aplicando bem o W, I e S.
00:19:28Se usarmos as outras estratégias para manter o contexto enxuto, evitamos isso, o que é
00:19:34bom, pois você deve evitar comprimir o máximo possível. Mas, se precisar, há
00:19:39duas estratégias aqui: o handoff e a compactação com foco. Vamos ao Claude Code
00:19:46ver como isso funciona. O handoff já vimos, é uma das nossas estratégias de escrita.
00:19:52Resumimos tudo o que foi feito para passar a outro agente ou ao mesmo agente após
00:19:56limpar a memória. E temos o comando nativo "/compact" no Claude Code.
00:20:02Ele resume a conversa, limpa o histórico e coloca o resumo no topo da janela
00:20:06de contexto. O handoff é poderoso porque nós definimos como a informação deve ser lembrada.
00:20:12Mas o "/compact" também é útil, especialmente porque podemos dar instruções opcionais de resumo.
00:20:18Quando eu realmente preciso compactar, uso isso sempre. Por exemplo: "foque nos casos de borda
00:20:23que acabamos de testar". Agora, quando ele criar o resumo, ele dará mais atenção
00:20:28a essa parte da memória de curto prazo. Eu digitei errado, mas não tem problema. Ele fará a
00:20:34compactação. O handoff e o "/compact" são alternativas, mas eu às vezes uso ambos.
00:20:41O handoff é melhor quando você já compactou umas duas vezes e a conversa continua
00:20:48muito cheia, então é melhor abrir uma nova sessão. Mas se for apenas uma vez,
00:20:53eu aceito usar o "/compact". No entanto, após compactar, eu costumo pedir ao agente para resumir o que
00:20:58ele lembra, só para garantir que ele realmente entendeu tudo. Tipo: "o que você lembra aqui?".
00:21:03Não é o ideal. Evite a compactação o máximo que puder. A melhor estratégia de
00:21:09compressão é não precisar dela. E esse é o framework WISC.
00:21:14Eu sei que foi muita coisa, então espero que tenham achado útil. Me digam se querem que
00:21:19eu aprofunde em alguma estratégia, porque daria para fazer um vídeo inteiro sobre qualquer uma
00:21:24delas. Mas este é o WISC. Espero que possam usá-lo para elevar seu nível no Claude Code
00:21:30ou em qualquer assistente de codificação por IA. Se você achou este vídeo útil
00:21:36e quer mais conteúdo sobre codificação com IA e aplicação desses tipos de frameworks
00:21:41na prática, eu agradeceria muito o seu like e sua inscrição. E com isso, vejo vocês
00:21:46no próximo vídeo. Calma! Tenho uma última coisa rapidinho que você não vai querer perder.
00:21:52No dia 2 de abril, vou realizar um workshop gratuito de transformação com IA ao vivo no meu canal,
00:21:59junto com Lior Weinstein, fundador da CTOX. É algo importante: Lior vai nos ensinar
00:22:04como reestruturar toda uma organização para a IA e eu ensinarei a dominar a metodologia de
00:22:09codificação com IA que uso para criar sistemas confiáveis e repetíveis com meus agentes.
00:22:14Deixarei o link na descrição para esta página. Será ao vivo no YouTube, então você
00:22:20pode ativar as notificações clicando neste botão aqui. Vejo vocês lá!
00:22:27restructuring our entire organization for AI and then I'll teach you how to master the AI coding
00:22:32methodology that I use to build reliable and repeatable systems for my coding agents. And so
00:22:38I'll have a link in the description to this page. It's going to be live on my YouTube channel so you
00:22:42can enable notifications for it by clicking on this button right here. I will see you there!