Reflexão sobre Vibe Trading: quando usar IA e quando não usar.

Recentemente surgiu um conceito chamado Vibe Trading — descrever intenções de negociação em linguagem natural e deixar a IA executar. Basta dizer "estratégia conservadora, priorizando ativos de baixa volatilidade" e a IA configura automaticamente para você. Parece ótimo.

Mas antes de falar sobre Vibe Trading, quero contar algo que aconteceu recentemente e que explica melhor do que qualquer teoria "onde a IA deve ser usada".

Em 31 de março, o Claude Code da Anthropic expôs acidentalmente seu código-fonte durante uma atualização npm — cerca de 512.000 linhas de TypeScript (nota: é o total de código empacotado, incluindo dependências e código gerado). A engenharia reversa pela comunidade se espalhou rapidamente, desenvolvedores do mundo todo vasculhavam o código em busca de novos recursos.

Mas a descoberta que mais me surpreendeu não tinha nada a ver com IA. Ela em si não tinha relação com trading, mas a filosofia de engenharia por trás dela deve ressoar com quem trabalha com quant.

Em um módulo anotado como userPromptKeywords, havia uma expressão regular para capturar palavrões como merda, que porra é essa, tá quebrado pra caramba — usada para determinar rapidamente se o usuário estava xingando.

A empresa de modelos de linguagem mais avançados do mundo usa expressão regular para detectar emoções.

Não é chamar o Claude para fazer análise de sentimentos. Não é treinar um classificador. É uma correspondência de strings em microssegundos.

Por quê?

1. Por que a Anthropic não usa a própria IA

Isso não é preguiça. É uma decisão de engenharia cuidadosamente considerada.

O Claude Code processa centenas de milhares de interações de usuários por dia. Cada interação precisa determinar se "o usuário expressou frustração" para ajustar a estratégia de resposta. Se cada vez chamasse o LLM para fazer esse julgamento:

• Latência: uma inferência do LLM leva centenas de milissegundos, expressão regular leva microssegundos
• Custo: chamadas LLM são cobradas por token, expressão regular é praticamente gratuita
• Determinismo: a expressão regular corresponde ou não, resultado 100% certo; a saída do LLM não é determinística, a mesma entrada pode gerar julgamentos diferentes

Portanto, a escolha da Anthropic foi: usar regex para filtragem rápida (baixo custo, rápido, determinístico), deixando o poder computacional do LLM para decisões que realmente exigem compreensão semântica.

Isso não é um detalhe técnico. É uma filosofia de arquitetura: nem todo problema merece ser resolvido com IA.

Quem trabalha com quant deve sentir essa frase especialmente.

2. A mesma escolha no trading quantitativo

Sua estratégia tem dois tipos de decisão:

Decisões determinísticas — use "regras"

Quem já escreveu estratégias na FMZ sabe que a lógica central de trading geralmente são algumas linhas de código determinístico:

            javascript
            
            
// Sinal de cruzamento de médias móveis — Exemplo em JavaScript FMZ
var records = exchange.GetRecords(PERIOD_D1)
var ma5 = TA.MA(records, 5)
var ma20 = TA.MA(records, 20)
var idx = records.length - 1

// Cruzamento de alta -> comprar
if (ma5[idx] > ma20[idx] && ma5[idx-1] <= ma20[idx-1]) {
    exchange.SetDirection("buy")
    exchange.Buy(records[idx].Close, 1)
    Log("Cruzamento de médias, comprar")
}

Condições claras, resultado determinado, não exige "entendimento" semântico. Escrito com if-else, 100% confiável, execução em milissegundos.

É a mesma lógica da Anthropic usar regex para detectar emoções — problemas determinísticos, use ferramentas determinísticas. Claro, regex é correspondência de strings, médias móveis são cálculos matemáticos; ferramentas diferentes, mas papéis semelhantes em seus sistemas: são julgamentos determinísticos que não precisam de IA.

Stop loss, confie no if-else com 100% de confiabilidade; confie na IA com "alta probabilidade". Sua conta não pode arcar com essa pequena probabilidade.

Decisões de julgamento difuso — use IA

Mas algumas decisões não podem ser escritas com if-else:

• Análise de sentimento de notícias: o comunicado do Fed saiu. É hawkish ou dovish? "Manter a taxa atual inalterada, mas o comitê monitorará de perto as mudanças nos dados" — essa frase é positiva ou negativa? Médias móveis não dizem, regex também não faz esse julgamento.
• Detecção de anomalias: o volume de discussão em redes sociais de uma altcoin subiu 800% em 3 horas, mas o preço ainda não se mexeu. É "dinheiro inteligente acumulando" ou "alguém fazendo propaganda antes de puxar o preço"? Precisa de julgamento difuso combinando informações multidimensionais.
• Geração de estratégias: você tem um palpite — "depois desse padrão, geralmente vem uma subida". Mas você não consegue descrever as condições exatas. Pode descrever esse palpite para o LLM e deixá-lo ajudar a transformar em um fator quantitativo backtestável.

