Unironically Using Claude For Quant Trading

I know, I know.... But there might actually be something to this.

If you’ve spent any time on Twitter/X recently, you’ve probably seen the posts: someone claims they prompted ChatGPT to “build a trading bot” and are now printing money from their couch.

The claims range from ambitious to genuinely unhinged:

As a result, the general consensus among serious practitioners is that if you’re using LLMs anywhere near a trading workflow, something has gone wrong.

We had a slightly different take.

In most of these cases, the person posting has never actively traded at scale. So while their implementation is almost certainly wrong, that doesn’t necessarily indict the tool itself.

So, we figured:

“If we have the experience in markets to know what specific things work and which definitely don’t, what if we just gave it a shot, but smarter?”

And that’s exactly what we did, and frankly, what we found was pretty surprising.

So today, we’re going to go on a deep-dive into working with these models the right way. By the end, we promise that you’ll see these being used in a way you haven’t before.

So, without further ado, let’s get right into it.

Prompt Like You Mean It

Okay, first things first, this isn’t 2022 anymore; models like Opus 4.6 and the like are now capable of not just vaguely understanding what you prompt them with, but can now actually do things like work with APIs, execute code, and fully reason out the tasks you give it.

So, instead of going with something like:

“Create a 10 sharpe trading strategy, make no mistakes”

We’re going to task it like we would a real quantitative researcher:

Think about how you’d actually onboard a new analyst. You wouldn’t hand them a Bloomberg terminal and say “find alpha”, but you also wouldn’t hand them a fully written strategy and say “just code it.”

You’d do something in between: give them a defined universe to work with, access to the data they need, a clear objective, and then let them figure out the approach.

With that as the framework, we can start designing the assignment:

1. Using Alphanume’s next-day movers endpoint, we pulled a historical basket of 5 stocks with high likelihoods of large moves in the immediate next trading session.

2. From there, we gave Claude the tools: sector classifications, historical pricing data, volatility metrics, etc.

   1. We showed it what the requests look like, what the response structure is, and let it understand the data it had to work with.

3. Then, we set the objective: “Build a hedged book around these expected movers.”

   1. Not “build a profitable strategy”, not “find the best trade.” Just: here’s a set of names we expect to move, construct a portfolio that captures that move while hedging out as much market and sector risk as possible.

4. And most importantly, we didn’t tell it how to hedge. We didn’t say “use 30-day realized vol to find the closest peer.”
   We added one more constraint: for every pair it constructs, it needs to provide an economic rationale for why the long leg should outperform the short leg over that specific duration.

   1. This is the part that filters out the nonsense. Anyone can match two stocks by sector and call it a pairs trade, but forcing the model to reason about why the trade works, in the context of the specific pair, is what stops this from just becoming a mechanical screen.

And then, we let it cook.