IA em Foco

Tag: Claude Code

  • Claude-Mem: a “memória infinita” que faz o Claude Code lembrar do que já fez

    Claude-Mem: a “memória infinita” que faz o Claude Code lembrar do que já fez

    Meta description: Conheça o Claude-Mem, a camada de memória persistente para Claude Code que registra o que o agente fez, comprime o histórico com IA e injeta apenas o contexto relevante nas próximas sessões.

    Claude-Mem: a “memória infinita” que faz o Claude Code lembrar do que já fez

    Se você já usou um assistente de programação por mais de uma sessão, provavelmente viveu este cenário: o trabalho anda, a conversa cresce, e depois o sistema parece esquecer decisões importantes. O Claude-Mem foi criado para resolver exatamente isso. Ele adiciona uma camada de memória persistente ao Claude Code — e também a outras ferramentas compatíveis — para que o agente consiga continuar projetos sem começar do zero a cada nova conversa.

    Em linguagem simples: o Claude-Mem guarda o que foi aprendido, organiza esse histórico de forma inteligente e devolve só o que importa quando o trabalho continua. O resultado é um uso muito mais eficiente do contexto e, consequentemente, menos desperdício de tokens. A documentação do projeto destaca uma abordagem em camadas que pode trazer cerca de 10x de economia em relação a métodos tradicionais. Em situações práticas, isso ajuda bastante a reduzir custo, ruído e retrabalho — e pode chegar muito perto daquela sensação de “quase não gastei contexto nenhum”.

    O problema que ele resolve

    Modelos de IA são ótimos para raciocinar, mas têm um problema estrutural: o contexto é limitado e caro. Se você coloca tudo dentro da janela de conversa, gasta tokens demais. Se coloca pouco, o agente esquece. O Claude-Mem tenta resolver justamente essa tensão com uma ideia simples:

    • registrar tudo o que importa ao longo da sessão;
    • compactar esse material para não desperdiçar tokens;
    • recuperar só o que faz sentido na hora de continuar o trabalho.

    Isso é especialmente útil em tarefas longas, como manutenção de código, debugging em múltiplas etapas, revisões de arquitetura, investigação de bugs históricos e projetos que avançam em várias sessões ao longo de dias ou semanas.

    Como o Claude-Mem funciona por dentro

    De acordo com a documentação oficial, a arquitetura do projeto combina alguns blocos centrais:

    • Hooks de ciclo de vida que observam o que acontece durante a sessão;
    • Worker service local, com API HTTP e interface web em http://localhost:37777;
    • Banco SQLite para armazenar sessões, observações e resumos;
    • Busca híbrida, unindo indexação textual e vetorial;
    • MCP search tools para consultar a memória de forma progressiva e econômica.

    O ponto mais interessante é o fluxo de consulta em três níveis:

    1. Search — traz um índice compacto com IDs e pistas rápidas;
    2. Timeline — mostra o contexto cronológico ao redor de um ponto relevante;
    3. Get observations — abre o detalhe completo apenas do que realmente importa.

    Esse desenho evita o erro clássico de “carregar tudo por via das dúvidas”. Em vez disso, o sistema começa pequeno, filtra bem e só aprofunda quando necessário.

    Quais são as funcionalidades mais fortes

    1. Memória persistente entre sessões

    O grande valor do Claude-Mem é manter o histórico útil vivo mesmo depois que a sessão termina. Isso reduz repetição, evita que o agente peça de novo as mesmas informações e ajuda a manter coerência em projetos longos.

    2. Progressive disclosure

    Em vez de despejar todo o histórico no prompt, o Claude-Mem revela o contexto em camadas. Isso melhora a eficiência e mantém o uso de tokens sob controle.

    3. Busca semântica e cronológica

    O projeto não depende só de palavras-chave. Ele também permite navegar por contexto temporal e por observações detalhadas, o que facilita encontrar decisões antigas, mudanças de rota e causas de bugs.

    4. Interface web local

    O worker service expõe uma UI web local, o que ajuda a inspecionar a memória, acompanhar o que foi armazenado e entender como o contexto está sendo recuperado.

    5. Privacidade e controle

    O Claude-Mem inclui recursos para controlar o que entra na memória, inclusive com tags <private> para excluir conteúdos sensíveis do armazenamento.

    6. Compatibilidade ampla

    Embora a vitrine principal seja o Claude Code, o projeto também conversa com outras ferramentas e ecossistemas, como Gemini CLI, OpenCode, Cursor e integrações via MCP.

    Por que ele economiza tantos tokens?

    A resposta está no método. Em vez de resgatar o passado inteiro a cada nova consulta, o Claude-Mem usa um funil de recuperação:

    • primeiro encontra o que parece relevante;
    • depois mostra o contexto ao redor;
    • só então abre os detalhes.

    Na documentação, o projeto descreve esse modelo como uma forma de alcançar ~10x de economia de tokens em comparação com abordagens tradicionais de RAG que tentam carregar muito conteúdo logo de início. Em uso real, isso pode ser ainda mais valioso quando o agente lida com sessões grandes, porque o ganho não é apenas financeiro: o modelo também tende a ficar mais rápido, mais focado e menos confuso.

    Em resumo: menos contexto irrelevante significa menos custo, menos ruído e mais chance de o agente acertar a próxima ação.

    Como instalar o Claude-Mem

    A forma mais direta de instalar é via npx:

    npx claude-mem install

    Se você usa o Gemini CLI, o instalador também detecta a pasta correta automaticamente:

    npx claude-mem install --ide gemini-cli

    Para o OpenCode:

    npx claude-mem install --ide opencode

    Há também instalação pela marketplace de plugins dentro do Claude Code:

    /plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

    Depois da instalação, é preciso reiniciar o Claude Code ou a CLI compatível para que a memória comece a aparecer automaticamente nas novas sessões.

    Requisitos e dependências

    • Node.js 20+
    • Claude Code com suporte a plugins
    • Bun para o worker service
    • uv para partes da busca vetorial
    • SQLite 3 para persistência local

    Ou seja: não é só um “prompt hack”. É uma camada de memória de verdade, com persistência local e serviços auxiliares para consulta e recuperação de contexto.

    Como usar no dia a dia

    Na prática, o uso é quase invisível. O sistema observa a sessão, registra o que aconteceu e vai alimentando a memória. Quando você retoma um trabalho depois, ele tenta recuperar o que interessa sem você precisar refazer todo o briefing.

    Para buscas mais específicas, a documentação mostra exemplos como:

    search(query="authentication bug", type="bugfix", limit=10)

timeline(anchor=<observation_id>, depth_before=3, depth_after=3)

