Empurrei pra IA, inteirinha, aquela tarefa manual de 15 minutos toda manhã

Toda manhã, antes mesmo de passar o café, eu fazia a mesma coisa.

Abrir a pasta, conferir o log de ontem, olhar no olho se algum teste tinha quebrado, colar no bloco de notas os diffs que me incomodavam. Cada coisinha leva 1 minuto. Mas fazendo tudo, quando termino o café já esfriou. Todo dia. Sem falta, menos no fim de semana.

Numa manhã me ocorreu: “isso precisa ser eu fazendo?”

Já adianto a conclusão: não precisava. Hoje essa rotina é um scriptzinho que termina tudo enquanto eu lavo o rosto. E com mais capricho do que eu. Hoje vou contar essa história, mostrando o código inteiro.

“Automação” não é papo só de quem é dev

Quando você ouve “automação”, imagina logo aquelas coisas imponentes, CI/CD, pipeline de deploy. Mas o que eu quero falar é de algo bem mais sem graça.

Aquele copia-e-cola que você faz no automático, todo santo dia. Passa isso pra outro fazer.

Tipo: catar números de vários arquivos e juntar numa tabela. Arrumar uma anotação num formato fixo. Pôr lado a lado o que mudou de ontem pra hoje. Pescar as anotações que ficaram velhas. Nada disso é “pensar” — é “mexer os olhos e os dedos”. Quando é o humano que faz, ele erra, enjoa e, acima de tudo, o tempo derrete.

É aqui que a IA, mais especificamente o Claude Code, faz diferença. Só tem um ponto: não jogue tudo no colo da IA. “Faz aí, do jeito que ficar bom” é receita de acidente (já já provo com meus vacilos). Em vez disso, decida antes o alcance da leitura, o que fazer e o que é proibido encostar, e delegue só a parte repetitiva. Só isso e o mundo muda.

A propósito, essa palavra que aparece bastante por aqui, “harness”. Ao pé da letra é arreio de cavalo, mas na real é a moldura externa que impede a IA de sair do trilho. O que ela recebe de entrada, até onde pode ir, como registra e como para quando dá ruim. Decore assim: você monta essa moldura antes.

Até onde delegar e a partir de onde olhar você mesmo

Antes de delegar, trace uma linha. Uma vez só. Se você corta esse passo, parece que ficou mais rápido, mas depois você apanha. Minha recomendação é em 4 níveis.

Nível	O que delegar à IA	O que olhar você mesmo
Investigação	Resumir logs, diffs, conteúdo dos arquivos	A importância e a ordem das prioridades
Organização	Unificar formato, juntar em tabela, fazer rascunho	O juízo sobre o conteúdo e o OK final
Checagem	Apontar teste quebrado, anotação velha, diff estranho	Qual apontamento adotar
Execução	Geração e cópia padronizadas	O botão de apagar, enviar, publicar

Traçar a linha é simples. O que tem volta, delega. O que não tem volta, você aperta com o seu próprio dedo. Apagar, enviar, cobrar, publicar. Esses quatro, no começo, deixe todos no “pergunta antes pro humano”. Só promova pra automático, depois, o que você descobriu ser seguro. Se a ordem for ao contrário, você chora.

Esse jeito de traçar a linha eu aprofundo em como montar aprovação e sandbox, então vale ler junto pra cair a ficha.

Primeiro, faça rodar: delegar a checagem matinal

Chega de blá-blá, vamos pôr o troço pra rodar. Aquilo que eu fazia toda manhã — “olhar o log e os testes e anotar o que cuidar hoje” — vira um script, igualzinho. Com Node.js e uma chave de API da Anthropic, já roda.

Salve como scripts/morning-check.mjs. Deixei todos os comentários em português.

#!/usr/bin/env node
import { spawnSync } from "node:child_process";
import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";

const logDir = ".claude-logs";
const lockFile = join(logDir, "morning.lock"); // chave que impede rodar duas vezes
const stamp = new Date().toISOString().replace(/[:.]/g, "-");
const logFile = join(logDir, `morning-${stamp}.log`);

function fail(message) {
  console.error(message);
  process.exit(1);
}

// Helper pequeno que roda um comando e pega a saída como está
function run(command, args, options = {}) {
  const result = spawnSync(command, args, {
    encoding: "utf8",
    shell: process.platform === "win32", // mandinga pra funcionar também no Windows
    ...options,
  });
  const output = `${result.stdout || ""}${result.stderr || ""}`;
  if (result.status !== 0) {
    writeFileSync(logFile, output);
    fail(`Comando falhou: ${command} ${args.join(" ")} / detalhes em ${logFile}`);
  }
  return output;
}

