Learn

AI in Trading

What language models are and are not good for in a trading workflow, and where the failure modes are.

27 guides

• AI and trading discipline

  A model can make discipline easier or much harder, and which one depends on where you put it. The failure mode is subtle and worth naming.

• How AI hallucination shows up in market analysis

  Not invented tickers — invented specificity. Numbers that sound like data, patterns named with confidence, and a tone that does not vary with certainty.

• Reviewing your trade journal with a model

  The one AI trading use case with a clear payoff and almost no risk — provided you supply data rather than ask for impressions.

• What an AI trading assistant costs to run

  Where the tokens go when an AI assistant drafts a trade plan — input vs output, context resent every call, tool-call round trips — and how to estimate your own bill.

• Why AI backtests do not survive live trading

  A model evaluated on data it was trained on is grading its own homework. The specific leaks, and why the gap is wider for LLMs than for rule-based systems.

• A workflow for trading with an AI copilot

  Where a model belongs in a trading process, in the order the steps actually happen — and which parts should never be handed over.

• Can AI predict the market?

  Language models are not forecasting engines, and the honest answer is no. What they are genuinely useful for in a trading workflow, and where the claim goes wrong.

• Read benchmark, costs and drawdown together

  Use the four-day CoTrading example to trace first execution, costs and drawdown before interpreting a return difference.

• Prepare an A-share quarter bridge for S01

  Prepare cumulative and derived quarterly figures for CoTrading S01 with consistent scope, paired source locations and restatement checks.

• Use Claude Code to check an earnings comparison

  Prepare a two-report CoTrading task for Claude Code, inspect the evidence ledger, and distinguish installation from a completed review.

• Check your ETF CSV before a CoTrading calculation

  Validate a long-format ETF CSV against identity, total-return basis, dates and the declared calendar before comparing strategies.

• Your first CoTrading research run in Codex CLI

  Build a small Codex CLI research folder, explicitly invoke a CoTrading skill, and verify the difference between discovery and task completion.

• Choose ETF data for the question you are testing

  Choose an ETF input for a CoTrading task without confusing traded prices, NAV, distribution events, holdings and total returns.

• Write an ETF rule card before asking for a backtest

  Turn an allocation idea into a confirmed CoTrading rule card with timing, costs, benchmark and explicit unresolved choices.

• Label facts, claims, inference and unknown in a report

  Build a CoTrading evidence table that preserves original amounts, attributed explanations, calculations and unanswered questions.

• Check a Hong Kong report basis before thesis review

  Prepare Hong Kong report inputs for CoTrading by matching issuer, reporting window, currency, unit and consolidated scope.

• Keep an honest log when ETF parameters improve

  Record every CoTrading sensitivity run, compare common intervals and preserve the boundary between exploration and untouched validation.

• Prepare an old thesis for a CoTrading review

  Turn dated research notes into a review input without rewriting old beliefs, and keep new evidence, revisions and unknowns separate.

• Move a research task between Claude, Codex and desktop

  Create a portable CoTrading handoff record while keeping package discovery, calculation results and desktop import support separate.

• How to evaluate an AI trading claim

  Six questions that account for most of the gap between a published result and what you would experience. Use them on any tool, including ours.

• Context windows and stale market data

  A model reasons over whatever is in its context, with no sense of how old any of it is. In a moving market that is a correctness problem, not a cost one.

• Local vs hosted models for trading

  Your chart context and position data are sensitive. Where the model runs decides who else sees them, and the trade-off is capability against custody.

• Non-determinism and what it does to testing

  The same prompt, the same chart, a different trade. Why a single evaluation run is a sample rather than a result, and what to do about it.

• Multi-agent setups and why they compound risk

  Several specialised models sounds like separation of concerns. It multiplies non-determinism, adds untrusted channels between components, and diffuses accountability.

• Prompt injection when the model can place orders

  Anything the model reads sits in the same context as your instructions. With order tools attached, that turns untrusted text into a path to your account.

• Why a trade plan should be structured output

  Prose analysis cannot be validated, logged comparably, or checked against limits. A schema turns a model's opinion into something a program can refuse.

• When not to use AI for trading

  The situations where adding a model makes things worse rather than slower — and the one where it is most tempting and most damaging.