Característica comum desses cenários: entrada não estruturada, critérios de julgamento difusos, precisa de "entendimento", não apenas "correspondência".

3. Uma abordagem em camadas para se inspirar

Voltando à arquitetura do Claude Code. A análise da comunidade revelou uma clara divisão em camadas:

Claro, Claude Code e trading quantitativo são áreas completamente diferentes. A correspondência aqui não é um mapeamento exato. Mas a ressonância filosófica de design é real — escolha a ferramenta mais adequada para cada camada, em vez de usar um martelo para todos os pregos.

A comunidade open source também está praticando ideias semelhantes. TradingAgents é um框架 multi-agente de trading quantitativo que merece atenção recentemente (construído sobre LangGraph, com artigo acadêmico correspondente). Ele simula a estrutura de equipe de uma empresa real de trading: analistas técnicos cuidam de candles e indicadores, analistas de sentimento interpretam notícias e opinião pública, traders de diferentes estilos sintetizam opiniões para decisão final. Não é uma IA onipotente que faz tudo, mas diferentes papéis cada um fazendo sua parte.

Vale notar que TradingAgents é um framework de pesquisa; ele resolve o problema "como a IA toma decisões de trading". Mas na operação real, você ainda precisa da outra metade: conexão com exchange, gerenciamento de ordens, execução de risco, auditoria de logs — essas tarefas de infraestrutura de engenharia são exatamente o que plataformas quant como FMZ já fazem por você.

4. Como o Vibe Trading pode ser implementado: exemplo de arquitetura em camadas

Voltando ao Vibe Trading do início. A direção está certa, mas a premissa é que as camadas estejam claras.

Suponha que hoje houve um cruzamento de alta no BTC, mas todas as notícias são negativas sobre regulação. O que fazer? Olhando apenas para as médias, deveria comprar; ouvindo apenas as notícias, não ousa mexer. Esse é o cenário típico que exige camadas.

Na FMZ, uma arquitetura simplificada em camadas pode ser implementada assim (nota: exemplo simplificado; em operação real, ajuste contratos e risco por conta própria):

            javascript
            
            
/*
参数 da estratégia (adicionar na aba "Parâmetros" da página de edição da estratégia FMZ):
  OPENROUTER_API_KEY : tipo string, insira sua chave de API do OpenRouter
  AI_MODEL           : tipo string, valor padrão "google/gemini-2.5-flash", pode ser alterado para outro modelo
*/

// Camada de decisão semântica: chama a IA via OpenRouter para obter sentimento de mercado
function getAISentiment() {
    var prompt = "Analise as notícias atuais do mercado de criptomoedas e forneça uma pontuação de sentimento (-1 a 1, -1 extremo medo, 1 extrema ganância), retorne apenas um número"
    var response = HttpQuery("https://openrouter.ai/api/v1/chat/completions", {
        method: "POST",
        body: JSON.stringify({
            model: AI_MODEL,
            messages: [{role: "user", content: prompt}],
            temperature: 0
        }),
        headers: {
            "Content-Type": "application/json",
            "Authorization": "Bearer " + OPENROUTER_API_KEY
        },
        timeout: 15000
    })

    var score = parseFloat(JSON.parse(response).choices[0].message.content)
    // Quando a IA retorna um valor anômalo, reverter para valor neutro — a confiabilidade do sistema não depende da saída correta da IA em todas as ocasiões
    if (isNaN(score) || score < -1 || score > 1) {
        Log("Formato de retorno da IA anômalo, usando valor padrão 0")
        score = 0
    }
    Log("Pontuação de sentimento da IA:", score)
    return score
}