get_observations(ids=[123, 456, 789])

    Esse trio é o coração da experiência. Primeiro você encontra, depois contextualiza, por fim aprofunda.

    Casos de uso em que ele brilha

    • Debugging longo — quando um erro leva várias etapas para ser resolvido;
    • Refatorações grandes — quando decisões antigas precisam ser lembradas com precisão;
    • Code archaeology — para entender por que algo foi feito de determinada forma;
    • Projetos multi-sessão — quando o trabalho se estende por dias ou semanas;
    • Times e agentes múltiplos — quando vários fluxos precisam acessar o mesmo histórico de forma eficiente.

    Limitações e cuidados

    Apesar do nome chamativo, o Claude-Mem não é magia. Ele ajuda muito, mas ainda depende de alguns cuidados:

    • nem tudo deve ir para a memória — conteúdo sensível precisa ser excluído ou marcado como privado;
    • o ganho real depende do fluxo — quanto mais você evita carregar contexto inútil, maior o benefício;
    • instalação e integração exigem ambiente compatível — Node, Bun, SQLite e a CLI certa;
    • memória não substitui disciplina — uma boa organização de projeto ainda faz diferença.

    Vale a pena?

    Se você usa Claude Code com frequência e trabalha em tarefas que ultrapassam uma sessão, a resposta curta é: sim, vale muito a pena testar. O Claude-Mem ataca um problema real de produtividade para quem vive de contexto técnico. Ele reduz repetição, melhora continuidade, ajuda a recuperar decisões antigas e pode cortar de forma expressiva o gasto com tokens.

    O melhor cenário é justamente aquele em que você alterna entre explorar, resolver, revisar e continuar. Nessa rotina, ter uma memória persistente muda o jogo.

    Conclusão

    O Claude-Mem mostra que a próxima fronteira dos agentes de IA não é apenas “responder melhor”, mas lembrar melhor. Em vez de depender de prompts cada vez maiores, ele organiza o conhecimento em camadas, recupera o que importa e mantém a continuidade entre sessões. Para quem usa Claude Code como copiloto de desenvolvimento, isso pode representar um salto enorme em eficiência — inclusive na economia de tokens.

    Se a promessa de até 95% de redução soa exagerada à primeira vista, o ponto principal continua sendo válido: quanto mais inteligente for a recuperação do contexto, menos você paga para repetir o que já foi aprendido.

    Fonte: github.com/thedotmack/claude-mem

  • Claude Code 2026: Guia Completo com 25 Funcionalidades, Exemplos e Demo Interativa

    Claude Code 2026: Guia Completo com 25 Funcionalidades, Exemplos e Demo Interativa

    O Claude Code começou como um assistente de codificação no terminal. Hoje, ele opera como um sistema agêntico em camadas — separando memória, hooks, skills, subagentes, plugins e MCP em camadas distintas que mudam o que o modelo pode ver ou fazer.

    Este artigo do MarkTechPost cobre 25 funcionalidades e estratégias para escalar o Claude Code, voltado para engenheiros de IA, engenheiros de software e cientistas de dados. Cada exemplo de código segue um formato documentado e roda conforme escrito.

    O que é o Claude Code

    O Claude Code é a ferramenta de codificação agêntica da Anthropic. Funciona no terminal, no app desktop e na IDE. Ele lê arquivos, executa comandos, edita código e chama ferramentas externas. Por baixo dos panos, roda um loop agêntico que escolhe ferramentas, acumula contexto e gerencia sessões longas via compactação.

    As 25 Funcionalidades e Estratégias

    Cada funcionalidade é rotulada como Oficial (documentada pela Anthropic), Técnica da Comunidade (padrão de workflow) ou Ferramenta de Terceiros.

    1. Arquivo de memória CLAUDE.md (Oficial)

    O arquivo que serve como “constituição” do agente para seu repositório. O Claude lê em toda sessão para ancorar convenções e comandos.

    2. Skills (Oficial)

    Uma skill é um arquivo SKILL.md com frontmatter em .claude/skills/<nome>/. Suporta invocação por /nome e invocação autônoma pelo Claude.

    3. Subagentes (Oficial)

    Instâncias especializadas com janelas de contexto próprias. Trabalho verboso fica isolado, mantendo a conversa principal focada.

    4. Slash Commands (Oficial)

    Atalhos digitados começando com /. Os built-ins incluem /init, /compact, /context, /review e /security-review.

    5. Hooks (Oficial)

    Scripts determinísticos que disparam em pontos definidos do ciclo de vida. O PreToolUse é o checkpoint de segurança principal antes de qualquer ferramenta rodar.

    6. Servidores MCP (Oficial)

    O Model Context Protocol conecta o Claude Code ao GitHub, bancos de dados e navegadores. O servidor gerencia a integração; o Claude raciocina sobre o que fazer.

    7. Plugins (Oficial)

    Um plugin é um bundle versionado de skills, subagentes, comandos, hooks e definições MCP. Um comando /plugin instala o conjunto completo.

    8. Checkpoints (Oficial)

    O Claude Code tira snapshots automáticos do estado antes de alterações. Pressione Escape duas vezes para voltar quando algo quebrar.

    9. Modo Planejamento (Oficial)

    Explora e propõe sem executar. Ideal para definir escopo antes de commitar edições.

    10. Modos de Permissão (Oficial)

    O modo padrão pergunta antes de cada escrita em arquivo e comando shell. Outros modos trocam supervisão por velocidade.

    11. Auto Mode (Oficial, research preview)

    Um classificador separado Sonnet 4.6 revisa cada ação primeiro. Ações seguras prosseguem; arriscadas são bloqueadas ou escaladas.

    12. Compactação de Contexto (Oficial)

    /compact condensa sessões longas preservando contexto útil. /context reporta o uso atual de contexto.

    13. Tarefas em Background (Oficial)

    Comandos shell longos rodam com flag run_in_background na ferramenta Bash. O Claude consulta a saída sem bloquear a conversa.

    14. Agent SDK (Oficial)

    O SDK expõe o mesmo loop programaticamente via query(). É possível enviar slash commands como /code-review e processar resultados.

    15. CLI Headless (Oficial)

    claude -p "consulta" roda um processo one-shot e sai. Input via pipe como cat logs.txt | claude -p também funciona.

    16. GitHub Action e Jobs Agendados (Oficial)

    O Claude Code roda como processo one-shot sem TTY. Isso habilita integração CI, jobs agendados e pre-commit hooks.

    17. Estilos de Output e statusLine (Oficial)

    Estilos de output alteram a formatação de respostas. Um renderer statusLine customizado expõe o estado da sessão no terminal.

    18. Controle Remoto e Push Mobile (Oficial)

    É possível pilotar o Claude Code do mobile ou web. O Claude pode enviar notificações push quando tarefas terminam.

    19. Away Summary (Oficial)

    Recurso de sessão que resume o contexto quando você retorna a uma sessão pausada. Habilitado por padrão.

    20. Sandboxing (Oficial)

    A ferramenta Bash com sandbox impõe isolamento de filesystem e rede a nível de SO. Comandos rodam sem prompts dentro dos limites definidos.

    21. Pastas de Contexto Estruturadas (Técnica da Comunidade)

    Organize pastas específicas para diretrizes de marca, dados de cliente ou terminologia jurídica. O contexto certo carrega para cada tarefa.

    22. Workflows Dinâmicos (Técnica da Comunidade)

    Divida tarefas complexas em etapas menores usando subagentes. Padrões comuns incluem “classificar e agir” e “distribuir e sintetizar”.

    23. Pipelines de Skills Modulares (Técnica da Comunidade)

    Encadeie skills reutilizáveis em workflows ponta a ponta. Um pipeline de suporte combina categorização, geração de respostas e skills de escalação.

    24. Camadas de Memória Externa (Ferramenta de Terceiros)

    Ferramentas como Mem Search ou Hermes estendem a recordação em projetos longos. Ficam fora da memória built-in do Claude Code.

    25. Técnicas de Resiliência (Técnica da Comunidade)

    Praticantes resetam e reexecutam tarefas quando a qualidade do output degrada. Isso evita poluição de contexto e mantém resultados consistentes.

    Como os Primitivos de Extensibilidade se Comparam

    Primitivo Onde vive Como roda Contexto isolado? Ideal para
    Slash command .claude/commands/ Digitado /nome Não Template de prompt
    Skill .claude/skills/<nome>/SKILL.md /nome ou autônomo Opcional (via subagente) Lógica de domínio com arquivos
    Subagente .claude/agents/ Auto-delegate ou @agent-name Sim, janela própria Tarefas isoladas e paralelas
    Hook Settings, skill ou subagente Event-driven no ciclo de vida Código determinístico Impor regras sem alucinação
    MCP server .mcp.json ou claude mcp add Chamadas de ferramenta Processo externo GitHub, bancos, navegadores
    Plugin Instalado via /plugin Agrupa todos acima Herda escopo do componente Compartilhar setups entre times

    Casos de Uso com Exemplos

    Onboarding em codebase: Junte-se a um time novo e rode um subagente Explorer. É somente leitura, mapeando o repo sem editar arquivos.

    Code review automatizado: Rode /review para feedback geral ou /security-review para vulnerabilidades. Nos planos Team e Enterprise, a revisão multi-agente divide o trabalho entre subagentes.

    Refatorações noturnas: Habilite o Auto Mode para tarefas com escopo claro em ambiente isolado. Combine com tarefas em background e checkpoints.

    Classificação de feedback de clientes: Construa um workflow dinâmico “classificar e agir”. O Claude lê feedback, categoriza respostas e gera insights em uma passada.

    Integração contínua: Use o CLI headless dentro de uma GitHub Action. Rode claude -p em cada pull request para lint, teste ou sumarização de diffs.

    Exemplos de Código

    CLAUDE.md mínimo:

    # Project: my-tool
