Réflexion sur le Vibe Trading : quand utiliser l'IA et quand ne pas l'utiliser.

Récemment, un concept appelé Vibe Trading a émergé : décrire son intention de trading en langage naturel et laisser l'IA l'exécuter. Dites « stratégie prudente, priorité aux actifs à faible volatilité » et l'IA configure automatiquement votre portefeuille. Cela semble idéal.

Mais avant d'aborder le Vibe Trading, je voudrais d'abord raconter un événement récent qui illustre mieux que toute théorie « où l'IA devrait être utilisée ».

Le 31 mars, le code source de Claude Code d'Anthropic a été accidentellement exposé lors d'une mise à jour npm — environ 512 000 lignes de TypeScript (note : il s'agit du volume total de code après empaquetage, y compris les dépendances et le code généré). L'analyse inverse par la communauté s'est rapidement répandue, des développeurs du monde entier fouillant le code à la recherche de nouvelles fonctionnalités.

Mais la découverte la plus surprenante pour moi n'avait rien à voir avec l'IA. Cette découverte en elle-même n'a pas non plus de lien avec le trading, mais la philosophie d'ingénierie derrière devrait résonner avec ceux qui font du quantitatif.

Dans un module marqué userPromptKeywords par les analystes, il y avait une expression régulière conçue pour détecter des grossièretés comme merde, putain, c'est cassé — afin d'évaluer rapidement si l'utilisateur est en train d'insulter.

La plus grande entreprise de grands modèles de langage au monde utilise des expressions régulières pour détecter les émotions.

Pas pour utiliser Claude pour faire de l'analyse de sentiments. Pas pour entraîner un classifieur. C'est une correspondance de chaînes de caractères s'exécutant à l'échelle de la microseconde.

Pourquoi ?

I. Pourquoi Anthropic n'utilise pas sa propre IA

Ce n'est pas de la paresse. C'est une décision d'ingénierie mûrement réfléchie.

Claude Code traite des centaines de milliers d'interactions utilisateur chaque jour. Chaque interaction doit déterminer si « l'utilisateur exprime de la frustration » afin d'ajuster la stratégie de réponse. Si l'on devait appeler le LLM à chaque fois pour cette évaluation :

• Latence : une inférence LLM prend au moins plusieurs centaines de millisecondes, contre quelques microsecondes pour une correspondance regex.
• Coût : les appels LLM sont facturés au token, la correspondance regex est quasi gratuite.
• Déterminisme : soit la regex correspond, soit elle ne correspond pas, résultat 100% certain ; la sortie du LLM n'est pas déterministe, la même entrée peut donner des jugements différents.

Donc Anthropic a choisi : utiliser la regex pour un filtrage rapide (faible seuil, rapidité, forte déterminisme), et réserver la puissance de calcul du LLM aux décisions qui nécessitent une véritable compréhension sémantique.

Ce n'est pas un détail technique. C'est une philosophie d'architecture : tous les problèmes ne méritent pas d'être résolus avec l'IA.

Ceux qui font du quantitatif devraient particulièrement ressentir cette phrase.

II. Le même choix dans le trading quantitatif

Dans votre stratégie, il y a deux types de décisions :

Décisions déterministes — utilisez des « règles »

Quiconque a écrit des stratégies sur FMZ sait que la logique de trading la plus centrale est souvent composée de quelques lignes de code déterministe :

            javascript
            
            
// Signal de croisement de moyenne mobile — Exemple FMZ JavaScript
var records = exchange.GetRecords(PERIOD_D1)
var ma5 = TA.MA(records, 5)
var ma20 = TA.MA(records, 20)
var idx = records.length - 1

// Croisement haussier : acheter
if (ma5[idx] > ma20[idx] && ma5[idx-1] <= ma20[idx-1]) {
    exchange.SetDirection("buy")
    exchange.Buy(records[idx].Close, 1)
    Log("Croisement haussier des moyennes mobiles, ouverture d'achat")
}

Conditions claires, résultats déterministes, pas besoin de « comprendre » le sens. Écrit avec if-else, 100% fiable, exécuté en millisecondes.

C'est la même logique qu'Anthropic utilisant des regex pour détecter les émotions — problèmes déterministes, outils déterministes. Bien sûr, la regex est une correspondance de chaînes, la moyenne mobile est un calcul mathématique, les outils diffèrent, mais leurs rôles dans leurs systèmes respectifs sont similaires : ce sont des jugements déterministes qui n'ont pas besoin d'IA.

Pour le stop-loss, la fiabilité avec if-else est de 100 %, avec l'IA c'est « probablement ». Votre compte ne peut pas se permettre ce petit risque.

Décisions floues — utilisez l'IA

Mais certaines décisions ne peuvent pas être écrites avec if-else :

• Analyse de sentiment de l'actualité : la déclaration de la Fed est sortie, est-elle hawkish ou dovish ? « Maintenir le taux d'intérêt actuel inchangé, mais le comité surveillera de près l'évolution des données » — cette phrase est-elle positive ou négative ? Les moyennes mobiles ne peuvent pas le dire, et une expression régulière non plus.
• Détection d'anomalies : le volume des discussions sur un altcoin sur les réseaux sociaux a augmenté de 800% en 3 heures, mais le prix n'a pas bougé. Est-ce que « l'argent intelligent se positionne » ou « quelqu'un fait du battage avant un pump » ? Cela nécessite un jugement flou combinant plusieurs dimensions d'information.
• Génération de stratégies : vous avez une intuition — « après ce genre de configuration, il y a souvent une poussée ». Mais vous ne pouvez pas décrire les conditions exactes. Vous pouvez décrire cette intuition à un LLM et lui demander de la transformer en facteur quantitatif backtestable.

Ces scénarios ont un point commun : l'entrée est non structurée, les critères de jugement sont flous, nécessitant une « compréhension » et pas seulement une « correspondance ».

III. Une approche hiérarchique à laquelle s'inspirer

Revenons à l'architecture de Claude Code. L'analyse de la communauté a révélé une hiérarchie claire :

Bien sûr, Claude Code et le trading quantitatif sont deux domaines complètement différents, et la correspondance ici n'est pas une cartographie exacte. Mais la résonance philosophique de conception est réelle — choisir l'outil le plus adapté à chaque niveau, plutôt que de cogner tous les clous avec le même marteau.

La communauté open source met également en pratique des idées similaires. TradingAgents est un framework de trading quantitatif multi-agents récent qui mérite l'attention (construit sur LangGraph, avec un article académique associé). Il simule la structure d'équipe d'une société de trading réelle : un analyste technique s'occupe des chandeliers et des indicateurs, un analyste de sentiment interprète l'actualité et les réseaux sociaux, et des traders de différents styles synthétisent les avis pour prendre la décision finale. Ce n'est pas une IA omnisciente qui fait tout, mais différents rôles remplissant leurs fonctions.

Il est à noter que TradingAgents est un framework de recherche ; il répond à la question « comment l'IA prend-elle des décisions de trading ». Mais en trading réel, vous avez besoin de l'autre moitié : connexion aux exchanges, gestion des ordres, exécution de la gestion des risques, journalisation et audit — ces tâches d'infrastructure technique sont précisément ce que des plateformes quantitatives comme FMZ ont déjà fait pour vous.

IV. Comment le Vibe Trading peut être mis en œuvre : exemple d'architecture hiérarchique

Revenons au Vibe Trading du début. La direction est bonne, mais la condition préalable est que la hiérarchie soit claire.

Supposons qu'aujourd'hui le BTC fasse un croisement haussier des moyennes mobiles, mais que toutes les actualités soient des nouvelles réglementaires négatives. Que faire ? En ne regardant que les moyennes mobiles, il faudrait acheter ; en n'écoutant que les actualités, vous n'osez pas agir. C'est un scénario typique nécessitant une hiérarchie.

Sur FMZ, une architecture hiérarchique simplifiée peut être mise en œuvre comme suit (note : exemple simplifié, pour le trading réel veuillez compléter vous-même les configurations de contrat et la gestion des risques) :

            javascript
            
            
/*
策略参数（在 FMZ 策略编辑页面的"参数"栏中添加）：
  OPENROUTER_API_KEY : string类型，填入你的 OpenRouter API Key
  AI_MODEL           : string类型，默认值 "google/gemini-2.5-flash"，可换成其他模型
*/

// 语义决策层：通过 OpenRouter 调用 AI 获取市场情绪
function getAISentiment() {
    var prompt = "分析当前加密货币市场新闻，给出情绪评分（-1到1，-1极度恐慌，1极度贪婪），只返回一个数字"
    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)
    // AI 返回异常时，回退到中性值——系统可靠性不依赖 AI 的每次正确输出
    if (isNaN(score) || score < -1 || score > 1) {
        Log("AI 返回格式异常，使用默认值 0")
        score = 0
    }
    Log("AI 情绪评分：", score)
    return score
}