// Se esqueceu de pôr a chave, para sem fazer nada (isto é importante)
if (!process.env.ANTHROPIC_API_KEY) {
  fail("Configure antes a ANTHROPIC_API_KEY.");
}

mkdirSync(logDir, { recursive: true });
if (existsSync(lockFile)) {
  fail(`A checagem anterior ainda está rodando: ${lockFile}`);
}
writeFileSync(lockFile, String(process.pid));

try {
  // 1. Junta o estado atual (aqui não é a IA, é só comando)
  const status = run("git", ["status", "--short"]);
  const tests = run("npm", ["test"]);

  // 2. Entrega o material à IA e pede só os pontos pra olhar hoje, em tópicos
  const prompt = [
    "Você é o meu assistente da checagem matinal.",
    "Leia o git status e o resultado dos testes abaixo e liste em tópicos o que cuidar hoje.",
    "Não altere, apague, faça commit nem envie nada de código. Só leia.",
    "Classifique em: autenticação / execução duplicada / como reverter / logs / precisa de juízo humano.",
    "",
    "git status:",
    status || "(sem mudanças)",
    "",
    "saída dos testes (só o final):",
    tests.slice(-12000), // não entrega o log inteiro; só o final já basta
  ].join("\n");

  const report = run("claude", [
    "-p", prompt,
    "--max-turns", "5",
    "--permission-mode", "plan", // modo só-leitura. não deixa reescrever
    "--output-format", "text",
  ]);

  writeFileSync(logFile, report);
  console.log(`Anotei a checagem de hoje em → ${logFile}`);
} finally {
  rmSync(lockFile, { force: true }); // ao terminar, solta a chave sem falta
}

Pra rodar, é só isto.

node scripts/morning-check.mjs

São umas poucas dezenas de linhas, mas aí dentro já estão “juntar material”, “entregar à IA”, “limitar a só leitura”, “impedir execução dupla com a chave” e “salvar log”. Esse é o esqueleto da automação. Se a sua rotina matinal for outra, é só trocar a parte do git status ou npm test pelos comandos que você costuma digitar. Escrevi pra funcionar mesmo se você só copiar sem entender o miolo, mas, quando pegar o jeito, mexa à vontade.

Onde isso faz diferença (3 casos)

1. Juntar arquivos espalhados numa folha só Sete CSVs de nota fiscal, jogados pela pasta. Todo mês eu abria isso na mão e somava. Colava um por um no Excel, somava, conferia. Uns 20 minutos. E mês passado, por causa de um erro de cópia, reportei um número com uma casa decimal trocada e depois passei a maior vergonha. Hoje é “lê todos os CSVs desta pasta e me dá numa tabela o total e só as linhas que fugiram muito da média”, e acabou. O humano, batendo na calculadora, troca uma casa; a máquina não troca. Sumiu até o trabalho de conferir.

2. Pôr lado a lado o diff de ontem e de hoje Quando você quer saber só “o que mudou” num arquivo de configuração ou numa anotação, comparando com o backup de ontem. Ler tudo de cima a baixo é um inferno. Os olhos escorregam, você não acha onde está diferente. Aí você manda catar só o diff, e “se aquilo é uma mudança que importa ou só um erro de digitação” quem julga sou eu. Não delego o juízo à IA — passo só o trabalho de achar a mudança. Os 3 minutos no olho viraram 5 segundos.

3. Arrumar anotações bagunçadas num formato fixo Aquele rabisco no meio da reunião. Datas espalhadas, sem título, cheio de erro de digitação, só setas que ninguém entende. Você pede: “formata seguindo este template que eu defini, mas não acrescenta absolutamente nada ao conteúdo”. E aqui o importante: não mande escrever do zero, mande só dar forma. Se você diz “resume aí, do jeito que ficar bom”, a IA completa por conta própria coisa que você nem disse. Bata o martelo: só a forma. Só isso e ela para de inventar.

3 vacilos que eu mesmo cometi

Vou escrever sem me fazer de bonzão. Minha primeira automação foi acidente atrás de acidente.

Primeiro. Joguei tudo no colo com “dá uma organizada aí”. Resultado: a IA “organizou” até arquivos de configuração que eu jamais deveria ter deixado encostar. O código que funcionava ficou, mas naquela manhã o sangue gelou de verdade. O .env sumiu, o serviço parou de subir, e a recuperação levou 1 hora. Desde então, passei a sempre indicar antes o alcance permitido: “só dentro desta pasta”, “neste arquivo não toca”. Você não pode esperar que a IA adivinhe.