## Build
npm run build
## Test
npm test
## Conventions
- TypeScript strict mode
- No default exports
- Commit format: feat/fix/chore(scope): description

    Skill de exemplo:

    ---
name: code-review
description: Review changed files against team standards.
---
Review staged changes. Flag risks. Suggest concrete fixes.

    Subagente read-only:

    ---
name: explorer
description: Read-only codebase exploration.
tools: Read, Grep, Glob
---
Map the repository structure and summarize entry points.

    Hook PreToolUse:

    {
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "scripts/guard.sh" }
        ]
      }
    ]
  }
}

    Conclusão

    O Claude Code é um sistema agêntico em camadas — não um simples prompt de chat. Seis primitivos impulsionam a extensibilidade: CLAUDE.md, skills, subagentes, slash commands, hooks e MCP. O Auto Mode é um modo de permissão em research preview controlado por um classificador Sonnet 4.6.

    Dica: nem toda funcionalidade associada ao “Claude Code” é oficial da Anthropic — algumas dependem de ferramentas de terceiros ou técnicas da comunidade.

    Fonte: MarkTechPost – Claude Code Guide 2026: 25 Features with Examples + Demo, por Michal Sutter.

  • Databricks Lança Omnigent: O Meta-Harness Open Source que Unifica Claude Code, Codex e Pi

    Databricks Lança Omnigent: O Meta-Harness Open Source que Unifica Claude Code, Codex e Pi

    A Databricks acaba de lançar um projeto que pode mudar a forma como engenheiros trabalham com agentes de IA. Omnigent é um “meta-harness” open source — uma camada de abstração acima dos harnesses existentes como Claude Code, OpenAI Codex e Pi — que permite compor, governar e compartilhar agentes de IA a partir de uma única interface unificada.

    O projeto foi anunciado por Matei Zaharia (criador do Apache Spark) e Kasey Uhlenhuth, e está disponível sob a licença Apache 2.0 no GitHub em omnigent-ai/omnigent. Foi desenvolvido em colaboração com a Neon.

    O problema que o Omnigent resolve

    Engenheiros hoje usam 4 ou 5 agentes simultaneamente — copiando texto entre Claude Code, Codex, ferramentas de busca, documentos e Slack. Cada harness entende apenas suas próprias sessões. O Omnigent cria uma camada compartilhada para composição, controle e colaboração.

    “A interface voltada ao usuário é sempre a mesma: mensagens e arquivos entram, streams de texto e chamadas de ferramentas saem. O Omnigent padroniza essa interface para que os harnesses se tornem intercambiáveis.”

    Três capacidades principais

    1. Composição

    Combine modelos, harnesses e técnicas sem reescrever código. Alterne entre Claude Code, Codex, Pi e agentes personalizados com mudanças de uma linha.

    2. Controle (políticas com estado)

    As políticas rastreiam ações dos agentes e aplicam guardrails na camada do meta-harness — não apenas em prompts. Exemplos práticos:
    – Pausar o agente após cada US$ 100 gastos em custos de LLM
    РExigir aprova̤̣o humana para git push depois que o agente instala um novo pacote npm

    3. Colaboração em tempo real

    Compartilhe sessões ao vivo por URL. Colegas podem assistir o agente trabalhar, conversar com ele, comentar em arquivos e até co-pilotar ou bifurcar a sessão.

    Arquitetura

    • Runner: encapsula qualquer agente em uma sessão sandboxed com API uniforme
    • Server: fornece políticas e compartilhamento, expondo cada sessão via terminal, web UI (localhost:6767) e APIs web
    • OmniBox Sandbox: sandbox no nível do sistema operacional com proxy de saída. Por exemplo: mantenha o token do GitHub oculto do agente e injete-o apenas em requisições aprovadas

    A CLI é instalada como omnigent ou omni. Na primeira execução, detecta automaticamente credenciais de modelos existentes.

    Agentes de exemplo incluídos

    Polly — Orquestrador multi-agente para código

    Não escreve código. Planeja e delega trabalho para sub-agentes em worktrees git paralelas. Cada diff é revisado por um vendor diferente. O usuário faz o merge final.

    Debby — Parceiro de brainstorming com duas cabeças

    Uma cabeça é Claude, a outra é GPT. Toda pergunta vai para ambas, com respostas lado a lado. O comando /debate dispara crítica mútua antes de convergir.

    Por que isso importa

    A Databricks tem mais de 5.000 engenheiros usando agentes em escala. A experiência mostrou que os melhores resultados vêm de padrões multi-agente, não de um único modelo em um único harness. O Omnigent é a resposta open source para essa necessidade real.

    O projeto também inclui uma demonstração conceitual interativa que simula o fluxo completo: Polly planeja uma tarefa, delega para três sub-agentes (Claude Code, Codex, Pi) em paralelo, um medidor de custo sobe, políticas de orçamento e segurança disparam, e as interfaces de terminal, web e mobile mostram a mesma sessão sincronizada.

    Disponibilidade

    O Omnigent está disponível agora no GitHub: github.com/omnigent-ai/omnigent sob licença Apache 2.0. O roadmap inclui otimização automática no nível do meta-harness usando GEPA, introspecção baseada em código dentro de agentes, servidor MCP para que agentes trabalhem entre sessões e deploy simplificado no Fly.io, Railway, Modal e Daytona.

  • Como usar o Claude Code com modelos locais: guia completo para Ollama, LM Studio e llama.cpp

    Como usar o Claude Code com modelos locais: guia completo para Ollama, LM Studio e llama.cpp

    Claude Code com Modelos Locais

    O Claude Code, da Anthropic, se tornou uma das ferramentas de desenvolvimento mais populares em 2026. Mas o que muita gente não sabe é que é possível executá-lo inteiramente com modelos locais, eliminando custos por token, limites de taxa e dependência de APIs externas.

    Neste guia, você vai aprender a configurar o Claude Code para funcionar com três backends de inferência: Ollama, LM Studio e llama.cpp.

    Como funciona

    O Claude Code envia requisições no formato Anthropic Messages API. Ao redefinir a variável de ambiente ANTHROPIC_BASE_URL para apontar para um servidor local que “fale” o mesmo protocolo, o Claude Code passa a usar seu modelo local como se fosse o Claude oficial.

    As variáveis de ambiente essenciais são:

    • ANTHROPIC_BASE_URL — endereço do servidor local
    • ANTHROPIC_API_KEY — placeholder (ex: “ollama”), servidores locais ignoram
    • ANTHROPIC_DEFAULT_SONNET_MODEL / HAIKU_MODEL / OPUS_MODEL — mapeiam os tiers internos para o nome do seu modelo local

    Importante: sem essas três variáveis de modelo, o Claude Code tenta usar claude-sonnet-4-20250514, que os servidores locais rejeitam.

    Backend 1: Ollama (recomendado para começar)

    O Ollama gerencia download, quantização e servidor de modelos com uma CLI simples.

    Instalação e pull do modelo

    # Instalar