function main() {
    var lastSignalTime = 0  // 记录上次信号触发的K线时间，防止同一根K线重复触发

    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]

        // 查持仓状态
        var pos = exchange.GetPosition()
        var hasPosition = pos && pos.length > 0

        // 第一层：确定性信号做"门槛"，金叉触发 + 无持仓 + 未在本根K线处理过，才去问 AI
        if (isBullCross && !hasPosition && curTime !== lastSignalTime) {
            lastSignalTime = curTime
            var sentiment = getAISentiment()

            // 第二层：AI 情绪做"参考"，影响仓位但不独立触发交易
            if (sentiment > 0.2) {
                exchange.SetDirection("buy")
                exchange.Buy(records[idx].Close, 1)
                Log("金叉 + AI看多，全仓开")
            } else if (sentiment > -0.3) {
                exchange.SetDirection("buy")
                exchange.Buy(records[idx].Close, 0.5)
                Log("金叉 + AI中性，半仓开")
            } else {
                Log("金叉但 AI 看空，跳过本次信号")
            }
        }

        // 死叉平仓：确定性规则，不经过 AI
        if (isBearCross && hasPosition) {
            exchange.SetDirection("closebuy")
            exchange.Sell(records[idx].Close, pos[0].Amount)
            Log("均线死叉，平仓")
        }

        // 第三层：止损是"铁律"，不经过 AI
        if (hasPosition) {
            var curPrice = records[idx].Close
            var entryPrice = pos[0].Price
            if (curPrice < entryPrice * 0.97) {  // 跌破开仓价 3%
                exchange.SetDirection("closebuy")
                exchange.Sell(curPrice, pos[0].Amount)
                Log("止损触发，无条件平仓，亏损", ((curPrice/entryPrice - 1)*100).toFixed(2), "%")
            }
        }

        Sleep(60 * 1000)
    }
}

