Descobertas de Julho — ferramentas que mudaram meu fluxo

Julho foi mês de experimentar

Julho chegou e com ele aquela sensação de que meu fluxo tava precisando de um choque. Não que as ferramentas que eu usava fossem ruins — mas cómodo não é sinônimo de eficiente. Passei o mês testando, quebrando cabeça, descartando e adotando. Esse post é o registro do que sobrou.

Três ferramentas mudaram meu jogo esse mês: UV, Codex CLI, e o ecossistema MCP. Cada uma resolveu uma dor específica que eu nem sabia que tinha.

UV: o pip que eu sempre quis

Eu sempre tive uma relação complicada com Python packaging. pip é lento, poetry é pesado, pipenv abandonou todo mundo. Minha solução era um Frankenstein de requirements.txt + virtualenvs manuais + scripts shell pra ativar cada projeto.

Aí descobri o UV — um pip/poetry escrito em Rust pela Astral (mesma galera do Ruff). Instalação em segundos:

curl -LsSf https://astral.sh/uv/install.sh | sh

Primeiro impacto: instalar dependências do Arachne (380+ pacotes) caiu de 47 segundos com pip pra 6 segundos com uv. Isso não é melhoria incremental — é outra categoria.

# Antes: pip + venv manual
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt       # 47s

# Depois: uv resolve tudo
uv sync                                # 6s
uv add fastapi                         # instala + lock
uv tool run pytest                     # sem ativar venv

Mas o que realmente me viciou foi o uv tool — executa ferramentas Python isoladas sem contaminar o ambiente global, tipo npx do Node:

uv tool run ruff check src/
uv tool run black --check .
uv tool run mypy src/ --strict

Sem virtualenv ativada, sem poluição. Perfeito pra CI e pra comandos avulsos.

O tradeoff? Lock file em formato próprio (não compatível com pip freeze). Se seu time usa pip puro, vai ter que converter. Mas pra projetos solo ou times pequenos — não tem volta.

Codex CLI: agente de código que funciona

Até julho eu usava o Hermes pra tudo — pair programming, debugging, refactor. Mas tem tarefas que não pedem agente completo, pedem ferramenta de terminal que pensa.

O Codex CLI entra nesse nicho: você dá um prompt no terminal, ele edita arquivos e executa comandos. Simples. Rápido. Zero configuração.

$ codex "refatore este arquivo para usar dataclasses em vez de dicts"

O que descobri na prática:

Tarefas cirúrgicas (refatorar uma função, adicionar teste, debug) — Codex é 3x mais rápido que abrir o Hermes e escrever prompt completo
Tarefas multi-arquivo (mudar schema, atualizar handler, testar) — Hermes ainda ganha por causa do planejamento estruturado
CI debugging — codex "por que esse teste falhou?" dentro do container CI resolve direto

Adicionei um alias no .zshrc:

alias x="codex"
alias xr="codex --repl"  # modo conversa contínua

O modo REPL é o mais útil — vira um pair programmer no terminal que mantém contexto entre comandos. Uso direto pra debugging de pipeline.

Cuidado: Codex executa comandos sem confirmação por padrão. Não rode em produção sem revisar. Se for mexer em infra, passe --dry-run primeiro.

MCP: a camada que faltava entre LLM e ferramentas

MCP (Model Context Protocol) é o protocolo da Anthropic que padroniza como LLMs se conectam com ferramentas externas. Tipo USB-C pra AI — um conector universal.

Antes, cada integração era custom: plugin do Hermes pro Telegram, REST handler pro banco, socket pro Playwright. Tudo costurado na mão. MCP muda o jogo: você escreve um servidor MCP uma vez, e qualquer cliente MCP (Hermes, Claude Desktop, Cursor, Codex) descobre e usa as ferramentas automaticamente.

O ecossistema que construí em julho:

mcp-servers/
├── filesystem/    # ler/escrever arquivos com permissões
├── github/        # PRs, issues, busca código
├── sequential-thinking/  # raciocínio estruturado
├── fetch/         # buscar páginas web
└── arachne/       # scraping, visão, transcribe, RAG → 36 tools

Cada servidor expõe tools que qualquer agente pode consumir. Quando conectei o Hermes ao MCP Arachne pela primeira vez, foi mágico:

Hermes: "busca o último post do blog e extrai os links"
→ MCP Arachne.scrape("https://samuel.me/lifelog")
→ retorna markdown limpo
→ MCP Arachne.extract_links(post_content)
→ lista de URLs
→ pronto

O Hermes não precisou saber como funcionava scraping — só pediu. O MCP fez a ponte.

Pra quem usa Hermes, configurar MCP é trivial — só adicionar no ~/.hermes/config.yaml:

mcp_servers:
  filesystem:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/samuel/projetos"]
  github:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
  arachne:
    command: python3
    args: ["-m", "arachne.mcp.server"]

Pronto. O Hermes descobre e expõe as tools na próxima interação. Sem restart, sem config extra.

O workflow que ficou

Depois de um mês de experimentação, meu fluxo do dia virou:

UV gerencia todos os ambientes — um uv sync e tô rodando
Codex CLI pras tarefas rápidas — debug, refactor local, CI
Hermes + MCP pras tarefas complexas — multi-arquivo, deploy, orquestração
Lifelog registra o que funcionou (igual esse post)

# Exemplo real: debugar + arrumar + publicar
codex "corrige o bug de timezone no agendador"     # 30s → arruma
hermes "roda os testes, faz deploy da hotfix"       # 2min → testa + deploy

Cada ferramenta no seu nicho. Nenhuma resolvendo tudo sozinha.

Aprendizados

Ferramenta certa no lugar certo — não adianta ter um canivete suíço se você precisa de uma chave de fenda. Codex pra micro-tarefas, Hermes pra macro. UV pra pacotes, pip nada.
MCP é o futuro da integração — protocolo aberto, qualquer cliente, qualquer servidor. O ecossistema que construí em julho já me salvou horas. Se você usa LLMs no terminal, MCP não é opcional — é infraestrutura.
Documentar a descoberta dobra o aprendizado — esse post existe porque cada ferramenta nova veio com um “hm, vou anotar isso”. Duas semanas depois, tenho um registro do que funcionou, o que não funcionou e por quê. Recomendo fazer o mesmo.

Para o próximo mês quero explorar ferramentas de visualização de dados e talvez um pouco de Rust — a TatuEngine pede. Mas isso é história pra agosto.