function main() {
    var lastSignalTime = 0  // Registra o tempo da vela do último sinal disparado, evitando repetição na mesma vela

    while (true) {
        var records = exchange.GetRecords(PERIOD_D1)
        if (!records || records.length < 20) { Sleep(1000); continue }

        var ma5 = TA.MA(records, 5)
        var ma20 = TA.MA(records, 20)
        var idx = records.length - 1
        var curTime = records[idx].Time
        var isBullCross = ma5[idx] > ma20[idx] && ma5[idx-1] <= ma20[idx-1]
        var isBearCross = ma5[idx] < ma20[idx] && ma5[idx-1] >= ma20[idx-1]

        // Verifica estado da posição
        var pos = exchange.GetPosition()
        var hasPosition = pos && pos.length > 0

        // Primeira camada: sinal determinístico como "limiar", apenas se golden cross + sem posição + não processado nesta vela, então pergunta à IA
        if (isBullCross && !hasPosition && curTime !== lastSignalTime) {
            lastSignalTime = curTime
            var sentiment = getAISentiment()

            // Segunda camada: sentimento da IA como "referência", afeta o tamanho da posição mas não dispara trade por si só
            if (sentiment > 0.2) {
                exchange.SetDirection("buy")
                exchange.Buy(records[idx].Close, 1)
                Log("Golden cross + IA otimista, abrir posição cheia")
            } else if (sentiment > -0.3) {
                exchange.SetDirection("buy")
                exchange.Buy(records[idx].Close, 0.5)
                Log("Golden cross + IA neutra, abrir meia posição")
            } else {
                Log("Golden cross mas IA pessimista, pular este sinal")
            }
        }

        // Fechar posição no death cross: regra determinística, não passa pela IA
        if (isBearCross && hasPosition) {
            exchange.SetDirection("closebuy")
            exchange.Sell(records[idx].Close, pos[0].Amount)
            Log("Death cross das médias, fechar posição")
        }

        // Terceira camada: stop loss é "regra absoluta", não passa pela IA
        if (hasPosition) {
            var curPrice = records[idx].Close
            var entryPrice = pos[0].Price
            if (curPrice < entryPrice * 0.97) {  // Caiu 3% abaixo do preço de abertura
                exchange.SetDirection("closebuy")
                exchange.Sell(curPrice, pos[0].Amount)
                Log("Stop loss acionado, fechamento incondicional, perda", ((curPrice/entryPrice - 1)*100).toFixed(2), "%")
            }
        }

        Sleep(60 * 1000)
    }
}

A lógica central deste código merece ser explicada em detalhes:

1. Golden cross das médias é o "limiar". Somente quando um sinal determinístico é disparado primeiro, a IA é chamada. Não consulta o modelo grande em todas as velas — economizando custos (APIs de modelos grandes cobram por token) e evitando ruído. Isso está alinhado com a abordagem da Anthropic: primeiro filtrar com regras, e só então acionar processamento mais pesado quando houver correspondência.

2. Sentimento da IA é "referência". Ele influencia o tamanho da posição e se o sinal deve ser ignorado, mas não dispara trades por si só. Observe o tratamento de exceção no código para o valor retornado pela IA — se o modelo grande retornar conteúdo não analisável, ele reverte automaticamente para o valor neutro 0. A confiabilidade do sistema não deve depender da saída correta da IA em todas as ocasiões.

3. Stop loss é "regra absoluta". Se cair 3% abaixo do preço de abertura, fecha posição incondicionalmente, sem perguntar à opinião da IA. A IA pode dizer "otimista no longo prazo", mas sua conta pode não esperar pelo longo prazo. Aqui, usa-se um stop loss rígido baseado em percentual de preço, sem passar por nenhum julgamento vago.

Esta é a maneira correta de usar o Vibe Trading: usar linguagem natural para que a IA o ajude a "sentir" o clima do mercado, e usar código determinístico para que você "execute" as ações de trading. Os limites entre os dois não podem ser confundidos.

Sugestão prática: no sistema de backtest da FMZ, execute primeiro a estratégia pura de médias como linha de base, depois adicione a camada de sentimento da IA e compare retorno e drawdown. Se a IA piorar os resultados — significa que a divisão em camadas está errada, possivelmente a IA está intervindo onde não deveria. Registre cada retorno da IA com Log() para facilitar a revisão de cada decisão posteriormente.

V. Leve uma frase consigo

As empresas de IA mais avançadas usam expressões regulares para detectar sentimento, não porque não conseguem construir uma IA melhor.

É porque sabem: Escolher a ferramenta certa é mais importante do que escolher a ferramenta mais forte.

Estratégias de médias móveis não são sexy, expressões regulares não são avançadas. Mas em seus próprios domínios, são mais confiáveis do que qualquer IA.

Por outro lado, quando você precisa extrair de um relatório macroeconômico de 5.000 palavras se "este artigo é otimista ou pessimista em relação ao BTC" — as médias móveis não ajudam, as expressões regulares também não ajudam. É aí que a IA deve entrar em cena.

Não é uma questão de "usar ou não usar IA", é uma questão de "em qual camada usar".

Aquele arquivo de expressão regular discreto no código-fonte do Claude Code responde a uma pergunta frequentemente ignorada. E a FMZ fornece uma infraestrutura em camadas pronta — interface de exchange, cálculo de indicadores, gerenciamento de trading real, auditoria de logs, tudo já feito para você. Você só precisa pensar claramente: quais decisões delegar ao TA.MA(), e quais delegar à IA.

Fontes de referência:

• Alex Kim - The Claude Code Source Leak — Análise de detecção de frustração com expressões regulares
• FMZ - Building an AI-Powered Automated Trading System — Arquitetura cérebro de IA + mãos FMZ
• TradingAgents - Multi-Agents LLM Financial Trading Framework — Framework de código aberto para negociação quantitativa multi-agente
• Artigo TradingAgents — Pesquisa acadêmica sobre framework de negociação financeira multi-agente
• VentureBeat - Claude Code Source Code Leak