Quando o Hélio entendeu a mecânica das notas, veio a pergunta que sempre vem: “E ele aprende com isso? Fica melhor com o tempo?”
A resposta é: aprende quando você estrutura esse aprendizado. O Claude não melhora sozinho — mas com uma seção específica no processo, cada execução pode deixar o processo mais preciso do que a anterior.
A seção <aprendizado>
O esqueleto do processo apresentado no artigo anterior já incluía <aprendizado> como uma das quatro seções. Ela começa vazia — e vai sendo preenchida ao longo do uso.
A estrutura é uma lista de regras. Cada aprendizado vira uma <regra-N> com uma linha ou um parágrafo curto descrevendo o que mudou. Sem hierarquia, sem data — só a regra em si.
<aprendizado>
<regra-1>
Ao calcular runway, sempre incluir IOF sobre compras
com cartão internacional.
</regra-1>
<regra-2>
Antes de gerar o painel, validar com o usuário se há
receita atrasada relevante no período.
</regra-2>
</aprendizado>As regras saem das notas que foram integradas. Quando uma nota corrige algo e sugere uma mudança no comportamento futuro do processo, essa instrução vira uma <regra-N>. Da próxima vez que o Claude executar o processo, ele lê o <aprendizado> e já começa com as regras em mente.
Como as regras entram na seção
O caminho é direto. Depois de integrar as notas de uma execução, você instrui o Claude:
Analise as anotações que acabaram de ser integradas e
identifique quais delas são melhorias que devem se tornar
regras permanentes do processo. Adicione como `<regra-N>`
na seção `<aprendizado>`.Não é toda correção que vira regra. Uma nota que corrige um dado específico daquele mês não precisa virar regra — foi um desvio pontual. Uma nota que indica que o processo sempre errou em um tipo de cálculo, ou que sempre deixou de verificar uma condição relevante — essa vira regra.
O ciclo completo
O que acontece ao longo do tempo é um ciclo de melhoria contínua do processo:
- Processo executa
- Você revisa o resultado com
<nota>nos pontos a corrigir - Claude integra as notas, corrige o artefato
- Melhorias que afetam futuras execuções viram
<regra-N>em<aprendizado> - Próxima execução começa já com as regras aprendidas
O ambiente do Hélio depois de alguns meses era mais preciso do que no primeiro dia — não porque o Claude evoluiu, mas porque o processo evoluiu. As regras acumuladas capturavam o que foi descoberto pelo uso real.
O horizonte
Um processo maduro, com um conjunto de regras bem calibrado, pode ser encapsulado em uma skill — um arquivo que encapsula o processo e pode ser ativado por comando em qualquer ambiente. A skill representa o processo abstraído para reuso.
Com habilidades mais avançadas, o processo pode virar um agent — um Claude configurado especificamente para aquele conjunto de tarefas, com suas próprias instruções e restrições.
Chegando mais longe ainda, múltiplos agents podem cooperar em times — cada um responsável por uma parte do trabalho.
Não vou me aprofundar nesses conceitos agora. São tópicos para artigos próprios, quando o fundamento do método estiver bem estabelecido. O que vale registrar é que o caminho existe: um processo que começa simples e evolui pelo uso pode chegar a níveis de automação significativos.
Para chegar lá, passa pelo que esse artigo apresenta: estruturar o aprendizado agora, em cada execução.
Estou ministrando mentorias para profissionais de diversas áreas que estão começando nessa ideia. Se não quer percorrer esse caminho sozinho, é só me chamar.