É 31 de março de 2026. Você acordou, abriu o notebook e passou 30 minutos lendo código que outra pessoa escreveu. Depois 20 minutos criando testes que nunca mais vai olhar. Depois 15 minutos compondo um e-mail que diz "conforme mencionado anteriormente" de quatro jeitos educados diferentes. Depois mais uma hora domando uma planilha rebelde.

Você não fez nada que importa, e já é hora do almoço. 😼

A conta desconfortável: você está queimando mais de 50 horas por mês em tarefas que uma IA resolve por aproximadamente 65 centavos de dólar. Não com alguma ferramenta mágica que vai lançar no próximo trimestre — com comandos que você digita no terminal agora mesmo. Este guia traz os scripts exatos, custos e ressalvas. Copia, cola e recupera sua agenda.

Categoria 1: Tarefas de código

Code review

O jeito antigo: Você lê cada PR — pull request, ou seja, as alterações de código que alguém propôs — procurando por estilo, bugs, falhas de segurança e edge cases esquecidos. São 15 a 60 minutos por PR, e seus olhos já vidram no terceiro.

O jeito novo:

claude "Review the diff in the last commit. Check for:
  1. Security vulnerabilities
  2. Performance issues
  3. Missing error handling
  4. Logic bugs
  5. Style inconsistencies
Report findings with severity (critical/warning/info)."

Ou conecte ao CI — integração contínua, o sistema que testa automaticamente seu código quando você faz push. Aqui vai um workflow de GitHub Actions que revisa cada PR automaticamente:

name: AI Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Review with Claude
        run: |
          DIFF=$(git diff origin/main...HEAD)
          jq -n --arg diff "$DIFF" '{
            "model": "claude-haiku-4.5",
            "max_tokens": 2000,
            "messages": [{
              "role": "user",
              "content": ("Review this code diff for bugs, security issues, and style problems. Be concise.\n\n" + $diff)
            }]
          }' | curl -s -X POST https://api.anthropic.com/v1/messages \
            -H "x-api-key: ${{ secrets.ANTHROPIC_API_KEY }}" \
            -H "anthropic-version: 2023-06-01" \
            -H "content-type: application/json" \
            -d @- > review.json

Custo: ~$0.002 por review com Claude Haiku. Isso dá $0.06/mês com um PR por dia.

Checagem de realidade: Pega cerca de 70% do que um revisor humano encontraria. Não entende lógica de negócio e não tem gosto arquitetural. Mas acerta o arroz com feijão — null checks, race conditions, padrões de segurança — justamente porque não cansa. 😸

Geração de testes

O jeito antigo: Você escreve testes na mão, ou sendo mais honesto, pula porque dá preguiça. 30 a 60 minutos por módulo quando se dá ao trabalho.

O jeito novo:

claude "Read src/auth/ and write comprehensive tests for the login flow.
Cover: happy path, wrong password, account locked, rate limiting,
SQL injection in email field, missing fields.
Use pytest. Mock the database. Output to tests/test_auth.py."

Custo: ~$0.01 por módulo com Sonnet. Testes gerados são verbosos mas completos — testam edge cases que você pularia porque "quem digita um e-mail de 10 mil caracteres?" Alguém vai.

Refatoração

O jeito antigo: Renomear uma função em 30 arquivos. Migrar de um ORM — mapeador objeto-relacional, a camada entre seu código e o banco de dados — para outro. Horas a dias.

O jeito novo:

claude "Refactor the codebase to replace all direct SQL queries with
Supabase client calls. ~15 files using raw SQL.
For each file:
1. Replace the SQL query with the equivalent Supabase call
2. Update the imports
3. Update error handling to match Supabase patterns
4. Run the tests to verify"

Custo: $0.10–0.50 para uma refatoração grande. Claude Code lê todos os arquivos, entende os padrões e aplica as mudanças de forma consistente. Mas revise o diff antes de commitar — sempre. 😾

Categoria 2: Conteúdo e comunicação

Rascunho de e-mails

O jeito antigo: Encarar a tela em branco. Escrever. Reescrever. Reescrever de novo. 10 a 30 minutos por e-mail importante.

O jeito novo: Um script Python minúsculo usando a Anthropic API — a interface de programação que permite seu código conversar com o Claude:

import anthropic

client = anthropic.Anthropic()

def draft_email(context: str, tone: str = "professional") -> str:
    response = client.messages.create(
        model="claude-haiku-4.5",
        max_tokens=1000,
        messages=[{
            "role": "user",
            "content": f"""Draft an email based on this context:
{context}

Tone: {tone}
Rules:
- Get to the point in the first sentence
- No filler phrases ("I hope this email finds you well")
- Under 150 words
- Clear call to action at the end"""
        }]
    )
    return response.content[0].text

python email_drafter.py "Declining a meeting invite from VP of Marketing
about Q3 planning because I have a conflicting deadline. Suggest async
alternative. Tone: friendly but firm."

Custo: ~$0.001 por e-mail. Essencialmente de graça.

Documentação

O jeito antigo: Ninguém escreve documentação. O README diz "TODO." Diz "TODO" desde 2024.

O jeito novo:

claude "Read every file in src/. Generate:
1. A README.md with project overview, setup instructions, and architecture
2. Inline docstrings for every public function missing one
3. An API.md documenting every endpoint in src/routes/

Be accurate — read the code, don't guess."

Custo: $0.05–0.20 dependendo do tamanho do codebase. Documentação gerada por IA é prolixa, mas precisa. Descreve o que o código faz corretamente. Não vai explicar por que o código existe — isso é com você. Mas "preciso e verboso" ganha de "inexistente" todo santo dia.

Changelog e release notes

git log --oneline v1.2.0..HEAD | claude "Convert these commits
into user-facing release notes. Group by: New Features, Bug Fixes,
Improvements. Ignore internal refactoring. Write for end users,
not developers."

Custo: ~$0.001. Essa nem deveria exigir reflexão.

Categoria 3: Processamento de dados

Limpeza de CSV

O jeito antigo: Abrir o Excel. Corrigir formatação. Remover duplicatas. Padronizar datas. 30 minutos a 2 horas de tédio destruidor de almas.

O jeito novo:

import anthropic

client = anthropic.Anthropic()

def clean_csv(filepath: str, instructions: str) -> str:
    with open(filepath) as f:
        data = f.read()
    response = client.messages.create(
        model="claude-haiku-4.5",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"""Clean this CSV data:
{instructions}

Data:
{data[:3000]}

Return the cleaned CSV. Maintain the header row."""
        }]
    )
    return response.content[0].text

python clean_csv.py contacts.csv "Standardize phone numbers to +55-XX-XXXXX-XXXX.
Remove duplicate emails (keep the row with more data).
Fix obvious city name typos. Convert dates to YYYY-MM-DD."

Custo: ~$0.005 por arquivo.

Relatórios semanais

O jeito antigo: Consultar o banco, exportar pra planilha, fazer gráficos, escrever comentários. 2 a 4 horas toda semana.

O jeito novo:

import anthropic, subprocess
from datetime import datetime

client = anthropic.Anthropic()

data = subprocess.run(
    ["psql", "-c", "SELECT * FROM weekly_metrics", "--csv"],
    capture_output=True, text=True
).stdout

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2000,
    messages=[{
        "role": "user",
        "content": f"""Generate a weekly business report from this data:
{data}

Include:
- Executive summary (3 sentences)
- Key metrics with week-over-week changes
- Notable trends or anomalies
- Recommended actions

Format as markdown."""
    }]
)

with open(f"reports/weekly-{datetime.now():%Y-%m-%d}.md", "w") as f:
    f.write(response.content[0].text)

Agende com cron — a ferramenta nativa que executa scripts em um timer:

# crontab -e
0 9 * * MON python3 /path/to/weekly_report.py

Custo: $0.02 por relatório. $0.08/mês para uma cadência semanal. 😸

Categoria 4: Administração de sistemas

Análise de logs

O jeito antigo: grep -r "ERROR" /var/log/ e depois ficar encarando 200 linhas de stack traces fingindo que entende o padrão. 30+ minutos.

O jeito novo:

tail -200 /var/log/app/error.log | claude "Analyze these error logs.
Group by error type. Identify the root cause of the most frequent error.
Suggest a fix with code if possible."

Custo: ~$0.003 por análise.

