Claude Isn't Your Quant

Where AI belongs in the build loop, and where it doesn't.

Using AI agents to build trading strategies is a seriously over-promised workflow in retail trading, with half of the content I see as just platform marketing. The other half is written by people who have never run a live book. This is the actual workflow: where AI earns its place, where it fails, and the three checks I run before I trust a single line of its output.

What can AI actually do in trading strategy research?

AI does four jobs well in a systematic build loop: generating candidate strategy ideas, red-teaming risk rules, surfacing hidden correlations across a portfolio, and explaining mechanisms you half-understand at speed.

The candidate-generation job is the obvious one. Describe a market behaviour (session-open momentum on indices, mean reversion after failed breakouts in FX majors) and a decent agent will hand you a dozen testable variations in minutes. Most will be junk. A few will be worth building.

The red-team job is the one I'd defend hardest. Hand your agent your strategy statistics, your live drawdown distribution, and your portfolio-level correlations, then ask it to attack your sizing rules. The output is generally sharper than what I've seen from human reviewers, because the model has no ego in the trade hypothesis and no incentive to defend the strategy. It will happily tell you that your two best performers are the same trade using different rules.

What AI cannot do is run your book. It is a weak portfolio-construction agent because it has no persistent access to your live fills, cannot watch your slippage drift in real time, and has no skin in the outcome. Claude can generate 20 candidate strategies in an afternoon. It cannot tell you which 5 belong in the live portfolio and which 15 are correlated through a single hidden factor it has never observed. That call stays with the operator.

The dividing line is simple: AI accelerates research and challenges conclusions. The operator makes decisions.

Where does Claude/Codex sit in my build loop?

My stack is short. StrategyQuantX data mines and does initial robustness checks. Block builders handle strategy generation without me writing raw code, although this is pretty much just for prototyping these days and is redundant for the most part as I've built my own encyclopedia of strategy code. MetaTrader 5 executes. My AI agents sit in two places: before the build, and after test results.

Upstream, Claude is the mechanism interrogator. Before I build anything, I want to know why an edge should exist. If I can't articulate who is on the other side of the trade and why they keep showing up, I'm probably about to curve-fit noise. So the first conversation is always mechanical: what behaviour produces this pattern, what regime does it depend on, what would kill it. If the mechanism story falls apart under questioning, the idea dies before it costs me a build cycle.

Downstream, Claude red-teams the surviving strategies. Once StrategyQuantX or my agents have evolved a set of candidates and they've passed walk-forward and Monte Carlo testing, I hand the statistics to Claude and ask it to find the problems. Which strategies cluster in the same sessions. Where the drawdown overlap sits. Which correlation numbers look stable and which are regime-dependent. The point of this pass is to surface what the headline metrics hide.

I also use agents to build my own portfolio-management tooling: the risk dashboards, the reconciliation scripts, the monitoring frameworks. That's a separate use case from research, but it compounds the same way. Tools I would have needed a developer for in 2024 now take an evening.

What I never do is ask Claude what to trade this week. The model has no live data, no edge, and no accountability.

The model researches. I decide.

What does a useful prompt actually look like?

The prompt structure that gets useful output has four parts: context, artefact, ask, and constraint.

Context means the trading reality the model needs: instrument, timeframe, costs, account structure. A strategy conversation about EUR/USD on H1 with CFD spreads and swap costs is a different conversation from one about S&P futures. If you don't supply the context, the model defaults to generic textbook conditions, and generic textbook conditions are where bad advice comes from.

Artefact means real data. Strategy statistics, a correlation matrix, vol contributions per strategy, a drawdown overlap table, the equity curve numbers. The model reasons dramatically better over an artefact than over a description of one. "My strategies seem correlated" gets you a lecture on diversification. A pasted correlation matrix gets you a specific observation about which pairs are pulling the same trade.

Ask means a narrow, falsifiable request. "Red-team my position-sizing rules and rank the three biggest weaknesses" beats "what do you think of my approach". Ranking forces the model to commit. Open questions invite it to perform balance, and balanced output is mostly useless to an operator who needs a decision sharpened.

Constraint means telling the model what it cannot know. I end research prompts with some version of: flag every claim that depends on data you don't have, and mark every number that isn't from my input. This single line cuts the hallucination rate more than anything else I've tried, because it gives the model permission to expose its own gaps instead of papering over them.

Where does AI fail in strategy research?

Three failure modes account for nearly every bad outcome I've seen.

Over-confident pattern-matching. Ask an LLM why gold sold off last Tuesday and it will produce a fluent, plausible mechanism story. Ask it why gold rallied last Tuesday and it will produce an equally fluent story for the opposite move. The model is a narrative engine. It pattern-matches to explanations that sound like the explanations in its training data, with no internal check on whether the explanation is doing any real work. In strategy research this shows up as beautiful mechanism stories for what is actually just simple noise. The defence is to treat every mechanism story as a hypothesis and take it straight to data.

Invented statistics. LLMs produce numbers with the same confidence whether the number is real or manufactured. Thresholds, historical win rates, academic findings, "studies show" claims: all of it arrives in the same authoritative voice. I've had models hand me precise-sounding figures for FX session volatility that simply do not exist in any dataset.

Generic advice that dies on contact with your instrument. This is the subtle one. The model tells you to widen your stops to reduce whipsaw, which is reasonable in the abstract and wrong for certain books where overnight swap costs eat the carry on a position you now hold three times longer. Textbook advice calibrated to frictionless markets fails when your actual costs arrive. The model doesn't know your spread, your swap rate, or your weekend gap exposure unless you force those numbers into the conversation.

What are the three checks before trusting AI output?

Every piece of AI research output goes through the same three checks before it touches my build queue.

