O Claude mudou. 15 comandos para dominar

O modelo já escreve bem, organiza e evita texto robótico sem receita. Skill longa repete o que ele já faz e ocupa contexto. Ela deve guardar só o que ele erra e o conhecimento que só você tem.

1. Faça a tarefa sem skill nenhuma, numa sessão limpa.
2. Anote só o que saiu errado ou diferente do seu jeito.
3. A skill vira essa lista: correções, nomes, caminhos, exceções do seu negócio.
4. Revise a cada troca de modelo: o que ele passou a acertar sai da skill.

Skill boa é a que melhora o resultado. A comparação é simples: a mesma tarefa com a skill e sem ela. Se não ganhar, enxugue ou apague.

1. Escreva 3 a 5 casos reais da tarefa, com o que conta como resultado bom.
2. Rode a mesma tarefa com e sem a skill (o eval de plugin já faz o braço "sem").
3. Compare a nota: perdeu ou empatou, corte linhas; continuou empatando, apague.
4. Guarde os casos: viram o teste da próxima versão da skill.

Em vez de escrever a skill, você faz a tarefa uma vez e o agente observa. Como ele só registra o que não saberia sozinho, a skill sai pequena.

1. No app desktop, use a gravação de skill e faça a tarefa como sempre faz.
2. Sem o recurso: faça a tarefa com o agente e, no fim, peça "liste só o que eu precisei corrigir".
3. Leia a skill gerada e tire o que for óbvio.
4. Passe pela dica 2 antes de adotar.

Cada modelo guarda o próprio cache da conversa. Trocar no meio faz o histórico inteiro ser lido de novo, sem desconto, e de novo na volta. Modelo menor também pode precisar de mais tentativas: barato por token não é barato por tarefa.

1. Escolha o modelo no começo do trabalho e fique nele.
2. Pergunta fácil no meio? Peça "resposta rápida, sem pensar muito" em vez de trocar.
3. Precisa de outro modelo? Abra outra sessão para aquela tarefa.
4. Fique de olho no consumo com /context e /usage.

Em vez de descer de modelo, baixe o esforço. Esforço alto não é sempre melhor: o modelo pode pensar demais e gastar à toa.

1. Deixe o esforço padrão para a maior parte do trabalho.
2. Tarefa simples e repetitiva: esforço baixo.
3. Só suba quando um problema difícil travar, e volte depois.
4. Para a sessão toda: claude --effort low|medium|high.

Um modelo mais barato faz o trabalho e consulta um mais forte só nas decisões difíceis: antes de escolher o caminho, quando o mesmo erro volta e antes de dizer que terminou. Ligar o advisor não quebra o cache da sessão.

1. Numa sessão em modelo médio, ligue o advisor com o modelo forte.
2. Deixe o agente decidir quando consultar.
3. Recurso experimental: veja se compensa no seu plano.
4. Em assinatura, ficar num modelo só costuma ser o mais simples.

Modelo, esforço, permissões e o ponto de compactar já vêm ajustados para cada modelo. Quem mexe em tudo "para melhorar" costuma piorar.

1. Comece com os padrões.
2. Só mude uma configuração quando algo der errado, e anote o motivo.
3. Mudou? Meça antes e depois (dica 2 vale aqui também).
4. Revise o que você mudou há meses: talvez já não precise.

O modelo já planeja bem sem o modo de plano. O que continua valendo é o plano para você: definir o objetivo, os limites e o que conta como pronto. Mudar um plano é muito mais barato que desfazer cem linhas.

1. Trabalho grande ou confuso: peça que o agente te entreviste e grave o plano num arquivo.
2. Comece a construção numa sessão nova, lendo esse arquivo.
3. Trabalho que cabe num parágrafo: pule o plano, escreva só objetivo, pronto e limites.
4. Quer travar edições até aprovar? Aí o modo de plano ainda ajuda.

O /goal faz o agente continuar até cumprir uma condição. Mas quem confere lê só a conversa: não abre arquivo nem roda teste. Se o agente disser "terminei", ele acredita.

1. Antes, peça ao agente um script de checagem com regras objetivas (ex.: checa.sh).
2. Escreva a condição com prova: "checa.sh passa e você mostra a saída".
3. Inclua o que não pode mudar e um limite de voltas.
4. Exemplo: /goal checa.sh passa e a saída aparece aqui; o modelo fica igual; pare em 15 voltas.

Hook roda sempre, no momento certo, sem depender da boa vontade do modelo. Agora o hook pode ser um prompt ou um agente: quando o Claude tenta parar, outro modelo olha o trabalho e diz "pode" ou "não pode, porque…". O motivo volta como próxima instrução.

1. Peça ao próprio Claude: "adicione um hook de Stop que confira X antes de deixar parar".
2. Tipo prompt: lê só a conversa, rápido e barato.
3. Tipo agente: abre arquivos e confere de verdade (experimental).
4. Use para regra que não pode falhar: "nunca mandar e-mail ao cliente, só rascunho".

Ter um milhão de tokens de espaço não quer dizer lembrar de tudo. Testes de recuperação mostram que a taxa de acerto cai quando o contexto enche. Mais janela é mais lugar para perder detalhe.

1. Guarde o contexto reutilizável em arquivos pequenos, em pastas.
2. No CLAUDE.md, ponha só ponteiros: "para X, leia pasta/x.md".
3. Trabalho longo: grave um handoff, dê /clear e retome com /prime.
4. Use /context para ver o que está ocupando espaço.

Subagente começa do zero, recebe só o que você passa e devolve só o resultado: deixa a conversa principal limpa. Fork é uma cópia da conversa: sabe tudo o que foi dito e aproveita o mesmo cache. O Claude já escolhe entre os dois sozinho.

1. Tarefa isolada (gerar uma imagem, buscar um dado): subagente.
2. Tarefa paralela que precisa de todo o histórico: fork.
3. Deixe o Claude escolher; peça fork só quando souber que precisa do histórico.
4. Lembre: subagente pode não ler o seu CLAUDE.md. Passe as regras no pedido.

Para pesquisa de verdade, o Claude monta um fluxo com vários agentes que buscam por ângulos diferentes, cruzam as fontes e descartam o que não se sustenta antes de você ver.

1. Use só quando a tarefa pede: pesquisa, comparação, verificação cruzada.
2. Antes, em /config, ponha o tamanho do workflow em pequeno (menos de cinco agentes).
3. Defina o que conta como resposta boa e as fontes aceitas.
4. Confira o custo depois da primeira rodada.

Rotinas rodam o Claude na nuvem. Além do horário, podem começar por um pedido web ou um evento do GitHub, como um pull request novo. Qualquer sistema que mande um pedido para a URL dispara o agente.

1. Crie a rotina com nome, pedido, repositório e gatilho.
2. Gatilho por API (confira na sua versão): você recebe uma URL e um token. Guarde o token como senha.
3. Deixe só os conectores que essa rotina usa.
4. Ponha a verificação (dicas 9 e 10) antes de deixar rodar sozinha.

Cada tarefa ganha uma máquina na nuvem. Você abre várias, fecha o notebook e elas continuam. Depois puxa a sessão inteira de volta para o seu computador.

1. Comece com claude --cloud "descrição da tarefa".
2. Acompanhe pelo navegador ou pelo app.
3. Traga de volta com claude --teleport.
4. Confira se o seu plano retoma a tarefa sozinho quando o limite de uso renova: se sim, ela gasta a próxima janela sem perguntar.