I Let AI Build My Quant Trading Framework. Then the Exchange Returned 502.

Burning tokens won't build the holy grail: Vibe coding and the industrial-grade quant trading framework

Late at night, you open an AI and type: "Help me write an industrial-grade quantitative trading framework."

It answers fast. The directory tree is neat: data, strategy, backtest, execution, risk, monitor, config. Dependencies listed. You click run. The backtest curve goes up. Sharpe 2.7, max drawdown 8%. You stare at the screen, fingers pause on the keyboard, then you screenshot it and send it to a group chat.

Someone replies: "Nice."

You feel like you found the holy grail. The holy grail is not in the directory tree.

What Vibe Coding can give you

The core of Vibe Coding is simple. You describe requirements in natural language. AI generates code. If something feels off, you keep talking and keep changing. You do not write every line. You hold the direction.

That is powerful. It lets you build scaffolding fast: data ingestion, cleaning, backtesting, visualization, logging, config, CLI. It helps with glue code: exchange APIs, databases, message queues, monitoring. It writes tests and documentation. It assists research. You can build agents: researcher, risk manager, trader.

If your head is clear, if you express requirements precisely, and if you understand a little software engineering, you can burn tokens and build your own quant framework.

But this is only a framework. It is not edge.

A framework is a container. Alpha is the content. A good container with nothing inside makes no money.

Industrial-grade does not mean it runs

Industrial-grade does not mean 100% annualized backtest. It does not mean a hundred GitHub stars.

Industrial-grade means data can be traced, checked, and versioned. Backtests include real costs and slippage, and they respect capacity constraints. Orders are idempotent. State is recoverable. Disconnections reconnect. Risk controls are hard-coded and independent of strategy. They have a kill switch. You have logs, monitoring, alerts, and replay across the chain. Keys are isolated. Privileges are minimal. Audit records exist. Paper trading and small-capital live gates are in place. Humans bear final responsibility, not AI.

You look at the list. You think you can build it slowly.

Then the exchange API returns 502. Your order state is unknown. You open the web page and manually check positions. One order was submitted twice. Risk control did not stop it. The log has one line: ERROR.

You sit back down. Your palms are sweaty.

Data: garbage in, hallucination out

You use a free data source. Cheap, even free.

During backtest, you see a stock with good earnings, buy it, and make money. Later you learn the earnings report was revised. What the market saw was another version. You used future information.

You see a constituent list. It is today's list. You backtest five years ago using today's constituents. Delisted stocks disappear. Suspended stocks have prices that do not move. Limit-up and limit-down: your backtest fills. T+1: your backtest sells the same day.

You spend huge time cleaning data, verifying again and again. AI helps write cleaning code. It cannot judge whether the data is correct.

More critically, much free data is not point-in-time.

Garbage in, garbage out. Dirty data in, hallucination out.

Later you upgrade. You listen to LLM recommendations. You build models: XGBoost, HMM, LightGBM for prediction. GNN, KNN for probabilities. The problem is not the model. The problem is the input.

XGBoost is not lazy. LightGBM is not unintelligent. You train on wrong history, reward with wrong validation, and explain with hallucinations.

A model is a mirror. What you give it, it reflects.

Backtest illusion

Backtesting is the easiest place to lie to yourself.

A beautiful curve may come from look-ahead bias: using information that was not known at the time. Data snooping: tuning parameters until the curve looks good. Survivorship bias: backtesting only stocks that survived. Ignored costs: no slippage, fees, or market impact. Ignored capacity: small capacity fails when capital grows. Ignored liquidity: limit-up, limit-down, suspension, zero volume mean no fill. Overfitting: so many parameters that it fits noise.

You tune to version 47. Sharpe 3.8. You know it may be overfit. You cannot delete it. You click save.

You think you validate a strategy. You validate your own hallucination.

Backtest profits do not equal live profits. Paper trading profits do not equal live profits. Small-capital live profits do not equal large-capital live profits. Profits over three months do not equal profits over the next three months.

Execution: orders do not follow the backtest

In backtest, you press buy. The fill price is the close.

In live trading, your order may partially fill. It may be rejected. It may be rate-limited. It may time out. It may be submitted twice. It may lose state after a disconnect. The exchange API may return an abnormal response. Network jitter may delay market data. You may be unable to buy at limit-up. You may be unable to sell because of T+1. You may suffer huge slippage because liquidity is insufficient.

An industrial-grade execution system needs an order state machine, idempotency, retry mechanisms, cancel-and-replace, reconnect logic, state recovery, rate limiting, pre-trade risk controls, and audit logs.

AI can write an order function. Industrial-grade execution is a whole reliable system.

Risk control: your hand is on the mouse, but you do not click