Segundo. Enfiei o log inteiro no prompt. Achando que era gentileza, despejei dezenas de milhares de linhas; a linha do erro, que era o que importava, ficou soterrada, e a IA apontou “o problema é aqui” num lugar totalmente errado. Só inflou a conta e o tempo, e no fim tive que reler tudo na mão. Hoje, como no código aí de cima, entrego só o final com slice(-12000). O erro sai no final. E a IA também lê melhor as últimas linhas. Por isso o final basta.

Terceiro. Rodei o mesmo script em duplicidade. Errei a configuração do agendador de tarefas, e a checagem matinal disparou 2 vezes, quase ao mesmo tempo. O log foi sobrescrito e eu não sabia mais qual era o verdadeiro. O pior é quando isso é um trabalho do tipo “que escreve”. Você gera a mesma anotação 2 vezes e depois apaga a duplicata na mão. Depois que coloquei o arquivo de lock (a chave), o que chega depois leva um “a anterior ainda está rodando” e resolve de primeira. São só 3 linhas de truque, mas, sem isso, você apanha justo na manhã corrida.

Se for começar, comece por aqui

Não saia mirando o 100% automático. Escolha uma tarefa pequena que, se der errado, você não chora. A checagem matinal, a somatória de arquivos, a formatação de anotações. Esse tamanho é o ideal.

O passo a passo é sempre o mesmo. ① Definir, estreito, o alcance da leitura → ② dizer em palavras, claro, qual é a meta (o resultado pronto) → ③ deixar a conferência por conta de comandos sempre que der → ④ fixar só apagar, enviar, cobrar e publicar no “pergunta pro humano”. Só promova pra automático, depois, o que você pegou prática e descobriu ser seguro. Só de respeitar essa ordem, os acidentes caem de um jeito impressionante.

Quando bater vontade de rodar todo dia num horário fixo, cadastre no cron ou no agendador de tarefas.

# Linux/macOS: rodar às 8h15 nos dias de semana
15 8 * * 1-5 cd /path/to/repo && /usr/bin/node scripts/morning-check.mjs >> .claude-logs/cron.log 2>&1

# Windows: cadastrar no agendador de tarefas todo dia às 8:15
schtasks /Create /TN "MorningCheck" /SC DAILY /ST 08:15 /F /TR "powershell -NoProfile -ExecutionPolicy Bypass -Command \"cd C:\path\to\repo; node scripts\morning-check.mjs\""

O que olhar quando algo trava e o significado dos argumentos miúdos como --permission-mode estão na fonte primária, a referência oficial da CLI. Quando empacar, olhe primeiro ali e você evita dar voltas. Se tropeçar logo no primeiro passo, dê uma garimpada também em Claude Code: os primeiros 30 minutos.

O que aconteceu quando testei na prática

Sendo honesto: na primeira semana, o script demorava mais do que a tarefa na mão. Esquecia de pôr a chave e travava, log demais devolvia resposta estranha, o agendador simplesmente não disparava. Consertei tudo na unha.

Mas da segunda semana em diante, começou a engrenar. Hoje, de manhã, quando lavo o rosto e volto pra mesa, em .claude-logs tem só 3 a 5 linhas com o que olhar hoje. Tipo: “Testes verdes, mas esta dependência está velha”, “No diff tem um arquivo que não lembro de ter apagado, conferir”.

O que mais me deixou feliz foi ter sumido aquela “preguiça” de toda manhã. Acabou o tempo gasto repetindo a mesma coisa no piloto automático, e dei pra usar esse tempo em trabalho que de fato exige a cabeça. Em vez de caçar a IA mais esperta, ir passando pra máquina, um por um, os meus 5 minutos chatos. Sem graça, mas foi o que mais funcionou.

Resumo

Automação não é aquele papo grandioso de deploy. É fazer a máquina assumir aquele copia-e-cola que você faz no automático todo dia. Só isso.

São 3 truques. Definir estreito o alcance da leitura. Dizer em palavras o resultado pronto. Apertar com o próprio dedo só as operações sem volta. Comece rodando o script aí de cima, ajustado ao seu trabalho, e tire amanhã 5 minutinhos da sua manhã.

Se você quer aprender de forma mais estruturada, ou automatizar de uma vez o trabalho do time, na lista de materiais tem coisas pra aprender botando a mão na massa. E quem quiser conversar sobre o próprio caso pode me chamar por ali.