A era dos AI Wrappers acabou. A era dos Claude Agent Wrappers começou.

Analisei o workshop de 90 minutos conduzido por Tariq Shihipar, o líder por trás do Claude Code na Anthropic.

Desde o Manus, o interesse em agentes explodiu - mas como realmente construir agentes que funcionam em produção continua frustrantemente vago. Esse workshop foi a resposta da Anthropic para essa pergunta.

Além de serviços que simplesmente encapsulam uma API de LLM, o que precisa mudar ao projetar aplicações agent-native? Aqui estão as quatro conclusões principais.

Bash É a Ferramenta Mais Poderosa

Você não precisa de dezenas de ferramentas customizadas.

• Softwares que já existem no Linux - ffmpeg, jq, curl e outros - dão conta da maioria das tarefas quando compostos via comandos Bash.
• Agentes aprendem sozinhos a usar ferramentas lendo man pages e a saída de --help.
• Você não precisa enfiar toda especificação de ferramenta dentro do prompt, o que significa menos desperdício de context window.

A implicação é significativa: em vez de construir integrações sob medida para cada capacidade, você entrega um shell ao agente e deixa ele compor o software existente. O universo de ferramentas CLI vira a caixa de ferramentas do agente - sem que nenhuma delas precise ser registrada antecipadamente.

O Centro do Loop do Agente É a Verificação

Coletar Contexto → Executar Ação → Verificar Resultado.

• O critério para decidir se vale usar um agente é simples: dá pra verificar o output?
• Código é fácil de verificar com compiladores e linters. Para tarefas de pesquisa, você precisa projetar a lógica de verificação separadamente - como exigir citação de fontes.
• Não dependa só da inteligência do modelo. Coloque ferramentas determinísticas - verificação de existência de arquivo, validação de sintaxe, checagem de tipos - dentro do loop para prevenir alucinações.

Esse é o insight que a maioria dos times perde. Eles focam em tornar os agentes mais inteligentes quando deveriam torná-los mais verificáveis. Um modelo mediano com loops de verificação fortes vai superar um modelo brilhante sem nenhum.

Até Trabalho Não-Dev Se Resolve com Geração de Código

Até tarefas simples como checar o clima ou analisar e-mails ficam melhores com código do que com respostas em texto.

• A abordagem: deixar o agente escrever scripts on the fly para conectar múltiplas APIs e processar dados.
• Uma parcela significativa dos usuários do Claude Code está em funções fora de desenvolvimento - marketing, finanças, operações.
• Tratar análise de dados e tarefas repetitivas como código descartável - scripts escritos uma vez, executados uma vez, jogados fora - está virando o workflow padrão.

Isso redefine o que “programar” significa na era dos agentes. O agente não precisa de uma integração pré-construída com seu provedor de e-mail. Ele escreve um script que chama a API, filtra os dados e retorna os resultados - tudo gerado em tempo de execução.

Engenharia de Contexto Mora no Sistema de Arquivos

Além da engenharia de prompt, você precisa projetar o ambiente em que o agente trabalha.

• Dar novas capacidades a um agente não exige fine-tuning complexo. Basta entregar uma pasta com arquivos markdown bem escritos e scripts.
• Tariq descreveu isso como ser “file system pilled.”
• Agentes têm estado. O centro da arquitetura de agentes é um ambiente isolado - um container - onde o agente tem acesso a um sistema de arquivos e pode executar comandos Bash.

Pense assim: o sistema de arquivos é a memória de longo prazo do agente, sua biblioteca de referência e seu workspace, tudo em um só lugar. Um arquivo CLAUDE.md na raiz do projeto não é só documentação - é o guia de onboarding do agente. Um diretório scripts/ não é só utilitários - é o kit de ferramentas do agente.

A Mudança de Paradigma

Assim como o desenvolvimento web evoluiu do jQuery para o React - saindo da manipulação imperativa do DOM para uma arquitetura baseada em componentes - o desenvolvimento de agentes está migrando de chamadas brutas de prompt para frameworks estruturados.

A pergunta não é mais “o que eu devo perguntar?” E sim “quais permissões e ambiente eu devo fornecer?”

Os times que entenderem essa distinção - que a performance do agente depende menos do modelo e mais do sistema ao redor dele - vão construir a próxima geração de software.

Baseado no workshop de Tariq Shihipar na Anthropic.