27 Configurações para Transformar o Claude Code em um Sistema de Agente Autônomo

Por Que Seu Fluxo de Trabalho Não Mudou Mesmo Usando o Claude Code Diariamente

"Eu lembro de ter executado /init. Mas não faço ideia de quando foi a última vez que o atualizei."

Isso parece com você? Você instalou o Claude Code, passou os primeiros dias configurando e conversa com ele diariamente. No entanto, comparado a três meses atrás, a estrutura do seu trabalho continua praticamente a mesma.

Isso não é um problema de uso; é um problema de posicionamento.

Se você continuar usando o Claude Code como uma "ferramenta que responde quando é chamada", acabará digitando as mesmas instruções toda manhã, recebendo respostas semelhantes e copiando-as para o seu trabalho. Você pode estar mais eficiente, mas a forma como seu trabalho progride não mudou fundamentalmente.

A mudança acontece quando você começa a tratar o Claude Code como um "alvo de design". Quem sabe o quê em qual contexto? Quais tarefas são delegadas para quem? O que se move mesmo quando nenhum humano está presente? Quando você começa a pensar nisso como design, o Claude Code começa a se comportar de forma completamente diferente.

As 27 funcionalidades publicadas por @sairahul1 (https://x.com/sairahul1/status/2070428662080618607) listam sistematicamente funções que devem ser usadas a partir dessa perspectiva de design. O Swarm interpretou essas funcionalidades através da lente do design de agentes e as organizou em um formato aplicável a contextos de negócios reais.

Vinte e sete pode parecer muito, mas existem apenas três princípios fundamentais. Explicaremos essa estrutura em ordem a partir do próximo capítulo.

As Três Disciplinas que Conectam as 27 Funcionalidades

Olhando para as 27 funcionalidades, elas podem parecer dispersas. Existem atalhos, configurações de arquivos, entrada de voz e execução de testes. No entanto, quando decodificadas, podem ser organizadas em grupos que respondem a três perguntas.

Disciplina 1: Design de Contexto (Funcionalidades 1–5)

Criar um estado onde o Claude saiba "de quem é o projeto, para qual propósito e quanto ele entende atualmente". Se isso falhar, você tem que explicar tudo do zero toda vez.

Disciplina 2: Design de Delegação (Funcionalidades 6–14)

Entregar tarefas e autoridade ao Claude de forma estruturada. Em vez de dizer "corrija o bug", você organiza e entrega "o que está quebrado e quais são as restrições", o que muda a probabilidade de uma resolução na primeira tentativa.

Disciplina 3: Design de Autonomia (Funcionalidades 15–27)

Projetar um mecanismo onde o Claude possa continuar se movendo sem instrução humana constante.

Esses três estágios também são a ordem em que você deve usá-los. Se o contexto não estiver definido, a delegação se torna imprecisa. Se a delegação não for projetada, a autonomia foge ao controle.

O que você precisa ter em mente aqui é como mudar a estrutura de "eu instruindo o Claude toda manhã". Se você está jogando as mesmas tarefas no chat toda manhã, o humano ainda é o sujeito. Quando o design muda para uma estrutura que move o Claude, o que você faz pela manhã muda.

Primeiro, vamos olhar para as cinco funcionalidades do Design de Contexto.

Fundamentos do Design de Contexto

O objetivo do design de contexto é dar ao Claude o "contexto deste projeto". Sem contexto, toda conversa começa de uma página em branco.

A primeira coisa a executar é `/init`.

Quando você abre um projeto pela primeira vez, execute isso primeiro. O Claude escaneia a estrutura do código-fonte, dependências e comandos de build para gerar automaticamente o CLAUDE.md. Este arquivo se torna o "plano mestre" do projeto.

É aqui que muitos param. Eles lembram de ter executado /init, mas não sabem quando foi a última atualização. Se deixado como foi gerado, o conteúdo do CLAUDE.md vai se distanciar da realidade à medida que o projeto muda. Operando na premissa de atualizações semanais, o Claude pode sempre se mover dentro do contexto mais recente.

Em seguida, `/statusline` é útil para configurar.

Uma linha de status aparecerá na parte inferior da tela. Você pode visualmente entender o que está sendo executado e quais processos estão ativos. Também pode ser integrada com linhas de status personalizadas no Vim ou Neovim, permitindo que você a configure de acordo com seu ambiente de editor existente.

O terceiro é a entrada de voz.

Você pode passar requisitos complexos falando usando ⌃⌘Space no Mac ou entrada de voz nativa no iOS e Android. Você pode passar instruções longas como "Eu quero que este componente se mova assim por este motivo, mas não mude os estilos existentes" sem digitar. Como você pode passar pensamentos conforme eles fluem, economiza tempo gasto organizando enquanto digita.

Use `/context` para verificar o estado do contexto.

Você pode ver o que está atualmente na conversa e o uso da janela de contexto em tempo real. Em sessões longas, o conteúdo do plano inicial tende a desaparecer. Este comando permite que você monitore isso.

As operações de reset para isso são `/compact` e `/clear`.

/compact comprime todo o contexto em um resumo. /clear é um reset completo. Se você continuar uma sessão longa, as respostas do Claude podem se tornar vagas. Este é um sinal de que o contexto está entupido. Usando /compact periodicamente, você pode manter a qualidade da saída.

Antes: Na segunda metade de uma sessão longa, o Claude dá uma resposta desalinhada mesmo ao dizer "seguindo a política de design discutida anteriormente."

Depois: Comprimir com /compact antes de continuar mantém a saída precisa em relação à política.

As cinco funcionalidades fazem uma coisa: manter o estado do Claude "sabendo" como um design. Isso se torna a base para o próximo passo, o Design de Delegação.

A Arte de Passar Problemas

Uma vez que o contexto está definido, o próximo passo é como passar o problema. A precisão da resposta muda completamente dependendo se você diz "corrija o bug" ou passa de forma estruturada.

Primeiro, use o modo de planejamento (`Shift+Tab`).

Antes de mudanças importantes, este modo gera "apenas o plano" em vez de executar. Você pode verificar o que o Claude pretende mudar e em qual ordem com antecedência.

Em vez de corrigir erros depois que eles ocorrem, você pode apontar "isso está errado" na fase de planejamento. Incorporar este passo ao seu design muda significativamente a frequência de mudanças inesperadas. Conforme você continua usando, perceberá que reduz o esforço de verificar "por que este arquivo foi reescrito?" depois do ocorrido.

Segundo é a estruturação de problemas, restrições e contexto.

Se você apenas disser "corrija o bug", o Claude tenta preencher as suposições por conta própria. Se essas suposições estiverem erradas, a solução também estará.

O formato oficialmente recomendado é escrever "o que está quebrado" na primeira linha, e "o que foi tentado, restrições e formato de saída esperado" a partir da segunda linha. Apenas passar neste formato já muda a taxa de resoluções em uma única tentativa. A maneira como você passa o problema se torna uma habilidade em si.

Terceiro é `AskUserQuestion`.

Esta é uma funcionalidade onde o Claude pede esclarecimentos antes de prosseguir quando encontra requisitos ambíguos. Retrabalho causado pela implementação prosseguindo com requisitos vagos muitas vezes acontece quando esta funcionalidade não é usada. É um design que paga o custo da confirmação antes da implementação.

Quarto é a etapa de autoverificação.

No final de uma tarefa, diga a ele para "executar testes e confirmar que o build passa antes de finalizar". Em vez de adicionar isso manualmente toda vez, escrevendo no CLAUDE.md garante que seja executado automaticamente no final de cada tarefa. Em vez do Claude parar em um estado onde as coisas não funcionam após uma mudança, o loop incluindo a verificação é completado como uma única tarefa.

Tomar medidas proativas com o modo de planejamento e automatizar etapas reativas com autoverificação. A estrutura do fluxo de desenvolvimento muda no momento em que esses dois são incorporados ao design.

No próximo capítulo, veremos o design da delegação de tarefas contínuas para o Claude.

Projetando a Delegação

Nos capítulos anteriores, organizamos como nos comunicar com o Claude e como fazê-lo reter memória. O próximo é sobre mudar "quem se torna o sujeito".

10. Subagentes

Se um humano gerencia procedimentos durante tarefas longas, ele inevitavelmente vai travar. Dizer constantemente "faça isso a seguir, depois faça aquilo quando terminar" significa que o humano, não o Claude, está lidando com a coordenação.

Usando as ferramentas TodoWrite ou Task, o Claude decompõe tarefas em subtarefas e as executa em paralelo. Em termos oficiais, isso é "execução concorrente de subagentes" — uma estrutura onde múltiplos Claudes filhos se movem simultaneamente. Diferentes Claudes executam pesquisa, implementação e teste ao mesmo tempo. Os humanos não precisam manter o procedimento.

11. Habilidades Personalizadas (Arquivos de Template de Fluxo de Trabalho)

Colocar arquivos Markdown no diretório .claude/commands/ permite que você chame conjuntos de instruções com /nome-do-comando. No contexto do Swarm, é mais fácil pensar neles como "SKILL.md (Arquivos de Template de Fluxo de Trabalho)".

Antes: Escrever "Por favor, conduza uma pesquisa de concorrentes. Os passos são 1, 2, 3..." toda vez.

Depois: Apenas digitar /pesquisa-concorrencia em uma linha.

O tempo gasto escrevendo as mesmas instruções repetidamente desaparece. Se compartilhado com uma equipe, torna-se um template onde qualquer um pode obter a mesma qualidade de saída.

12. Seleção de Modelo

Você pode alternar modelos dentro de uma sessão pressionando Alt+P. Um uso realista em três estágios é: modelos de alto raciocínio para fases de design e conceituação, modelos leves para implementação simples e modelos intermediários para depuração.

Combinar o poder do modelo com o peso do processo melhora tanto a eficiência de custos quanto a velocidade de resposta simultaneamente.

13. Atualizações Automáticas do CLAUDE.md

Se você disser ao Claude para "adicionar o que você aprendeu neste projeto ao CLAUDE.md", o Claude atualizará o CLAUDE.md por conta própria. É uma estrutura onde o plano mestre cresce sozinho.

Adicionando este comando uma vez por semana, o CLAUDE.md se torna um "documento vivo". Mesmo que os humanos não escrevam reflexões, o Claude acumula o que aprendeu.

14. Vinculação de Arquivos Externos

Você pode passar arquivos, URLs ou Issues como contexto usando @{caminho_do_arquivo}. É um mecanismo para completar "leia este arquivo antes de trabalhar" em uma linha.

Antes: Copiar e colar conteúdos de arquivo no prompt.

Depois: Apenas escrever "Verifique as configurações consultando @src/config.yaml."

Projetar delegação significa criar um sistema que entrega o sujeito ao Claude. Quando procedimentos, templates, referências e memória estão todos em ordem, os humanos só precisam pensar sobre "o que criar".

No entanto, à medida que a delegação aumenta, também aumenta o risco de "Claude se mover em uma direção diferente da intenção". No próximo capítulo, veremos como parar esse desvio cedo.

Parando o Desvio Cedo

À medida que a delegação para o Claude aumenta, um problema se torna mais provável: perceber que ele seguiu em uma direção completamente diferente da pretendida. Chamamos isso de desvio.

O desvio não é algo para consertar depois; pode ser prevenido tomando medidas proativas de design.

15. Parada Imediata

Se você sentir que a saída está indo em uma direção obviamente errada, pode pará-la imediatamente com a tecla Escape. "Vou consertar depois que terminar" é um erro. Quanto mais a geração prossegue, maior o custo da correção. Parar no meio e corrigir o prompt economiza tempo e tokens.

Se você intuitivamente achar que algo está errado, pare sem hesitação. A velocidade desse julgamento impacta diretamente a precisão.

16. Solicitar a Primeira Saída como Evidência

Um design proativo é dizer "mostre apenas a primeira saída primeiro, e eu decidirei se continuo" antes de começar o trabalho.

Em vez de deixá-lo gastar 10 minutos na direção errada, confirme com a primeira saída antes de deixá-lo executar. Esta é a ideia de cortar o desvio pela raiz. É essencial para tarefas de longa duração ou trabalho que começa com direções ambíguas.

Antes de dizer "deixo o resto com você", insira "deixe-me verificar o começo". É apenas um passo, mas este movimento proativo muda o resultado.

17. Ganchos de Notificação

Ficar olhando para a tela esperando uma tarefa longa terminar é uma perda de tempo. Colocando um script em ~/.claude/hooks/, você pode receber notificações de desktop quando uma tarefa é concluída.

Configure uma vez. A partir daí, mesmo que você esteja fazendo outro trabalho, o Claude notificará quando terminar. É um design que elimina o ato de esperar.

18. Passar Capturas de Tela

Explicar bugs de UI em palavras é surpreendentemente difícil. Em vez de dizer verbalmente "um erro vermelho apareceu no canto superior esquerdo e o botão não pode ser pressionado", passar uma captura de tela é mais rápido.

O Claude recebe a imagem e retorna o conteúdo do erro, a causa e sugestões de correção diretamente. É completado com "olhe para esta tela".

As 18 funcionalidades introduzidas até agora são todas baseadas na premissa de uma pessoa operando. No próximo capítulo, entramos na estrutura de "usar como uma equipe", onde múltiplos Claudes executam em paralelo e se integram.

Operação Paralela e Integração

Enquanto usa o Claude Code como uma ferramenta de chat, você não pode começar a próxima tarefa até que uma termine. Mas mudando o design, você pode criar uma estrutura onde múltiplos Claudes se movem simultaneamente.

Comece com a integração com o Chrome DevTools. Como você pode passar logs de erro do navegador e logs de rede diretamente para o Claude Code, você não precisa mais explicar verbalmente situações como "há um erro vermelho no console, mas não sei o que está acontecendo". A documentação oficial tem uma página dedicada para isso, posicionando-a como a porta de entrada para a depuração.

O gerenciamento de sessão também muda. Você pode retomar a sessão mais recente como está com claude --continue, ou escolher de uma lista de sessões com claude --resume. Além disso, nomeando sessões com /rename, você pode gerenciar múltiplas tarefas em paralelo com a mesma sensação de branches do Git. Usando sessões nomeadas "Auth", "Payment" e "Dashboard", o custo de alternar contexto se torna quase zero.

E o núcleo da operação paralela é a combinação com git worktrees. Digitar claude --worktree feature-auth inicia uma sessão onde o branch está completamente isolado pela worktree. Se você executar Auth, Payment e Dashboard em worktrees separadas, três Claudes prosseguirão com o desenvolvimento em paralelo. Como cada um está em um espaço de trabalho independente, nenhum conflito ocorre. A estrutura para terminar uma semana de desenvolvimento em um dia é estabelecida aqui como um design.

Também é necessário organizar os pensamentos sobre MCP. Um servidor MCP nem sempre é a solução ideal. A documentação oficial afirma que "ferramentas CLI são a maneira mais eficiente em termos de contexto para interagir com serviços externos", e ferramentas CLI como gh ou aws são consideradas com alta eficiência de contexto e menos propensas a atingir limites de taxa. Apenas com o comando gh, o Claude Code pode criar, atualizar e fechar Issues do GitHub autonomamente. Ter um eixo de julgamento para verificar se uma ferramenta CLI pode ser usada antes de adicionar um MCP mantém o design simples.

Quando o design paralelo é possível, os humanos não precisam mais gerenciar a sequência. Isso ocorre porque o design muda para passar múltiplos sujeitos para o Claude simultaneamente. Em seguida, evoluiremos este processamento paralelo projetado para um sistema que continua se movendo mesmo quando você está longe da sua mesa.

Operação Autônoma

A próxima questão após o design paralelo é: "Onde eu preciso estar durante esse tempo?" Quando a operação autônoma é projetada, um estado é criado onde o trabalho progride mesmo sem um humano presente.

/loop é uma funcionalidade que executa polling automático dentro de uma sessão. A explicação oficial é "Polling rápido enquanto uma sessão está aberta", e repete operações especificadas enquanto a sessão estiver aberta. Usar --resume ou --continue permite retomar sessões que não expiraram, e de acordo com relatos de experiência no artigo original, casos de operação não tripulada por até três dias foram relatados. Embora não tenhamos confirmado esse número de dias diretamente com fontes oficiais, certamente funciona como um ponto de entrada para operação autônoma de longa duração.

O Controle Remoto, adicionado no Q1 de 2026, é uma funcionalidade para operar sessões do Claude Code rodando localmente a partir de um smartphone ou navegador de PC. Enquanto o código permanece local, apenas as mensagens são trocadas através de um canal criptografado. Foi lançado como uma prévia de pesquisa em fevereiro de 2026. Um cenário é estabelecido onde o Claude Code local continua se movendo apenas enviando "verifique se os testes passaram" de um smartphone enquanto estiver fora.

Consultas em linguagem natural a bancos de dados também podem ser incorporadas ao design. Conectando-se a SQLite, PostgreSQL ou MySQL via MCP permite recuperar dados usando português (ou inglês) como "me diga os usuários registrados na semana passada". O guia oficial sugere executar claude mcp add para conectar ferramentas externas como seu banco de dados, permitindo delegar rotinas de confirmação de dados ao Claude sem escrever SQL.

Existem também quatro funcionalidades para controlar a profundidade do pensamento. ultrathink aciona o pensamento estendido de até 31.999 tokens apenas incluindo essa palavra-chave no prompt. Existe uma hierarquia: think é 4.000 tokens, megathink é 10.000 tokens e ultrathink é 31.999 tokens. A maneira correta de usá-lo é apenas para os 10% de problemas verdadeiramente difíceis, como decisões complexas de arquitetura, implementações de segurança, otimização de desempenho e refatoração em larga escala. Usá-lo para toda consulta inflará os custos inutilmente.

/effort ultracode é uma configuração para habilitar raciocínio ultra-alto e fluxos de trabalho dinâmicos para toda a sessão. Enquanto ultrathink é uma palavra-chave de um turno, ultracode permanece ativo durante toda a sessão. É adequado para "trabalho pesado de sessão inteira" como auditar uma base de código inteira, migrar centenas de arquivos ou tarefas de alto risco. No entanto, como os custos de token aumentam significativamente, discernir a situação determina a eficácia.

O Claude Code, que começou com digitação no chat para movê-lo, alcançou o portal de um sistema que detecta eventos e se move autonomamente. Em vez de humanos movê-lo, o design move o Claude. Em seguida, confirmaremos onde a diferença na produtividade essencialmente surge através de todas essas funcionalidades.

Por Que os Resultados Diferem com o Mesmo Claude Code

Pessoas que desenvolvem rapidamente não necessariamente têm habilidades especiais. Elas estão simplesmente projetando de forma mais sistemática.

Por exemplo, considere a situação de executar /init. Mesmo que o mesmo comando seja digitado, a qualidade da saída vários meses depois será completamente diferente entre um CLAUDE.md que é atualizado semanalmente e um que foi deixado desde a configuração. Isso ocorre porque o frescor e a precisão do contexto que o Claude lê impactam diretamente a qualidade da saída.

Usando uma analogia de cozinha, o nível da culinária é determinado mais por como a própria cozinha é organizada do que por quais ingredientes são usados. O desempenho do modelo do Claude é fornecido igualmente a todos os usuários. A diferença está na precisão destes três pontos: como o contexto foi organizado, como as instruções foram sistematizadas e como a operação autônoma foi projetada.

Antes de discutir "qual modelo usar", tente verificar quando seu CLAUDE.md atual foi atualizado pela última vez. Isso lhe dirá o estado atual do seu design.

Então, por onde você deve realmente começar? No próximo capítulo, organizaremos uma sequência de introdução passo a passo.

Por Onde Começar: Um Guia de Introdução Passo a Passo

Você não precisa tentar lembrar de todos os 27 de uma vez.

Na primeira semana, reduza para apenas quatro.

• Crie um mapa do projeto com /init.
• Comprima o contexto periodicamente com /compact.
• Separe exploração e execução com o modo de planejamento (Shift+Tab).
• Passe as etapas de autoverificação (testes, builds) para o Claude.

Apenas com esses quatro, a qualidade da sessão mudará fundamentalmente. Como o Claude começa a se mover com uma compreensão precisa de "o que deve ser feito", a quantidade de retrabalho diminuirá visivelmente.

A partir da segunda semana, adicione o Design de Delegação sobre esta base. Resuma instruções em um formato reutilizável com Habilidades Personalizadas, ajuste o peso e a velocidade do processamento com a seleção de modelo (Alt+P) e estabeleça o hábito de atualizar o CLAUDE.md semanalmente. Este é o estágio onde você muda as instruções de "algo escrito toda vez" para "algo que se acumula".

Após um mês, prossiga para subagentes, git worktrees e sessões paralelas. Você terá um sistema onde pode se concentrar no design e na confirmação enquanto desenvolve múltiplas funcionalidades simultaneamente.

ultrathink e ultracode são ferramentas para serem usadas pela primeira vez neste fluxo quando você encontrar "problemas verdadeiramente difíceis". Não são ferramentas para serem usadas em todo problema.

Seguindo estes passos, você entenderá através da experiência "por que cada funcionalidade é necessária". Por favor, comece com os quatro itens da primeira semana.

Tudo Muda no Momento em que Você Trata Isso como um Alvo de Design

O momento em que você começa a tratar o Claude Code como um alvo de design, a qualidade da sessão muda fundamentalmente.

Vou resumir o conteúdo introduzido neste artigo em um formato que você possa salvar e consultar.

• Os quatro itens — /init + /compact + modo de planejamento + autoverificação — são os designs básicos mais fundamentais.
• Sistematize a reutilização de instruções com Habilidades Personalizadas e cultive o CLAUDE.md como um "plano mestre vivo" atualizado semanalmente.
• Quando você começar a usar subagentes, a produtividade muda de adição para multiplicação.
• A regra de ferro é detectar o desvio cedo e parar imediatamente. Sempre solicite evidência na primeira saída.
• Você pode desenvolver múltiplas funcionalidades simultaneamente com git worktrees + sessões paralelas.
• Configure a operação autônoma com /loop e confirme ou instrua a partir de um smartphone com o Controle Remoto.
• ultrathink é uma ferramenta dedicada para os "10% verdadeiramente difíceis". Não é para todo problema.

Se você tentar mesmo uma das funcionalidades mencionadas neste artigo, seu relacionamento com o Claude Code começará gradualmente a mudar.

Para Aqueles Interessados em Agentes de IA

O Swarm (@swarm_japan) compartilha filosofias de design essenciais e casos de uso de negócios para agentes.

Siga-nos para adquirir o conhecimento de negócios necessário para a era dos agentes de IA 👇

★ Explicando as informações mais recentes sobre agentes de IA de uma perspectiva única

★ Apresentando casos de uso de negócios para agentes

★ Publicando know-how original

Se você está interessado, por favor, siga e confira! 👀