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

Por que Seu Fluxo de Trabalho Não Mudou Apesar de Usar o Claude Code Diariamente

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

Isso soa familiar para você? Você instalou o Claude Code, passou os primeiros dias configurando-o e conversa com ele diariamente. No entanto, comparado a três meses atrás, a estrutura do seu trabalho permanece 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 todas as manhãs, obtendo respostas semelhantes e copiando-as para o seu trabalho. Você pode até ser 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 maneira totalmente 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 das lentes 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ê terá 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 desleixada. 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 todas as manhãs". Se você está jogando as mesmas tarefas no chat todas as manhãs, 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 ver 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, cada conversa começa do zero.

A primeira coisa a executar é o `/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 "modelo" do projeto.

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

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

Uma linha de status aparecerá na parte inferior da tela. Você pode visualizar o que está sendo executado e quais processos estão ativos. Também pode ser integrado com linhas de status personalizadas no Vim ou Neovim, permitindo que você o 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 "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 o `/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 modelo inicial tende a desaparecer. Este comando permite que você monitore isso.

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

O /compact comprime todo o contexto em um resumo. O /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 o /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 plano (`Shift+Tab`).

Antes de grandes mudanças, este modo gera "apenas o plano" em vez de executar. Você pode verificar o que o Claude pretende mudar e em que ordem antecipadamente.

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 a usá-lo, perceberá que reduz o esforço de verificar "por que este arquivo foi reescrito?" depois do fato.

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

Se você apenas disser "corrija o bug", o Claude tentará 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 muda a taxa de resoluções na primeira tentativa. A forma como você passa o problema se torna uma habilidade.

Terceiro é o `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 geralmente acontece quando esta funcionalidade não é usada. É um design que paga o custo da confirmação antes da implementação.

Quarto é o passo de autoverificação.

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

Tomar medidas proativas com o modo de plano e automatizar passos reativos 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 se 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, inevitavelmente ficará preso. 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 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 segurar o procedimento.

11. Habilidades Personalizadas (Arquivos de Modelo 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 Modelo 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 /competitive-research em uma linha.

O tempo gasto escrevendo as mesmas instruções repetidamente desaparece. Se compartilhado com uma equipe, torna-se um modelo 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 conceituais, 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 custo quanto a velocidade de resposta simultaneamente.

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

Se você disser ao Claude para "adicionar o que aprendeu neste projeto ao CLAUDE.md", o Claude atualizará o CLAUDE.md por conta própria. É uma estrutura onde o modelo 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 a delegação significa criar um sistema que entrega o sujeito ao Claude. Quando procedimentos, modelos, referências e memória estão todos em vigor, 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 ao Claude aumenta, um problema se torna mais provável: perceber que ele foi 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 de design proativas.

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 de 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-me apenas a primeira saída primeiro, e eu decidirei se devo continuar" 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 começando 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 for concluída.

Configure uma vez. A partir de então, 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, causa e sugestões de correção como estão. É concluído 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 são executados em paralelo e integrados.

Operação e Integração em Paralelo

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

Comece com a integração do Chrome DevTools. Como você pode passar logs de erro do navegador e logs de rede diretamente para o Claude Code, 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 que 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 é 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 pensamentos sobre MCP. Um servidor MCP nem sempre é a solução ideal. A documentação oficial afirma que "ferramentas CLI são a forma mais eficiente em termos de contexto para interagir com serviços externos", e ferramentas CLI como gh ou aws são ditas ter alta eficiência de contexto e são 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 porque o design muda para passar múltiplos sujeitos ao Claude simultaneamente. Em seguida, evoluiremos esse 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 pergunta 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 está 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 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 que você recupere dados usando português (ou inglês) como "diga-me 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 que você delegue rotinas de confirmação de dados ao Claude sem escrever SQL.

Existem também quatro funcionalidades para controlar a profundidade do pensamento. ultrathink aciona 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 cada consulta inflará os custos inutilmente.

/effort ultracode é uma configuração para habilitar raciocínio xhigh 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 em toda a sessão" 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 em um chat para movê-lo, alcançou o gateway 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 surge essencialmente através de todas essas funcionalidades.

Por Que os Resultados Diferem com o Mesmo Claude Code

Pessoas que desenvolvem rapidamente não têm necessariamente 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 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 todos os 27 de uma vez.

Na primeira semana, reduza para apenas quatro.

• Crie um mapa do projeto com /init.
• Comprima periodicamente o contexto com /compact.
• Separe exploração e execução com o modo de plano (Shift+Tab).
• Passe passos 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 em design e 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 todos os problemas.

Seguindo esses 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 uma forma que você possa salvar e consultar.

• Os quatro itens—/init + /compact + modo de plano + 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 "modelo 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ências 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 de um smartphone com o Controle Remoto.
• ultrathink é uma ferramenta dedicada para os "10% verdadeiramente difíceis". Não é para todos os problemas.

Se você tentar até 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! 👀