Trace every number. Any statistic, threshold, or empirical claim must trace to a source I can open, or to my own data. If Claude cites a figure, I find it. If I can't find it, the figure is treated as invented and the reasoning built on it is re-derived without it. No exceptions, because one laundered fake number can shape an entire strategy design.

Re-run the advice against your real instrument. Take the recommendation and price it under your actual conditions: your spread, your swap costs, your gap risk, your fill quality. A suggestion that improves a frictionless backtest can be a net loss after CFD financing. This check eliminates a surprising amount of what survives check 1, and it kills the half that would have cost real money.

Demand falsifiability. Every claim worth acting on can be turned into a test: a backtest comparison, a parameter sweep, a 100-trade live sample. If a piece of advice can't be expressed as a testable claim, it's opinion, and it doesn't get implemented. The build loop runs on evidence.

The three checks are cheap. Each takes minutes. What they buy is the right to use a fast, occasionally wrong research partner without inheriting its errors.

The build loop runs on evidence.

What does the operator still own?

After everything above, a specific set of decisions stays with the human, and I think this list is fairly stable even as the models improve.

Portfolio construction is mine. Which strategies make the live book, at what weights, with what correlation budget. The model can flag overlap; it cannot feel the difference between a backtest correlation and the way two strategies actually behave together in a fast market, because it has never watched my book in one.

The live-vs-backtest variance call is mine. After 100 live trades, the divergence between the live equity curve and the projected backtest path tells you whether the strategy was real. Reading that divergence honestly, and pulling a strategy that has drifted too far, is an operator judgement with real money attached. I covered the exact thresholds I use in It's Overfit, my piece on avoiding overfitting in trading strategies, which is worth reading alongside this one.

The kill-switch call is mine. Signal-health metrics degrade before equity curves confirm it. Deciding when degradation has crossed from variance into decay is exactly the kind of ambiguous, accountable call that doesn't belong to a tool with no downside.

AI in the build loop is the biggest leverage I've found since going systematic. The leverage works because the boundary is clean. The model researches. I decide.

How do I set this workflow up from scratch?

Someone asked me recently for a step-by-step a complete beginner could follow, and it's a fair question, because everything above assumes the scaffolding already exists. Here is how I build that scaffolding. It runs the same whether the project is a trading strategy or the back office of a business, because the principle is identical: put your effort into scope before anything gets built. The tool doing the heavy lifting here is Claude Cowork.

The setup goes like this:

1. Open a directory in Claude Cowork. Point it at a clean folder for the project. That folder becomes the home everything else gets built into.
2. Map the scope out loud. Tell it what you are actually building. For a strategy that means risk management, entry types, confluences, your instrument universe, every moving part. For a business it means your CRM, your accounts, your sprints, the things you run day to day. Hold nothing back at this stage.
3. Let it interview you for 30 to 60 minutes. Go back and forth and answer as many questions as you can. The depth you give it here is the depth you get back later.
4. Get it to write an interview markdown file. One file holding every question it still needs answered to understand the project in full.
5. Answer that file by hand in AntiGravity, Obsidian or Cursor. Open it up and work through every single question yourself. Don't skip this one. The manual answers are what hand Cowork the complete scope; rush it and everything stays vague.
6. Have it build the directory structure. Everything split out and organised into a proper folder tree, not one sprawling document.
7. Get a README written. Any agentic coding agent you bring in afterwards reads that first and understands what you are working towards, with no re-explaining from you.
8. Split the skills out. Break the project into separate skills and give each one enough context that it pulls from the same source files every time. That is what stops the different parts drifting away from each other.
9. Lay down a markdown file for every part of the project. Each component documented in its own right, so nothing important lives only in your head.
10. Hand the whole thing to a coding agent and let it build. Move the scope across to Claude Code, Codex, or whichever coder you prefer. The prompting is already done. It is sitting in the files you built in Cowork, so the agent needs almost nothing from you to start building the real thing.

One add-on if the project needs a face. Layer in a design skill and a proper design specification: brand colours, logo, the lot. Hand that over to Claude Design, get it to build the brand out, then have it generate the mockups, a website UI, or whatever app interface you are after. Same principle as the rest, the specification does the work so the build comes close to automatic.

The whole point is front-loaded scope.

Put the hours into the questions and the files, and the build stops being the hard part.

Common questions

Can AI build a profitable trading strategy on its own?
No. AI can generate candidate strategies quickly, and some of those candidates will test well, but selection, validation, sizing, and live monitoring decide profitability, and those jobs need an operator with access to live data and accountability for losses. AI compresses the research stage of the process.

What data should you give an AI before asking for strategy advice?
Give it the instrument, timeframe, and full cost structure (spread, commission, swap, gap risk), plus real artefacts: strategy statistics, correlation matrices, drawdown distributions. The quality of AI trading advice tracks the quality of the data supplied almost one to one.

How do you stop an AI talking you into a bad idea?
Force falsifiability. Require every recommendation to be expressed as a testable claim, then test it in a backtest or a small live sample before implementation. Models reward this structure because it converts persuasive narrative into checkable work.

Do AI-generated trading strategies work in live markets?
Some survive, most don't, and the filter is the same robustness testing that applies to any machine-generated candidate set: walk-forward analysis, parameter sensitivity, Monte Carlo on the trade sequence, then a small live allocation with a 100-trade review. Treat AI-generated candidates as raw material for that pipeline.

Is Claude better than ChatGPT for trading strategy research?
I use Claude and ChatGPT's coding agent (Codex) because they handle long technical artefacts (correlation matrices, strategy statistics, code for my tooling) well in a single conversation, and that fits my workflow. The workflow in this article matters more than the model choice: context, artefact, narrow ask, constraint, then the three checks on the output.