Risk control is the lifeline of quantitative trading.

Many people treat it as part of the strategy. That is dangerous.

Risk control must be independent, hard-coded, deterministic. It cannot be left to LLM discretion. It cannot be voted on by agents. It cannot be "I feel risk is not high today."

Risk control includes pre-trade limits: position limits, single-name caps, sector exposure, leverage limits. It includes intraday controls: real-time drawdown monitoring, circuit breakers, kill switch, abnormal order blocking. It includes post-trade work: attribution analysis, risk reports, review.

Drawdown 18%. You stare at the screen. Hand on the mouse. Kill switch right there. You do not click. You want to wait.

Risk control comes down to whether you can press stop when losing. Not code.

AI can write risk rules. AI cannot keep discipline for you when the market goes crazy.

Industrial-grade risk control is not code. It is human final responsibility.

Agent cognitive contamination: three agents merge into one

You build a researcher agent, a trader agent, and a risk manager agent. You want separate roles.

In operation, they share context. Memories connect. Invalid information keeps being injected. Goals drift. The three agents merge into one confident hallucination machine.

In the chat log: the researcher says this factor works. The trader says buy. Risk says risk is controllable.

They may all be on the same wrong data, the same overfit model, the same hallucinated logic.

LLMs generate coherent text. Coherent does not mean correct. Confident does not mean reliable.

In quantitative trading, consistent error is more dangerous than random error. You will believe it.

Reinventing the wheel

You go around in circles. Burn many tokens. Finally build your own quant framework.

Then you discover ready-made tools: qlib, vn.py, nautilus_trader, backtrader, vectorbt, ccxt, polars, duckdb, ClickHouse, Prometheus, Grafana.

You download one. Write a simple Python script. Backtest. You look back at what you burned tokens to build. Three hundred commits. Two stars on GitHub.

You feel like a clown.

This is the typical programmer's disease: reinventing the wheel.

Reinventing the wheel is not completely worthless. If building the wheel helped you understand data, backtesting, execution, and risk control, those tokens were not wasted. If you only wanted to own your own framework, yes, it is easy to become a clown.

The goal is not to own a framework. The goal is to own edge.

Making money is another question

The framework is built. The model is trained. The backtest is beautiful. Paper trading is profitable.

Then live trading.

First week: up 3%. Second week: gives it back. Third week: fees eat profit. Fourth week: you intervene manually and lose more.

The money-making window may be only a few months. When the wind comes, following the crowd makes money. When to run is another question.

China A-shares often reward running fast and playing Dou Dizhu. That is not the whole of quantitative trading.

Quantitative trading needs edge that can be repeated, controlled, and executed.

Without edge, even an industrial-grade framework does not make money. With edge, even a simple script can make money.

Alpha decays. Markets change. Strategies fail. What worked in the past may not work in the future.

The framework is not the destination. The framework is only the tool you use to capture edge.

A realistic path

Do not start by building a grand framework.

Use existing wheels first: vectorbt, backtrader, qlib, vn.py, nautilus_trader, ccxt, polars, duckdb, ClickHouse, Prometheus/Grafana.

First write a simple backtest script. Verify data, costs, execution. Start strategies from simple baselines: momentum, mean reversion, carry, portfolio rebalancing. Complex models come later.

Let AI be a pair programmer, code reviewer, and documentation assistant. Not a prophet. Agents can divide labor. Risk control must be independent and hard-ruled. Order permissions must be tightly restricted.

Every round of failure must be reviewed. Is it a data problem, a logic problem, an execution problem, a risk control problem, or simply no market edge?

Vibe Coding can make you fail faster. Only structured failure can bring you to the next moment of real insight.

Minimum industrial-grade checklist

If you cannot meet these, it is only a personal framework.

Data is point-in-time, versionable, verifiable. Backtests include real costs, slippage, capacity constraints. Orders are idempotent. State is recoverable. Disconnections reconnect. Risk controls are hard-coded, independent of strategy, with a kill switch. Full-chain logs, monitoring, alerts, replay. Key isolation, least privilege, audit records. Paper trading and small-capital live gates. Humans bear final responsibility, not AI.

Close the IDE

You will not give up because of what I said.

I have been on this road. I have failed several times. I know: if you could easily burn tokens, build your own quant framework, and make money, that does not exist in the real world.

Only after failure, failure, failure, failure, failure, failure can success become possible. Every failure pulls back the fog and shows what is real.

Vibe Coding can help you write code. Industrial-grade ultimately grows on you.

You close the IDE. Open the trade log. See a manual stop-loss. See a duplicate order. See one line: ORDER_REJECTED.

You write these down. Tomorrow you fix them again.

The framework is a container. Alpha is the content. You are the final risk control system.