La logique centrale de ce code mérite d'être détaillée :

1. Le croisement haussier des moyennes mobiles est un « seuil ». Ce n'est qu'après qu'un signal certain a été déclenché que l'on fait appel à l'IA. On n'interroge pas le grand modèle sur chaque bougie – cela permet d'économiser de l'argent (les API des grands modèles facturent par token) et d'éviter le bruit. Cela rejoint l'approche d'Anthropic : d'abord un filtre avec une expression régulière, et seulement en cas de correspondance, on lance un traitement plus lourd.

2. Le sentiment de l'IA est une « référence ». Il influence la taille de la position et la décision de sauter un signal, mais ne déclenche pas indépendamment une transaction. Notez que le code gère les valeurs anormales de l'IA : si le grand modèle renvoie un contenu non interprétable, on revient automatiquement à la valeur neutre 0. La fiabilité du système ne doit pas dépendre de chaque sortie correcte de l'IA.

3. Le stop-loss est une « règle absolue ». Une perte de 3 % par rapport au prix d'ouverture provoque une clôture inconditionnelle, sans demander l'avis de l'IA. L'IA pourrait dire « haussier à long terme », mais votre compte ne tiendra pas jusqu'au long terme. Ici, on utilise un stop-loss dur basé sur un pourcentage de prix, sans aucune décision floue.

Voici la bonne façon d'utiliser le Vibe Trading : utiliser le langage naturel pour que l'IA vous aide à « ressentir » l'ambiance du marché, et un code déterminé pour « exécuter » les actions de trading. La frontière entre les deux ne doit pas être floue.

Conseil pratique : dans le système de backtest de FMZ, exécutez d'abord une stratégie basée uniquement sur les moyennes mobiles comme ligne de base, puis ajoutez la couche de sentiment IA, et comparez les rendements et le drawdown. Si l'ajout de l'IA aggrave les résultats, c'est que la stratification est mal conçue – l'IA intervient peut-être là où elle ne devrait pas. Enregistrez chaque résultat de l'IA avec Log() pour pouvoir analyser chaque décision ultérieurement.

五、Une phrase à retenir

Les entreprises d'IA les plus avancées utilisent des expressions régulières pour détecter les émotions, non pas parce qu'elles ne peuvent pas créer une meilleure IA.

C'est parce qu'elles savent que : choisir le bon outil est plus important que choisir un outil puissant.

Les stratégies basées sur les moyennes mobiles ne sont pas glamour, les expressions régulières ne sont pas avancées. Mais dans leur propre domaine, elles sont plus fiables que n'importe quelle IA.

Inversement, lorsque vous devez extraire d'un rapport macro-économique de 5 000 mots un jugement du type « ce rapport est-il haussier ou baissier pour le BTC ? » – les moyennes mobiles ne vous aideront pas, les expressions régulières non plus. C'est là que l'IA doit entrer en jeu.

Ce n'est pas une question « d'utiliser ou non l'IA », c'est une question « à quel niveau l'utiliser ».

Le fichier d'expression régulière apparemment insignifiant dans le code source de Claude Code répond à une question souvent négligée. Et FMZ vous offre une infrastructure en couches toute prête – interfaces d'échange, calcul des indicateurs, gestion en temps réel, audit des logs – tout est déjà fait. Vous avez juste à décider : quelles décisions confier à TA.MA(), et quelles décisions confier à l'IA.

Références :

• Alex Kim - The Claude Code Source Leak — Analyse de détection de frustration par expressions régulières
• FMZ - Building an AI-Powered Automated Trading System — Architecture cerveau IA + mains FMZ
• TradingAgents - Multi-Agents LLM Financial Trading Framework — Cadre open source de trading quantitatif multi-agents
• TradingAgents 论文 — Recherche académique sur le cadre de trading financier multi-agents
• VentureBeat - Claude Code Source Code Leak