Scripts de monitoramento

claude "Write a bash script that:
1. Checks if nginx is running, restarts if not
2. Checks disk usage, alerts if > 80%
3. Checks SSL cert expiry, alerts if < 14 days
4. Checks main API endpoint responds with 200
5. Sends alerts to a Telegram bot
6. Runs every 5 minutes via cron

Use curl for HTTP checks. Use openssl for cert checks.
Include the cron line at the top as a comment."

Script de monitoramento funcional em 30 segundos. Revise, teste, faça deploy. Custo: ~$0.003, uma única vez, por um script que vai rodar por meses.

Categoria 5: Pesquisa e decisões

Avaliação de tecnologia

O jeito antigo: 20 abas no navegador, três artigos comparativos de 2023, uma thread no Reddit que vira briga sobre Rust. 2 a 4 horas por decisão.

O jeito novo:

claude "I need a message queue for a Python backend.
Requirements: ~10K messages/day, dead letter queue,
works with Supabase, team of 1.

Compare: Redis Streams, RabbitMQ, SQS, Supabase Queues.
For each: pricing at my scale, setup complexity,
Python SDK quality, gotchas. Give me a recommendation."

Custo: ~$0.005 com Sonnet. Comparação melhor do que 2 horas alternando entre abas.

Ressalva: Sempre confira os valores de preço de forma independente. IA pode estar desatualizada em custos específicos. O framework de análise é sólido; os valores em dólar precisam de uma checagem rápida. 😾

O relatório de danos

Tarefa Tempo manual Tempo com IA Custo IA/mês Horas salvas/mês
Code review (1/dia) 30 min 2 min $0.06 9.3
Geração de testes (2/semana) 45 min 5 min $0.08 5.3
Rascunho de e-mails (3/dia) 15 min 1 min $0.09 14.0
Documentação 4 horas 15 min $0.20 3.75
Changelog (2/mês) 30 min 2 min $0.002 0.9
Limpeza de CSV (2/semana) 30 min 3 min $0.04 3.6
Relatório semanal 2 horas 5 min $0.08 7.7
Análise de logs (diária) 15 min 2 min $0.09 6.5
Total ~$0.65 ~51 horas

Sessenta e cinco centavos. Cinquenta e uma horas. Seis dias úteis de volta todo mês. Não é erro de digitação.

O que NÃO automatizar (ainda)

Algumas coisas que a IA ainda faz mal em março de 2026:

  • Qualquer coisa que exija empatia real — e-mails de desculpa a clientes, conversas de demissão, assuntos sensíveis de RH. A IA pode rascunhar; um humano precisa revisar e enviar.
  • Decisões estratégicas — IA pode analisar dados e apresentar opções, mas "devemos pivotar?" fica com você.
  • Documentos jurídicos — IA pode rascunhar, mas nunca publique texto legal sem os olhos de um advogado.
  • Trabalho criativo de marca — IA gera opções, mas voz de marca e direção criativa precisam de gosto humano.
  • Código crítico de segurança — IA pode escrever, mas caminhos críticos de segurança precisam de um humano que entenda o modelo de ameaças.

O padrão: IA cuida dos 80% que são repetitivos e estruturados. Os 20% que exigem julgamento, empatia ou responsabilidade ficam com você. Automatize os 80%, concentre sua energia nos 20% que realmente importam.

Agora faz alguma coisa

Lembra daquela manhã do começo do texto? Aquela em que você queimou metade do dia com trabalho operacional? Aquela manhã é opcional. 😹

O maior obstáculo não é técnico — todo script acima funciona hoje. É psicológico. "Eu deveria fazer isso eu mesmo" parece responsável. Mas gastar uma hora formatando um CSV não é responsabilidade — é procrastinação disfarçada. Você está se escondendo no trabalho braçal em vez de fazer as coisas difíceis que só você pode fazer: conversar com clientes, tomar decisões de produto, fechar negócios.

Escolha uma automação deste guia. Só uma. Configure essa semana. Sinta como muda seu dia. Depois automatize a próxima. No final do mês, você vai se perguntar por que fazia qualquer uma dessas coisas na mão — e vai ter 51 horas de prova de que estava certo em parar. 😼