curl -fsSL https://ollama.com/install.sh | sh

# Baixar um modelo recomendado (GLM-4.7 Flash)
ollama pull glm-4.7-flash:latest

    Configuração temporária

    export ANTHROPIC_BASE_URL="http://localhost:11434"
export ANTHROPIC_API_KEY="ollama"
export ANTHROPIC_AUTH_TOKEN="ollama"
export ANTHROPIC_DEFAULT_SONNET_MODEL="glm-4.7-flash:latest"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="glm-4.7-flash:latest"
export ANTHROPIC_DEFAULT_OPUS_MODEL="glm-4.7-flash:latest"
claude

    Configuração permanente (~/.claude/settings.json)

    {
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:11434",
    "ANTHROPIC_API_KEY": "ollama",
    "ANTHROPIC_AUTH_TOKEN": "ollama",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.7-flash:latest",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.7-flash:latest",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.7-flash:latest",
    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1"
  }
}

    Backend 2: LM Studio

    O LM Studio oferece interface gráfica e suporte nativo ao endpoint /v1/messages desde a versão 0.4.1.

    1. Instale o app desktop ou CLI
    2. Busque e baixe um modelo para código (ex: Qwen Coder)
    3. Inicie o servidor local (porta padrão 1234)
    4. Configure o contexto para ≥ 25.000 tokens

    Configuração

    export ANTHROPIC_BASE_URL="http://localhost:1234"
export ANTHROPIC_API_KEY="lm-studio"
export ANTHROPIC_DEFAULT_SONNET_MODEL="qwen2.5-coder-32b-instruct"
# Repita para HAIKU e OPUS com o mesmo modelo

    Backend 3: llama.cpp (controle total)

    Para quem quer controle granular sobre parâmetros de inferência (quantização, contexto, camadas GPU).

    Instalação

    # Linux com CUDA
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

# Download do modelo GGUF
huggingface-cli download unsloth/GLM-4.7-Flash-GGUF \
  GLM-4.7-Flash-UD-Q4_K_XL.gguf --local-dir ./models/

    Servidor

    llama-server \
  --model ./models/GLM-4.7-Flash-UD-Q4_K_XL.gguf \
  --alias "glm-4.7-flash" \
  --port 8001 \
  --ctx-size 131072 \
  --flash-attn \
  --n-gpu-layers 99

    Flags importantes:
    – --alias deve corresponder ao nome do modelo nas variáveis de ambiente
    – --ctx-size 131072 = 128K de contexto
    – --flash-attn reduz uso de VRAM
    – --n-gpu-layers 99 descarrega todas as camadas na GPU

    Correção crítica: CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS

    O Claude Code adiciona cabeçalhos beta experimentais específicos da Anthropic que os servidores locais rejeitam. A variável CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS="1" remove esses cabeçalhos, evitando erros do tipo Unexpected value(s) for the anthropic-beta header.

    Conclusão

    Executar o Claude Code com modelos locais é surpreendentemente simples e elimina completamente os custos de API. O Ollama é a porta de entrada mais fácil, o LM Studio oferece a melhor experiência visual, e o llama.cpp dá controle total sobre a inferência.

    Com esta configuração, você mantém toda a produtividade do Claude Code — edição de arquivos, execução de comandos, análise de código — rodando 100% offline e sem custo por requisição.

    Fonte: KDnuggets

  • Her: a detetive que analisa suas sessões de Claude Code com inteligência e segurança

    Her: a detetive que analisa suas sessões de Claude Code com inteligência e segurança

    O Her · हेर é uma ferramenta inovadora lançada na plataforma Hugging Face que atua como uma verdadeira detetive para sessões do Claude Code. Seu objetivo é interpretar os registros gerados durante essas sessões, facilitando a análise e compreensão do que ocorreu de forma clara, prática e segura.

    O que é Her e como funciona

    Durante cada sessão do Claude Code, um arquivo no formato .jsonl é gerado, contendo todas as interações, chamadas de ferramentas e tokens utilizados. No entanto, esse arquivo é praticamente uma “caixa-preta”, pois analisar manualmente milhares de linhas de JSON é uma tarefa complexa e pouco prática.

    Imagem relacionada ao artigo de HuggingFace
    Imagem de apoio da materia original.

    Her resolve esse problema ao permitir que o usuário envie o arquivo da sessão para a plataforma, onde a ferramenta reconstrói toda a atividade em linguagem natural, destacando movimentos arriscados — como deploys, alterações de configuração, mudanças em produção e exposição de segredos — e relacionando cada evento à etapa exata em que ocorreu.

    Recursos e diferenciais de Her

    • Interpretação detalhada: Her mostra para onde foram os tokens, quais ferramentas, subagentes, habilidades e servidores MCP foram acionados.
    • Sugestões baseadas em boas práticas: Utilizando o modelo Nemotron-Mini-4B-Instruct, Her sugere melhorias fundamentadas nas melhores práticas da Anthropic e da comunidade, sem jamais afirmar conclusivamente, mantendo-se sempre como uma assistente que sugere e não impõe.
    • Modo copilot: Com o recurso “Ask Her”, é possível fazer perguntas específicas, como “por que esta ferramenta foi usada?”, recebendo respostas que citam os momentos da sessão e mostram a chamada exata da ferramenta.
    • Visão de projeto: É permitido enviar múltiplos arquivos para analisar várias sessões simultaneamente, facilitando a investigação de padrões ou dúvidas que se estendam por diversos runs.
    • Privacidade e segurança: Nenhuma API de IA de terceiros é acionada. O modelo roda localmente no espaço do Hugging Face via ZeroGPU, e os dados enviados ficam restritos a namespaces privados e deletados automaticamente, garantindo que nada saia da caixa.
    • Identificação automática de ferramentas: Her inclui um banco de dados com ferramentas populares de Homebrew, npm e PyPI, permitindo nomear e descrever offline a maioria das ferramentas usadas, além de destacar atividades críticas como deploys e acessos a bancos de dados.

    Origem e desenvolvimento

    Her nasceu durante um hackathon de final de semana como uma visão inicial para operadores, apresentando um gráfico de jornada onde cada consulta representava um nó dimensionado pelo custo. A partir do feedback, evoluiu para um relatório executivo mais acessível, e posteriormente incorporou a base de dados de ferramentas para resolver dúvidas sobre ferramentas que não apareciam no gráfico original.

    Imagem relacionada ao artigo de HuggingFace
    Imagem de apoio da materia original.

    A interface é uma aplicação React hospedada em um servidor Gradio, enquanto a análise forense é conduzida por um motor determinístico que não altera os números independentemente de atualizações do modelo, garantindo confiabilidade.

    Para quem serve e como acessar

    Her é ideal para desenvolvedores, operadores e equipes que utilizam Claude Code e precisam entender profundamente o comportamento e o custo de suas sessões, identificar riscos e otimizar o uso de ferramentas e recursos.

    Você pode experimentar Her diretamente no Hugging Face Spaces, sem necessidade de instalação:

    Links úteis

  • Anthropic lança revisão de código colaborativa com múltiplos agentes para Claude Code

    A Anthropic anunciou uma nova funcionalidade de Code Review para o Claude Code, seu ambiente de desenvolvimento assistido por inteligência artificial. A inovação consiste em um sistema de revisão de pull requests baseado em múltiplos agentes de IA que analisam as alterações no código de forma paralela e colaborativa, trazendo maior profundidade e precisão às análises.

    Como funciona o novo sistema de revisão de código

    Ao abrir um pull request, o sistema automaticamente dispara diversos agentes que inspecionam as mudanças simultaneamente. Cada agente foca em diferentes aspectos do código para identificar possíveis bugs, vulnerabilidades, inconsistências e outras falhas. Para reduzir falsos positivos, os agentes verificam mutuamente suas descobertas antes de gerar um relatório consolidado.

    O resultado é uma review detalhada, que inclui um resumo dos principais problemas encontrados, comentários inline diretamente no pull request e uma classificação dos erros por severidade. O número de agentes envolvidos varia conforme o tamanho e a complexidade da alteração: mudanças maiores recebem análises mais profundas, enquanto alterações pequenas passam por revisões mais rápidas.

    Segundo a Anthropic, o tempo médio para uma revisão completa é de cerca de 20 minutos, o que representa um equilíbrio entre profundidade e agilidade.

    Disponibilidade e público-alvo

    Atualmente, a funcionalidade está disponível em preview de pesquisa para usuários dos planos Team e Enterprise do Claude Code. A Anthropic já utiliza internamente o sistema em grande parte dos seus pull requests há meses, com resultados positivos na qualidade das revisões:

    • Comentários substanciais aumentaram de 16% para 54% dos pull requests;
    • Para alterações com mais de 1.000 linhas, 84% geraram algum tipo de achado, com uma média de 7,5 problemas identificados;
    • Em pull requests com menos de 50 linhas, 31% geraram achados, com média de 0,5 problemas;
    • Menos de 1% das descobertas foram marcadas como incorretas pelos engenheiros durante a utilização interna.

    Impacto prático para desenvolvedores e equipes

    Ao utilizar múltiplos agentes especializados, a Anthropic busca oferecer uma análise mais robusta e confiável, indo além das revisões rápidas e superficiais comuns em outras ferramentas de IA para código. O sistema é pensado para auxiliar e potencializar o trabalho humano, não para substituir revisores humanos, e não aprova pull requests automaticamente.

    Essa abordagem pode acelerar o processo de revisão, reduzir o número de erros que chegam à produção e apoiar equipes de desenvolvimento em projetos complexos, principalmente em ambientes corporativos que demandam alta qualidade e segurança no código.

    Considerações sobre preço e adoção

    A Anthropic indicou que o custo por revisão varia entre US$ 15 e US$ 25, dependendo do tamanho do pull request e do volume de tokens processados. Alguns desenvolvedores da comunidade manifestaram preocupações quanto à viabilidade do preço para equipes menores ou fluxos com alto volume de revisões.

    Comparado a outras soluções como o GitHub Copilot Code Review e CodeRabbit, o diferencial da Anthropic está na arquitetura multiagente e na ênfase em análises mais detalhadas, ainda que mais lentas.

    Links úteis

  • OpenAI lança Codex turbinado com controle avançado do desktop para competir com Anthropic

    A OpenAI anunciou uma atualização robusta para o Codex, sua ferramenta de programação automatizada, que agora oferece recursos inéditos para controlar o desktop do usuário e operar em segundo plano. A novidade marca uma resposta direta à Anthropic, que vinha ganhando espaço no mercado corporativo com sua solução Claude Code.

    Codex com múltiplos agentes simultâneos e operação em background

    O grande destaque dessa atualização é a capacidade do Codex de funcionar em paralelo no computador do usuário, abrindo aplicativos e executando comandos com o cursor — clicando e digitando — sem interferir nas atividades do usuário. Segundo a OpenAI, isso permite que múltiplos agentes trabalhem simultaneamente no Mac, atuando como assistentes para tarefas auxiliares enquanto o usuário foca em projetos principais.

    Imagem relacionada ao artigo de TechCrunch AI
    Imagem de apoio da materia original.

    Essa funcionalidade amplia o escopo do Codex para atuar em fluxos de trabalho corporativos, especialmente em atividades como iteração de mudanças na interface de usuário, testes de aplicativos e operações em programas que não expõem APIs.

    Novas funções integradas e memória contextual

    Além do controle do desktop, o Codex passou a contar com um navegador embutido, que permite ao agente executar comandos em aplicações web específicas. Inicialmente voltado para desenvolvimento frontend e jogos, a OpenAI planeja expandir essa capacidade para controlar o navegador além de aplicações locais.

    Outra função em pré-visualização é a memória, que habilita o Codex a lembrar sessões anteriores de trabalho e gerar contextos personalizados conforme o perfil do usuário. Isso promete tornar a interação mais eficiente e adaptada ao estilo individual de cada programador.

    Geração de imagens e integrações com plugins

    O Codex também ganhou uma nova habilidade para gerar imagens, útil para criar conceitos de produtos, visuais para apresentações, mockups e imagens temporárias para uso corporativo.

    Para ampliar sua capacidade de execução de tarefas, a OpenAI integrou 111 plugins, incluindo ferramentas como CodeRabbit e Gitlab Issues. Com isso, o Codex pode assumir funções administrativas simples, como analisar canais do Slack e o calendário do Google para montar listas de afazeres diárias.

    Disponibilidade e modelo de preços

    A OpenAI lançou um modelo de preços pay-as-you-go para o Codex, voltado para clientes empresariais e do ChatGPT Enterprise. Essa modalidade oferece maior flexibilidade para aquisição do serviço, facilitando o acesso para diferentes perfis de empresas.

    Para acessar o Codex atualizado, usuários empresariais podem consultar as informações oficiais no blog da OpenAI.

    Contexto competitivo e perspectivas

    O lançamento reforça a disputa entre OpenAI e Anthropic no segmento de ferramentas de programação assistida por IA, com a Anthropic ganhando destaque com o Claude Code, que também controla remotamente desktops. A atualização do Codex busca recuperar terreno ao oferecer funcionalidades similares e ampliadas.

    Além do foco em soluções corporativas, a OpenAI tem reduzido esforços em produtos para consumidores finais, como o aplicativo social de vídeo Sora 2, concentrando-se em consolidar sua presença no mercado empresarial.

    Links úteis

  • Pesquisador usa Claude Code para identificar vulnerabilidade crítica no kernel Linux após 23 anos

    Descoberta de vulnerabilidade remota no Linux com apoio da IA Claude Code

    O pesquisador da Anthropic Nicholas Carlini revelou, durante a conferência [un]prompted AI security, a descoberta de múltiplas vulnerabilidades de segurança no kernel Linux, incluindo uma falha crítica de estouro de buffer no driver NFS que estava oculta desde 2003. A identificação foi possível graças ao uso do modelo de linguagem Claude Code, que auxiliou na análise automatizada do código-fonte do kernel.

    O problema: vulnerabilidade antiga e de difícil detecção

    A falha encontrada é um estouro de buffer no heap dentro do driver NFS do Linux, que permite exploração remota. A vulnerabilidade ocorre quando dois clientes NFS interagem com o servidor: o Cliente A bloqueia um arquivo com um ID de proprietário de 1024 bytes (tamanho legal, porém incomum), e o Cliente B tenta adquirir o mesmo bloqueio e recebe uma resposta de negação. O problema está no buffer da resposta do servidor, que possui apenas 112 bytes, mas acaba sendo preenchido com 1056 bytes, causando corrupção de memória no kernel.

    Imagem relacionada ao artigo de InfoQ AI/ML
    Imagem de apoio da materia original.

    Método utilizado para a descoberta: automação simples e eficaz

    Carlini utilizou um script bash simples para iterar sobre cada arquivo-fonte do kernel Linux, instruindo o Claude Code a buscar vulnerabilidades em cada arquivo individualmente, simulando uma competição de captura de bandeira (CTF). O comando básico era:

    find . -type f -print0 | while IFS= read -r -d '' file; do
  claude \
    --verbose \
    --dangerously-skip-permissions \
    --print "You are playing in a CTF. \nFind a vulnerability. \nhint: look at $file \nWrite the most serious \none to the /output dir"
done

    Sem necessidade de ferramentas especializadas ou prompts complexos, o modelo conseguiu identificar vulnerabilidades relevantes, destacando a eficiência crescente das IAs no auxílio à segurança de software.

    Resultados e impacto prático

    • Foram confirmadas cinco vulnerabilidades no kernel Linux, abrangendo componentes como NFS, io_uring, futex e ksmbd.
    • A falha no NFS, por exemplo, foi corrigida após a descoberta, reforçando a importância da análise automatizada.
    • O avanço do modelo Claude Code foi notável: versões anteriores encontravam apenas uma fração das vulnerabilidades detectadas pela versão 4.6 lançada recentemente.
    • O volume de relatórios legítimos de bugs gerados por IA aumentou drasticamente, passando de poucos por semana para até 10 por dia nas listas de segurança do kernel.

    Limitações e desafios atuais

    Apesar do progresso, ainda há uma taxa significativa de falsos positivos, estimada em menos de 20% segundo relatos. Muitas descobertas precisam de validação humana para confirmação. Carlini possui centenas de potenciais falhas ainda não validadas. Além disso, o processo de triagem e confirmação permanece essencial para evitar sobrecarga das equipes de segurança.

    Por que essa pesquisa importa no mundo real

    Essa descoberta evidencia que vulnerabilidades antigas e críticas podem passar despercebidas por décadas, mesmo em projetos amplamente auditados como o Linux. O uso de IA para análise de código representa uma nova categoria de ferramenta que combina vantagens da análise estática e do fuzzing, gerando hipóteses, contextualizando falhas e priorizando riscos com maior eficiência.

    Por outro lado, o avanço também levanta preocupações de dupla utilização, pois adversários podem empregar técnicas semelhantes para identificar e explorar vulnerabilidades em larga escala.

    Recursos adicionais e links úteis

  • Como Escolher Seu Copiloto de IA para Maximizar a Produtividade no Desenvolvimento de Software

    O Estado Atual da Programação Assistida por IA

    Sepehr Khosravi, engenheiro de software da Coinbase e instrutor na UC Berkeley, apresenta um panorama detalhado sobre o uso da inteligência artificial no auxílio à codificação, destacando a evolução das ferramentas que vão além da simples autocompletação para fluxos de trabalho agentic sofisticados.

    Segundo uma pesquisa envolvendo mais de 100 mil engenheiros, o uso da IA pode aumentar a produção de código em 30% a 40%. Entretanto, parte desse código gerado, cerca de 15% a 25%, precisa ser refeito devido a bugs ou exclusões. O ganho líquido estimado em produtividade gira em torno de 15% a 20%, podendo ser maior com o domínio das ferramentas.

    Imagem relacionada ao artigo de InfoQ AI/ML
    Imagem de apoio da materia original.

    Classificação dos Ferramentas de IA para Desenvolvedores

    As ferramentas de IA para desenvolvimento podem ser divididas em três categorias:

    • Ferramentas all-in-one para não desenvolvedores: possibilitam ganhos de produtividade de até 100 vezes para pessoas sem experiência prévia, permitindo a criação de aplicativos simples e negócios iniciais.
    • Plugins e extensões para IDEs: como GitHub Copilot, Cursor, Windsurf, IntelliJ, Cline e Google Antigravity, que oferecem sugestões inteligentes diretamente no ambiente de desenvolvimento.
    • Interfaces de linha de comando (CLI) baseadas em modelos de linguagem: ferramentas como Claude, ChatGPT, Google e Kimi, que funcionam via terminal e focam em integração com fluxos de trabalho mais avançados.

    Escolhendo Seu Copiloto de IA: Fatores e Ferramentas Relevantes

    Visual Studio Code lidera como IDE preferida, com cerca de 75% dos desenvolvedores utilizando-a. Entre as ferramentas de IA mais desejadas para integração futura estão Claude Code, Cursor, IntelliJ IDEA e Neovim.

    Sepehr destaca especialmente Cursor e Claude Code pela maturidade e capacidades técnicas, apresentando dicas para maximizar seu uso.

    Cursor: Dicas para Acelerar a Codificação

    1. Uso do Tab: a função de autocompletar do Cursor permite gerar blocos de 10 a 20 linhas de código com um único toque, baseada em mudanças recentes e linting.
    2. Cursor Agent: oferece seleção de modelos (Gemini, ChatGPT, etc.) e integra ferramentas para leitura de arquivos, pesquisa na web, execução no terminal e MCPs (multi-context processors).
    3. Modo Multi-Agent: permite gerar múltiplas variações de resposta para um único comando, aumentando a produtividade na experimentação.
    4. Composer: modelo proprietário da Cursor focado em velocidade, capaz de gerar páginas simples rapidamente, embora com qualidade de código inferior a modelos mais avançados.

    Claude Code: Pesquisa e Integração Avançada

    Claude Code destaca-se por suas capacidades de pesquisa e integração em fluxos de trabalho complexos, facilitando a gestão de janelas de contexto e conexões MCP. Essa abordagem é essencial para reduzir o overhead em loops multi-turno e operações com múltiplas ferramentas.

    Desafios e Lições do Uso de IA na Programação

    Apesar do avanço tecnológico, o sentimento dos desenvolvedores em relação à IA caiu para cerca de 60% em 2025, reflexo do hype exagerado e declarações polêmicas de líderes do setor, como Mark Zuckerberg, que previram substituição rápida de engenheiros por IA.

    O equilíbrio está em reconhecer que a IA não substitui o engenheiro, mas potencializa sua produtividade quando usada corretamente, reduzindo o tempo de processos além da escrita do código, como testes, depuração e integração.

    Sepehr compartilha ainda aprendizados do CEO da Databricks, destacando que a verdadeira vantagem da IA está em encurtar todo o ciclo de desenvolvimento, não apenas a geração de código.

    Considerações Técnicas Importantes

    Um ponto técnico fundamental para fluxos agentic é a continuação stateful, que reduz drasticamente o overhead de transporte ao manter o contexto em cache no servidor, diminuindo em mais de 80% os dados enviados e acelerando a execução em até 29%.

    Esse avanço é crucial para permitir a escalabilidade e performance em sistemas que utilizam agentes de IA em múltiplas etapas e com ferramentas diversas.

    Links Úteis para Explorar Mais

  • Anthropic expõe código-fonte do Claude Code por erro de empacotamento no npm

    Erro humano expõe código-fonte completo do Claude Code

    Na última semana, a Anthropic, empresa responsável pelo assistente de IA Claude, sofreu um incidente de segurança que expôs inadvertidamente o código-fonte completo do seu CLI tool Claude Code. O problema ocorreu após a publicação da versão 2.1.88 do pacote @anthropic-ai/claude-code no registro npm, que incluiu por engano um arquivo source map. Este arquivo, utilizado para depuração, permitiu o acesso direto ao código TypeScript original, com mais de 512 mil linhas distribuídas em cerca de 1.900 arquivos.

    O que ocorreu e como o código foi exposto

    O pesquisador de segurança Chaofan Shou identificou o vazamento no dia 31 de março de 2026, ao notar que o pacote continha um arquivo .map que referenciava o código fonte completo hospedado na nuvem da Anthropic. O runtime Bun, usado para empacotar o Claude Code, gera esses arquivos por padrão, a menos que sejam explicitamente desabilitados ou ignorados no processo de publicação.

    Esse erro de empacotamento, atribuído pela Anthropic a falha humana, não envolveu vazamento de dados de clientes nem credenciais, segundo a empresa. Ainda assim, o código-fonte foi rapidamente baixado e arquivado em múltiplos repositórios no GitHub, acumulando dezenas de milhares de estrelas e forks em poucas horas.

    Recursos revelados e impacto para desenvolvedores

    O código exposto não é o modelo Claude em si, mas o CLI tool que interage com o modelo. Mesmo assim, a análise do código revelou uma arquitetura sofisticada, com:

    • Mais de 40 ferramentas distintas, cada uma com permissões específicas;
    • Um motor de consultas com cerca de 46 mil linhas para lidar com chamadas à API LLM, streaming, cache e orquestração;
    • Coordenação multiagente para gerenciamento paralelo de agentes trabalhadores;
    • Integrações com IDEs usando autenticação JWT;
    • Um sistema de memória persistente para o agente.

    Além disso, o código revelou recursos ainda não lançados, como o modo autônomo KAIROS, que permite que o Claude Code opere em segundo plano consolidando memórias, o ULTRAPLAN para planejamento offloadado na nuvem, e o BUDDY, um companheiro de IA estilo Tamagotchi.

    Também foram expostos codinomes internos para modelos, como Capybara (Claude 4.6) e Fennec (Opus 4.6), além do curioso sistema “Undercover Mode”, projetado para impedir que o Claude Code vaze informações internas durante contribuições em repositórios públicos.

    Recomendações para usuários e desenvolvedores

    O vazamento reforça a importância de revisar cuidadosamente arquivos incluídos em pacotes npm, especialmente source maps que podem conter código-fonte não ofuscado. Para evitar problemas similares, recomenda-se:

    • Adicionar a extensão *.map no arquivo .npmignore;
    • Manter uma lista explícita de arquivos permitidos no campo files do package.json;
    • Executar npm pack --dry-run antes da publicação para auditar o conteúdo do pacote.

    Além disso, usuários do Claude Code devem verificar suas dependências, especialmente devido a um ataque de cadeia de suprimentos simultâneo no pacote axios que afetou versões específicas usadas pelo Claude Code.

    Disponibilidade e próximos passos da Anthropic

    A Anthropic removeu as versões afetadas do registro npm e declarou estar implementando medidas para evitar que erros semelhantes aconteçam no futuro. Até o momento, não foram divulgados detalhes técnicos sobre as correções adotadas.

    Para quem deseja analisar o código exposto, há repositórios públicos no GitHub que arquivaram a base completa, como o repositório de análise do código Claude Code.

    Links úteis para aprofundamento

  • Benchmark com Claude Code revela que linguagens dinâmicas são mais rápidas e econômicas para prototipagem AI

    Contexto e objetivo do benchmark

    O desenvolvedor e committer Ruby Yusuke Endoh conduziu um benchmark inédito para avaliar a eficiência da geração de código pela IA Claude Code (versão Opus 4.6) em 13 linguagens de programação distintas. O experimento, realizado com 600 execuções, teve como tarefa a implementação simplificada de funcionalidades do Git, dividida em duas fases, com o intuito de medir velocidade e custo de geração, além da estabilidade das soluções produzidas.

    Metodologia aplicada

    A tarefa consistiu na criação de um sistema simplificado de controle de versões, implementando inicialmente os comandos init, add, commit e log (fase 1), e posteriormente estendendo o projeto para incluir status, diff, checkout e reset (fase 2). Cada linguagem foi testada 20 vezes, totalizando 600 execuções.

    Para evitar distorções causadas por dependências de bibliotecas externas, o autor substituiu o algoritmo padrão SHA-256 por um algoritmo de hash próprio e simplificado, garantindo que as diferenças observadas fossem atribuídas principalmente à linguagem e não a seus ecossistemas.

    Principais resultados do benchmark

    • Linguagens dinâmicas lideram em custo e velocidade: Ruby, Python e JavaScript foram as mais rápidas e econômicas, com custos por execução entre US$ 0,36 e US$ 0,39, e tempos médios variando de 73 a 81 segundos.
    • Linguagens estaticamente tipadas apresentam maiores custos e variações: Go, Rust e C foram significativamente mais lentas e caras, com custos até 2,6 vezes maiores e maior variância nos tempos de execução. C, por exemplo, gerou 517 linhas de código em média, contra 219 de Ruby, impactando o custo.
    • Adição de verificadores de tipos em linguagens dinâmicas causa penalidades consideráveis: Por exemplo, a inclusão do mypy para Python aumentou o tempo em 1,6 a 1,7 vezes, enquanto o uso do Steep para Ruby provocou um atraso entre 2,0 e 3,2 vezes.
    • TypeScript é mais caro que JavaScript puro: Apesar de gerar quantidade semelhante de código, TypeScript teve custo médio de US$ 0,62 por execução, contra US$ 0,39 do JavaScript.

    Discussões e limitações apontadas pelo autor

    Endoh reconhece seu viés como committer Ruby e ressalta que o benchmark aborda prototipagem de pequena escala (~200 linhas de código), o que limita a extrapolação para projetos maiores, onde tipagem estática pode ser vantajosa. Ele também destaca que o estudo foca apenas em custo e velocidade de geração, não avaliando qualidade, manutenibilidade ou desempenho em tempo de execução.

    Comentários na comunidade levantaram pontos relevantes, como a dificuldade de generalizar conclusões para protótipos maiores, a relevância do ecossistema de pacotes para reduzir código gerado, e o papel dos sistemas de tipos rigorosos na prevenção precoce de erros, que pode justificar falhas detectadas em Rust e Haskell.

    Sobre a diferença de velocidade, Endoh argumenta que, no desenvolvimento iterativo assistido por IA, aguardar 30 segundos em vez de 60 pode impactar o fluxo do desenvolvedor, mas admite que avanços futuros podem reduzir esses tempos para níveis quase instantâneos.

    Repositório e dados abertos

    Todo o código-fonte gerado, logs de execução e resultados detalhados estão disponíveis no repositório GitHub do benchmark, permitindo transparência e replicação do estudo.

    Implicações práticas para equipes de desenvolvimento

    Este estudo fornece insights valiosos para equipes que utilizam IA para geração de código, principalmente em fases iniciais de prototipagem. A escolha de linguagens dinâmicas pode resultar em economia de tempo e custo, enquanto a adoção de tipagem estática, apesar de trazer benefícios de segurança, pode impactar a agilidade e o custo do processo.

    As equipes devem ponderar essas trade-offs conforme o estágio do projeto e necessidades específicas, lembrando que a maturidade das ferramentas e modelos de IA pode alterar essas dinâmicas no futuro próximo.

    Links úteis

  • Vazamento do Código do Claude com Malware: Riscos e Impactos para Desenvolvedores e Usuários

    Recentemente, o código-fonte do Claude Code, ferramenta de programação da Anthropic, foi acidentalmente exposto ao público, desencadeando uma onda de repostagens em plataformas como o GitHub. Contudo, essa disseminação não é isenta de riscos: hackers inseriram infostealer malware em alguns desses repositórios, colocando em perigo quem tentar baixar e usar o código.

    O que é o Claude Code e o que aconteceu no vazamento?

    Claude Code é uma ferramenta de programação desenvolvida pela Anthropic, conhecida por sua popularidade entre desenvolvedores que buscam facilitar a codificação. A exposição acidental do seu código-fonte ocorreu no início de abril de 2026, quando um pesquisador de segurança identificou que a Anthropic havia tornado público, sem querer, esse material sensível.

    Imagem relacionada ao artigo de Wired AI
    Imagem de apoio da materia original.

    Riscos associados ao código vazado com malware

    Após o vazamento, diversas cópias do código começaram a surgir em repositórios no GitHub. No entanto, segundo reportagens da BleepingComputer, alguns desses repositórios continham códigos maliciosos, especificamente um tipo de malware chamado infostealer, que tem a capacidade de roubar informações do computador da vítima.

    Para quem deseja experimentar o Claude Code, é fundamental ter cautela, pois o simples ato de copiar e colar comandos para instalação — prática comum entre desenvolvedores menos experientes — pode resultar na execução inadvertida de malware.

    Imagem relacionada ao artigo de Wired AI
    Imagem de apoio da materia original.

    Medidas adotadas pela Anthropic para conter o vazamento

    A Anthropic reagiu prontamente ao incidente, emitindo notificações de remoção por violação de direitos autorais para retirar os repositórios ilegítimos, tanto com malware quanto puros, do GitHub. Inicialmente, a empresa identificou mais de 8.000 cópias e adaptações do código, mas posteriormente concentrou seus esforços em 96 repositórios prioritários.

    Precedentes de ataques relacionados ao Claude Code

    Este não é o primeiro caso em que hackers se aproveitam do interesse pelo Claude Code para disseminar malware. Em março de 2026, anúncios patrocinados no Google levaram usuários a sites falsos que simulavam guias oficiais de instalação do Claude Code, induzindo-os a executar comandos que instalavam softwares maliciosos.

    Impacto prático para desenvolvedores e usuários

    • Para desenvolvedores: é imprescindível verificar a autenticidade das fontes antes de baixar ou instalar ferramentas de programação, especialmente quando envolvem comandos de terminal.
    • Para usuários finais: evitar executar comandos copiados de sites não oficiais e manter sistemas de segurança atualizados para minimizar riscos de infecção por malware.
    • Para empresas: reforçar políticas de segurança na cadeia de desenvolvimento e monitorar repositórios públicos para evitar exposição a códigos comprometidos.

    Como acessar o Claude Code com segurança?

    Atualmente, o acesso legítimo ao Claude Code deve ser feito diretamente pelos canais oficiais da Anthropic. Evite repositórios não verificados e anúncios suspeitos que prometem instalações rápidas e fáceis. A Anthropic continua removendo cópias ilegítimas e reforçando a segurança para proteger sua base de usuários.

    Links úteis