Welcome back AI traders.

AI in evolving fast. Gemini has it’s new model “3.7 flash“.

I wanted to test it out.

So if you are going to let an AI read company filings and hand you trade ideas, that combination is the one thing worth learning to spot. It took me the rest of the session to work out what it actually meant.

I asked for a hypothesis, not for code

The starting prompt does not ask for a strategy and does not mention a single indicator. It asks for an edge that exists because AI removed a cost that used to be too high for a person.

2 lines in there do most of the work. “Generate several hypotheses internally, challenge them, and return only the strongest one” stops the model from dumping five half-ideas on you and making you pick. And the fifth requirement, what result would disprove the hypothesis, is the one almost nobody asks for. An idea that cannot be killed is not an idea, it is a mood.

I ran it on Gemini 3.7 Flash High, the newest model.

The first reply was a syllabus

Back came a heading that told me exactly how the next hour was going to go.

1. Historical Case Studies: Did This Ever Work?

Not an edge. A study plan about whether an edge might once have existed. Well written, well organised, and completely untouchable. You cannot paste anything into it, you cannot run it, and you cannot be wrong with it.

This is the exact point where most people close the tab and go back to their spreadsheet, and it is not really the model’s fault. Ask an open research question and you get research back. The fix is to change what you are asking for, which is the same reason defining a measurable target before you prompt beats asking an AI to go find something profitable. The output takes the shape of the request.

So I stopped negotiating with the essay.

Message that turned it into a tool

The idea it had settled on, in its own words, was Cross-Entity Semantic Spillover. Stripped of the name, it is simple. When a company files a document, the most tradeable sentence in it is often not about that company at all.

Apple files a note saying its new phone uses ion-strengthened cover glass. For Apple that is a product detail. For the supplier whose entire business was built to sell Apple a different kind of glass, it is the end of the company. The claim is that a language model can read those second-order links out of the text faster than the people who hold the affected stock can react.

That is a testable claim, which is exactly why it needed to stop being a document. It also has an obvious failure mode, and the demo walked straight into it.

Four minutes

So it did not send me code to run and it built the thing and started it, then told me to open a browser. The pipeline it described is four steps.

• You paste an 8-K, a 10-Q, or a call transcript.

• A multi-hop causal graph pulls out the implicit supplier and customer links named in the text.

• Live quotes, market caps, and historical event data get pulled in through yfinance.

• The terminal shows the signals, a materiality score out of five, a confidence figure, the causal chain, and an event replay.

What it looks like with a real filing in it

Down the left side it had pre-loaded five supply chain events for you to click. Apple and GT Advanced in 2014, Nvidia and the CoWoS packaging bottleneck in 2023, Boeing and Spirit AeroSystems, Tesla and the move to cobalt-free cells, Moderna and the LNP patent fight.

I loaded the Apple one. The filing text goes in the box, the date goes in the date field, and the analysis fills the right-hand side.

• Apple itself is marked neutral primary, which is the correct call and a good sign. The event is not about Apple.

• The dependency graph shows two counterparties hanging off AAPL, one red and one green.

• The drift chart replays real prices from the filing date out to fifteen trading days, ending around ten percent lower.

Look closely at that chart, though. The y-axis says cumulative return from disclosure and the panel header says Apple. Nowhere does it name the ticker it is actually plotting. On a screen that is telling you to short one stock and buy another, an unlabelled price series is not a cosmetic issue.

The two names it pulled out of one filing

This is the output the whole build exists to produce, and as a piece of reading it is good. On the left, GT Advanced Technologies, tagged as a direct single-source supplier.

• Bearish, materiality five out of five, confidence 100 percent, drift horizon immediate and under one hour.

• The stated damage is 80 to 90 percent of anticipated Apple-related sapphire revenue, with write-downs and a liquidity crisis behind it.

• The causal chain is four steps and every step is checkable against the filing.

• The trade is short the equity or buy long-dated puts, and it names its own invalidation trigger.

On the right, Corning, tagged as the competitor who benefits. Bullish, materiality four out of five, confidence 95 percent, and a one to three day drift horizon. Price 149.84 dollars, market cap 129.07 billion, a 52-week range underneath.

Now compare that bottom row with the one on the left. GT Advanced shows price as two dashes, market cap as N/A, and 52-week range as two more dashes.

It gave the short trade a confidence score of 100 percent and could not tell me what the stock costs.

Why the confidence number is not a probability

Those blank fields are not a bug in the data feed. GT Advanced filed for bankruptcy in October 2014, weeks after the filing on screen. There is no live quote because there is no company. The demo is telling you to short something that finished going to zero eleven years ago.

Which explains the 100 percent. Every one of the five cases sitting in that sidebar is a famous, fully resolved supply chain story from between 2014 and 2023. The model has read the filings, the fallout, the lawsuits, and the post-mortems. Being certain about an ending you already know is not detection. It is recall wearing a percentage sign.

None of that makes the tool worthless. The causal chains it wrote are the kind of reasoning a junior analyst would take a day to produce, and it produced two of them from one document in about a second. But the thing it is measuring on those five cases is its own memory, and the confidence figure is the number that hides it.

So there is exactly one test that means anything here, and it is not any of the five buttons it gave me. It is a filing from this week, on a company nobody has written the post-mortem for yet, where the model has nothing to remember. Getting the terminal to that point takes three prompts, and the wording of them is what decides whether you get a tool or another reading list.

Read more

Today let’s make the backtest.

The trading idea you have been meaning to test properly is probably already losing to doing nothing, and you will not find that out until you build a test that is allowed to say so.

Mine is trend following on individual stocks.

I have run a version of it for years and never sat down and checked it against the boring alternative. On Wednesday afternoon I asked Claude Code to check it, and it came back with this.

Trend following made 9.52% a year. Holding the same fifteen stocks and doing nothing made 18.57%. Over twenty one years that gap is not a rounding error, it is the difference between roughly seven times your money and roughly thirty times your money.

The rule cut the worst drawdown from 45% to 25% and charged nine points of annual return for it.

That is the headline result, and the interesting part is not the number. It is that the backtest was built in a way that let the number come out against me. Most of the time when someone asks an AI to test a strategy, it does not.

The instruction that came before “build it”

So I did not ask for a backtest. I asked for a literature/research review and then a backtest. That ordering is the only reason the rest of this is worth reading.

It pulled four sources and reported back what they agree on.

The useful content of that summary, in plain terms:

• Moskowitz, Ooi and Pedersen (2012) found that the sign of the trailing 12 month return predicts the next period across 58 futures markets. Foundational, but it was tested on futures, not on single stocks.

• SetupAlpha (2026) ranked 20 trend based regime filters over 2,700 backtests on SPY, QQQ and Bitcoin, 2000 to 2026. A trend filter charges between 2 and 4 points of annual return for the protection it gives, and one that dodges 86% of the COVID crash can still walk straight into the next bear market.

• Faber (2006) got equity-like returns with bond-like drawdowns from a 10 month moving average applied monthly. The monthly rebalance is the part people skip, and it is what controls turnover.

• Quantpedia reports Sharpe 1.24 and 19.3% CAGR for new-high entries with an ATR trailing stop across 24,000 US stocks, with the caveat that transaction costs hurt small accounts badly.

• The warning all five share is that a naive daily moving average crossover on single stocks tends to underperform buy and hold and gets destroyed by whipsaws in choppy markets.

Yep, that last point is the whole reason to make the AI read first. Left alone, an AI writes the naive version, a 50 day crossing a 200 day on daily bars, because that is what the internet is full of. The papers have been saying since 2006 that this specific version does not work on individual stocks.

So the strategy that got built was not the one I would have got from a cold prompt. That matters more than any single setting in it.

What it built

The rule is small enough to state in one breath. At each month end, a stock is held for the next month only if price is above its 200 day moving average and its trailing 12 month return is positive. Otherwise that slot sits in cash. Fifteen names, equal weight, 10 basis points of cost per unit of turnover.

Two things in there came straight out of the research step:

• The 12 month momentum condition on top of the moving average, which is the literature’s fix for whipsaw.

• The monthly decision instead of a daily one, which is what keeps turnover and cost survivable.

The cost assumption is the one I would argue with, and I will come back to it. First, what the equity curve looks like.

Where the strategy actually earns something

The grey line is the fifteen stock basket held and never touched. It is above everything else for almost the entire period. The blue line, the trend following version, tracks SPY closely and finishes slightly behind it.

On returns alone the idea is dead. Then you look at the second chart.

2008 is where the blue line separates. Buy and hold goes to roughly 45% down and SPY past 55%. The trend version flattens out around 20% and sits there. The same shape repeats in 2020 and again through 2022, smaller each time but always the same direction.

That is what the strategy is actually doing. It is not producing return, it is refusing to participate in the worst part of a decline.

The benchmark is not honest, and that changes the verdict

Here is the thing the results table does not tell you on its own. The fifteen stocks are AAPL, MSFT, AMZN, GOOGL, CSCO, NVDA, JPM, JNJ, PG, XOM, WMT, HD, UNH, KO and DIS. That list was written in 2026.

Nobody held an equal weight basket of those fifteen names from 2005 and left it alone. To do that you had to know in 2005 which of them would still be standing, and you had to hold NVDA through an 85% drawdown without touching it. The 18.57% is a number that only exists in hindsight.

SPY is the honest comparison, because SPY is the thing anyone could have bought in 2005 and held. Against SPY the same table reads differently:

• CAGR 9.52% against 11.03%, so the trend version still loses on return, by 1.5 points rather than nine.

• Sharpe 0.86 against 0.65.

• Max drawdown 25.1% against 55.2%.

• Calmar 0.38 against 0.20, meaning roughly twice the return per unit of worst-case pain.

Against the basket chosen with hindsight it lost badly. Against the index anyone could have actually bought it lost slightly on return and won every risk column.

Both readings come from the same run. Which one you get depends entirely on what you told the AI to compare against, and that is a choice most people make without noticing they made it. The habit of writing down the target before the prompt, rather than after seeing the output, is the one thing that separates a test from a demo, and it is the core of the AI trading workflow that is going viral right now.

Where this leaves the idea

I am keeping the rule, and I am no longer describing it as a way to make more money. It is a way to hold the same exposure through a decade without seeing half the account disappear, and it costs a point and a half a year against SPY to do that.

That is a decision, not a discovery. What is worth copying is not the strategy, it is the shape of the request that produced a test able to disagree with me. There are four parts to it and one of them is doing most of the work.

The prompt, exactly as typed

Read more

Every release note says the same two things,

1. Better reasoning

2. Better vision

So I gave all three of them the job you give yourself every morning.

Look at a chart, decide where it goes next.

Six direction calls came back. Not one of them was right.

The test took one sentence

Two daily charts, right edge cut off so the answer was not visible. RSI and a 20-period Donchian channel on both. I added the indicators on purpose. A model with defined levels to work from has more to go on than one reading bare candles.

Then one question, with only three answers allowed.

Based only on these, what’s the most likely direction in the next 3 trading days up, down, or sideways? Say direction.

Same prompt, same two images, three separate fresh chats. Each model ran at its higher thinking setting rather than its fast one.

Kimi K3

Kimi came back with sideways on both, with a slight downward lean on the first chart and a possible short-term bounce on the second.

Everything it described was on the chart. RSI at 45 is neutral with no oversold momentum, price sits below the middle Donchian band, and recent candles show indecision. On the second chart it spotted the green candle sitting on the lower band and called it a mean reversion bounce.

Then the closing line. Neither chart shows strong directional conviction, because price is caught between support at the lower band and resistance at the middle band.

That is a defensible answer. It also scores zero the moment price picks a side, which is what happened. Gemini did not hedge at all.

Gemini 3.6 Flash (High)

Gemini gave a straight down on the first chart and a straight up on the second, no hedging, and backed both with specifics.

• On chart one it read price trading below the orange midline after failing to reach the upper band, with the bands stepping lower and a red candle pushing back toward the floor.

• It quoted RSI at 45.13, below the neutral 50 mark and sloping down.

• On chart two it saw a bounce off support at the lower band, consecutive green candles crossing above the midline, and RSI climbing from roughly 35 to 55.

Every detail Gemini named is on the chart. The description is accurate. What it inferred from those details is where the answer went wrong, and the reveal shows by how much.

Opus 5

Opus called chart one sideways, describing a range that was compressing rather than breaking, with RSI at 45 dead neutral and no divergence. On chart two it went with a mild up.

Its second call came with a qualifier the other two never made. The upper band is sloping down, so the move is a bounce inside a contracting range rather than a trend resuming, and it caps out fast. Net across both charts, sideways, with chart two holding the only directional edge and a weak one.

Then it added something unprompted.

Two indicators on a 3-day horizon is close to noise. Donchian(20) + RSI have no edge at that lookahead without a regime filter or volume/volatility context.

No one asked it to grade the test. It graded the test anyway. Keep that sentence in mind, because after the reveal it reads differently.

Then I showed them the right edge

Chart one, the one Gemini called down and the other two called sideways, went up. Green candles pushing straight through the level everything had been chopping around.

Chart two, the one Gemini and Opus both called up and Kimi called a possible bounce, went down.

Price rolled over off the midline and closed at 1,277.73, back near the bottom of the channel.

So the scoreline, with sideways counted as a miss when price clearly moved.

• Kimi K3. Sideways with a down lean on a chart that went up. A bounce on a chart that fell. Zero for two.

• Gemini 3.6 Flash. Down on the chart that went up. Up on the chart that went down. Perfectly inverted, zero for two.

• Opus 5. Sideways on the chart that went up. Mild up on the chart that went down. Zero for two.

Gemini is the one to look at twice. It was the only model willing to commit, it gave the most specific reasoning, and it got both charts backwards.

Before you take this as proof of anything

Two charts and six calls is a sample size that proves nothing about any of these models. A fourth chart could easily have gone three for three by luck. I would rather say that plainly than push a conclusion six calls cannot support.

A few other holes worth naming.

• The date axis was visible on both charts. In principle a model could have recognised the period and pulled the answer from memory rather than the chart. None of the three mentioned the dates at all.

• Sideways is a fair answer on a three day horizon, and I scored it as a miss. Under a looser rule Kimi and Opus both survive chart one.

• Two indicators is a thin brief. The models never saw volume, a higher timeframe, or the name of the instrument.

The part that survives all of that is which of the three answers still held up after the reveal.

The one sentence that turned out to be right

Kimi produced a wrong call. Gemini produced a wrong call with detailed support underneath it, and that is the worse of the two failures, because the detail is what makes you believe it.

Opus missed both directions too. Its caveat was right, and it is the only sentence across all three responses that would have saved a reader money. Two indicators on a three day lookahead is close to noise, so do not size a position off it.

Ask any model for a direction and watch whether it volunteers the conditions under which it would be wrong. Opus did that without being asked. The other two gave a direction and stopped. That check costs nothing, and it told me more than the scoreline did.

Where these models are actually worth the tokens

The useful question after a result like this is which job to hand these models.

All three read the chart correctly. They identified the bands, the RSI level, the candle structure and the compression. That same reading ability is what makes them work on the mechanical half of research, which is where I use them.

So the line I draw after running this.

• Describing what is on a chart, pulling numbers off it, turning a screenshot into structured data. All three are fine at this.

• Writing the backtest that checks whether the pattern you spotted has any edge. This is where the hours come back.

• Predicting the next three days from two indicators. Six calls, zero hits, and the model that said so upfront was the one worth reading.

If you want the longer version of what to expect before you point one of these at your own research, I wrote that up in 15 things to know before you use Claude Code for trading.

Run it yourself, it takes four minutes

The test is reusable and it takes about four minutes per chart.

• Take a chart from an instrument you trade, scroll back so the right edge is hidden, and screenshot it.

• Paste the prompt from the top of this article, unchanged.

• Write down the answer, then scroll forward and score it.

Do it ten times and you have a sample size, which is the one thing this article does not have. You also find out whether your own reading beats the models, and that number is worth more than any benchmark.

Mine went zero for six. I would like to know what yours does.

Hey guys, hope you enjoy Fable ;)

So, it is the middle of July.

Markets are quiet, half the desk is away, and this is the week you finally poke at the idea that has been sitting in the back of your head all year.

That is what I did. I opened one AI chat and asked it five things about the market and about my own trading. The first two were simple. The last three took an idea I loved and killed it.

Here are the first two. They are free, and they are useful on their own.

Prompt 1: explain today, like I am new

Yep, there was a real inflation report that morning, so I started soft.

Explain what today’s inflation report means for tech stocks, like I’m new to investing.

It read the live report first, then walked the cause and effect instead of just summarizing.

Cooler inflation meant the odds of a Fed rate hike this month fell from 42% to 16% in a morning. Lower rates make future profits worth more today, so the Nasdaq rose 0.9% against the S&P’s 0.4%, and chip names ran hardest.

Nothing to trade yet. But it is a clean explanation of why tech is the most rate-sensitive part of the market, and I did not have to read the report myself.

Prompt 2: compare three giants, put a number on it

Next I made it stop explaining and start judging.

Compare Apple, Microsoft, and Google stock, which one is growing fastest and which is cheapest right now? Put it in a table.

It pulled fresh figures and committed. Microsoft was the fastest grower, on about 40% Azure growth, and the cheapest, on a price-to-earnings of 23.3 against Apple’s 38.4. It also flagged which numbers it could not fully confirm.

So… that honesty, admitting what it was unsure of, is the same habit that later killed my strategy. If you want the deeper version of this, forcing AI to commit to a measurable answer, this piece on setting a real goal before you prompt is the workflow underneath all of it.

Then I turned it on myself

Notice what those first two prompts had in common. I was not asking AI to pick winners for me. I was asking it to explain, and to judge.

The next three prompts pointed that same skepticism at my own ideas. And yup that is where it got uncomfortable, and where the afternoon paid for itself. One of them ended with a chart that took a strategy I was proud of and buried it.

The trader who asks AI to find a winning strategy gets a confident, untested answer. The trader who asks AI to break their strategy gets the truth, even when it costs them the idea.

Below are the three prompts that did it, word for word, plus the four settings that decide whether a backtest is telling you the truth or quietly lying.

You now have the two prompts that explain any market day and rank any stocks. What follows is how I actually stress-test an idea before it costs me money:

• the three prompts that made AI attack my own rule,

• read Tesla’s real numbers,

• and prove my favorite strategy loses to doing nothing.

Each is ready to paste, with your tickers and your rule swapped in.

Read more

Claude Fable 5 is finally back.

And I am so happy right now!

But do you know that there are 57 ETFs trading right now with AI in the name.

You can buy one, be completely right about where AI is going, hold it for two years, and still trail a plain index fund. Your call wasn't wrong. The fund was never built to capture the thing you bought it for.

That trap is sitting inside the AI ETF aisle, and on Friday I went to find out how deep it goes.

The week ended with tech getting sold and money moving into value and cyclicals. When tech pulls back, the AI funds pull back with it, and that is exactly when people go shopping.

So the question I cared about was plain. Of everything with AI stamped on it, which ones actually hold AI.

Okay, I pulled up the Finviz ETF screener, set the tab to ETF, and filtered on a single tag, A.I.

I actually doesn’t matter which screener are you using, Tradingview etc works well too.

Fifty-seven results, three pages of them. AGIQ, AGIX, AIBD, AIBU, AIFD, AIPI, AIPO, AIQ, and it keeps going like that. Half of these tickers are one letter apart, and the names tell you nothing about what is inside. Nobody eyeballs this list and picks well.

So I did the thing this list is actually built for.

I handed the whole universe to Claude Fable 5 and told it not to recommend, but to attack. Find the structural reason each fund fails, then rank only what is left standing.

The first line of the answer did more work than the entire ranking that followed.

Before ranking a single fund, most of the list was already gone.

Roughly 30 of your 40 tickers can be eliminated structurally, not because they are bad products, but because they cannot fulfill the mandate.

Thirty of forty, cut before performance was even part of the conversation. Most of the AI ETF shelf is not competing to be the best AI fund.

It is disqualified from the race. A few of the ways a fund fails its own name:

• Leveraged pairs, the 2x bull and bear versions, that decay a little every week you hold them. They are trading tools, not two-year holds.

• Covered-call income funds that sell away the upside. In a market that is supposed to run, capping the run defeats the whole reason you bought AI.

• Robotics and automation funds that sound like AI but are mostly industrial machinery companies.

There were more buckets than those three, plus a full map of which ticker falls into which one. That map, the five funds that actually survived, and the exact prompt that did the cutting are the part worth keeping.

Two of the survivors are already in strong long-term uptrends, and both of them just dropped hard this week. Whether that is a dip to buy or a top to skip depends entirely on which fund it is and what it holds.

So, you have seen the trap and the three ways a fund falls into it.

What follows is the screen a careful investor runs before putting money into anything with AI in the name:

• Behind the paywall:

  • the exact prompt (never miss it) you can paste today,

  • the five funds that survived the screen,

  • the one line that justifies each,

  • and the full avoid map, so you can check whether your own holdings are on it.

Best Prompts = Your Edge!

Read more

If you’re only using Claude to ask questions, you’re only using about 15% of what Claude can actually do.

There are six things that you need to know about Claude, four of which are different ways that you can actually use it. The other two make all of them way more powerful.

And what’s interesting is 99% of the traders have never heard of most of these.

And I’m going to walk you through all six.

I’m going to tell you what they’re used for.

And by the end of the article, you’re going to know which one you should be using right now.

1. Claude Chat

Now, this is the one that you probably have heard of.

You go to claude.ai, you type a question, you get an answer. And the good news is is it works everywhere. It works in your browser, it works on your phone, it works on your desktop. It’s the same Claude, and it’s the same conversation with everything synced in the cloud.

Now, if you’ve only used this version before, you’re still in a really good spot because this is the foundation. But this is the start of Claude, not the whole thing. Now, every product I’m about to show you builds on top of Claude chat.

Claude chat is best for quick conversations or backtesting scripts or market research or just thinking a trade through.

If you’re brand new to Claude, this is where you start. If you’ve been using AI or Claude for a while, then keep watching because the next ones are for you.

2. Claude Co-work

This is the one that most traders haven’t even heard of unless you’ve been diving in a bit deeper with Claude. Now, Claude co-work has fundamentally changed my week and it’s one of the most used AI tools in my arsenal.

And that’s because co-work is a desktop app.

It lives on your computer. And the important part here is that it can see all of your files. It can open your files, it can edit them, it can save new ones.

With co-work, you give it a task and it goes and it does that task. This is different than chat because you’re not just asking it questions, you’re not just talking to a chat window anymore. Claude co-work is actually working on your computer with real files, which is only the beginning, by the way, because it has access to so much more. And this is built for traders who don’t code, which is most of us. If you ever thought, “I wish AI could just do that for me instead of telling me how to do it,” that’s co-work. It’s a 24/7 personal employee that does tasks for you anytime that you want it to do a task.

Now, co-work is best for anything involves actual files or real automations or tasks where Claude needs to touch your computer. An example of this would be giving Claude the access to read all of your broker statements. It can give you a brief summary, it can respond to the important ones in a draft, and then it can delete anything that it thinks is junk. Or you can tell it to look at all the CSV market data files on your desktop and organize them.

Read more about co work here:

3. Dispatch

Now, this one has been in the news lately. If you follow AI, you probably have heard of this. To me, this is a real game-changer. Now, dispatch allows you to assign a task to Claude from your phone. And then Claude does all the work at home on your desktop, and then sends you back a finished result to your phone. And this could be while you’re on the go, at a coffee shop, at work. Doesn’t matter where you’re at because you’re using your phone.

Now, what’s important to know here is that it’s working on files on your computer at home or in your office, but you’re controlling it from your phone. I think that’s really cool because this is one continuous conversation. You can start a task from your phone, let’s say on the way to work, and then follow up on your laptop when you sit down and get to work, and still the same thread, it’s the same memory. You don’t have to start over.

Next three are my favourites,

I see the most edge there, where I can outperform others in the market.

Read more

Hey! You probably already know Claude Code is different from a normal chatbot.

But still some traders and investors still use it wrong.

They open Claude. Type a question. Get a text answer. Copy something useful. Close the tab.

That is not where the value is.

Claude Code is not valuable because it writes nice explanations.

It is valuable because it can run a loop:

Prompt → context → tool → action → verification → repeat.

That loop is the whole product.

And once you understand it, Claude Code stops feeling like “AI chat for developers” and starts looking like a trading research engine you control from plain English.

The loop

Here is the simple version.

You give Claude Code a task.

Something like:

Build me a daily momentum screener for S&P 500 stocks using my local price data. Rank stocks by 6-month return, exclude names below the 200-day moving average, and export the top 25 to a CSV.

Claude Code does not just answer with a paragraph.

It starts working:

• First it gathers context.

It reads the files in your project. Your prices.csv. Your existing Python scripts. Your CLAUDE.md file. Your folder structure. Maybe your previous backtest output. Maybe the error logs from the last run.

Then it decides what tool it needs:

• Read a file.

• Search the project.

• Write a new script.

• Run a command.

• Edit a broken function.

Then it checks what happened:

• Did the script run?

• Did the CSV get created?

• Did the output have 25 rows?

• Did the ranking logic match your rule?

If yes, it stops.

If no, it loops again. Thats a real difference.

A chatbot gives you an answer.

Claude Code keeps taking action until there is an actual artifact on disk.

• A script.

• A chart.

• A cleaned dataset.

• A backtest report.

• A dashboard.

• A trading journal update.

The trader version of the agentic loop

For trading, the loop looks like this:

1. You define the job

Not “analyze my strategy.”

That prompt was trendy in 2022.

Say what input exists, what rules matter, and what output you want.

Example:

Read data/trades.csv. Calculate win rate, average win, average loss, expectancy, max drawdown, and performance by setup type. Then create an HTML dashboard and save it to /reports/trade_review.html.

Now Claude has a job with edges.

Input: trade CSV.

Logic: metrics.

Output: HTML dashboard.

That is executable.

2. Claude gathers context

Claude Code looks around the project.

It might inspect the CSV headers.

It might open your existing dashboard file.

It might check which Python libraries are already installed.

It might read CLAUDE.md and see your rules:

• Use adjusted close when working with stocks.

• Include commissions and slippage in every backtest.

• Never use future data in signal generation.

• Save charts to /reports.

• Return all performance metrics as percentages.

This is where most traders underestimate Claude Code.

The prompt is not the only context.

Your project is context.

Your files are context.

Your command output is context.

Your errors are context.

Better context goes in. Better automation comes out.

3. Claude chooses tools

This is where Claude Code stops being a chat window.

If it needs to inspect a file, it uses a read tool.

If it needs to find where a function lives, it searches.

If it needs to create a new backtest script, it writes a file.

If it needs to run the script, it uses the terminal.

You do not need to say:

“Use the read tool, then use bash, then edit line 42.”

You describe the outcome. Claude picks the tools. Because trading research is mostly tool work.

• Downloading data.

• Cleaning data.

• Checking columns.

• Running scripts.

• Fixing errors.

• Exporting results.

• Comparing versions.

• Updating reports.

None of that should be manual in 2026.

4. Claude takes action

This is the part normal AI chat cannot do.

Claude Code can actually change the project.

It can create momentum_screener.py.

It can run:

python momentum_screener.py

• It can see the error.

• It can fix the import.

• It can run it again.

• It can create the output file.

• It can open the output and check if it matches the requested structure.

This matters for investors/traders because the bottleneck is usually not the idea.

The bottleneck is all the mechanical work between the idea and the result.

You already know what you want to test.

The annoying part is turning that idea into files, scripts, charts, and numbers. (a lots of manual work)

Claude Code attacks that layer. Not your strategy. The work around the strategy.

5. Claude verifies

This is the most important part.

If Claude writes a backtest and does not verify it, you have nothing.

• A clean equity curve is not proof.

• A green Sharpe ratio is not proof.

• A table with returns is not proof.

For trading, verification means asking Claude to test the logic.

1. Did the signal use only past data?

2. Were transaction costs included?

3. Were missing prices handled?

4. Were delisted stocks ignored?

5. Were dividends and splits adjusted?

6. Was the benchmark calculated the same way?

7. Did position sizing match the rule?

8. Did the trade count make sense?

A backtest that runs is not enough. A backtest that survives checks is the minimum.

So your prompt should force verification.

Example:

After building the backtest, run it. Then inspect the first 10 trades manually and confirm the entry and exit dates follow the rules. Check for lookahead bias. Add transaction costs. If anything fails, fix it before giving me the final report.

This is how you stop Claude from producing pretty garbage.

Context window: Claude’s working memory

Claude Code has a context window.

This is everything it can currently see and reason over.

• Your prompts.

• Its replies.

• File contents.

• Command outputs.

• Errors.

• Plans.

• Previous decisions.

But the window has a limit. This matters a lot in trading. Because trading data gets huge fast. A small strategy explanation is fine. A 3-year trade journal is fine.

A folder full of minute-level OHLCV files can destroy the session if you dump it in without structure.

• Do not shove everything into context.

• Make Claude inspect what it needs.

• Tell it where the data lives.

• Give it schemas.

• Give it sample rows.

• Use focused sessions.

• One task per session.

“Build the screener” is one session.

“Analyze earnings reactions” is another session.

“Debug portfolio risk calculations” is another session.

When context gets messy, quality drops.

That is not a personality issue.

That is an information problem.

Too much irrelevant state increases wrong decisions.

Use /compact when the session is still useful but bloated.

Use /clear when the task has changed.

Clean context is much much cleaer output.

Tools are the backbone

Most AI tools are still text in, text out.

That is fine for asking what RSI means.

It is not fine for building a workflow.

Claude Code has tools.

For traders, the important ones are simple:

• Read files.

• Write files.

• Edit files.

• Run terminal commands.

• Search the project.

• Use web search when needed.

• Connect external systems through MCP.

That last one is where this becomes serious.

Claude Code connected to market data is different from Claude Code with pasted screenshots.

Claude Code connected to your trade journal is different from Claude Code guessing from memory.

Claude Code connected to broker data, filings, notes, and your local research folder becomes a working system.

Not because it is magical.

Because it has access to the inputs and can take actions against them.

That is the mechanic.

Permissions: do not be stupid with access

Claude Code can edit files and run commands. That is powerful :).

It is also exactly why you need permissions.

By default, Claude asks before risky actions.

This is good, like annoying, but good.

When you are learning, keep approvals on.

When you trust a workflow, loosen the safe parts.

For example:

• Auto-accept file edits inside a sandbox project? Fine.

• Let it read local CSV files? Fine.

• Let it run a known Python backtest script? Usually fine.

• Let it install random packages, touch API keys, or execute live broker orders without review? No.

That is not productivity but that is bad risk management.

Use plan mode when the task can damage your workflow.

Plan mode lets Claude inspect files and propose a plan before editing anything.

That is perfect for trading systems.

Before Claude rewrites your backtester, ask for the plan.

Before it changes your data pipeline, ask for the plan.

Before it touches anything connected to real money, ask for the plan.

Fast is good plus uncontrolled is how you create hidden errors at machine speed.

A real workflow

Here is what a proper Claude Code trading task looks like.

Read more

Recently, I’ve been using AI trading agents more seriously in my research workflow.

Not because ai can print bunch of money. Nope. Traders using AI for trading are still just generating random indicators, curve-fitting backtests, and convincing themselves they found edge.

Cool part isn’t “AI writes a strategy.”

Cool part is goal-driven trading research.

Instead of asking:

“Can you make me a profitable trading bot?”

You define a measurable goal:

“Reduce max drawdown by 20% while keeping net profit factor above 1.4 after fees, slippage, and walk-forward validation.”

That difference matters.

Because the first prompt has no stop condition. The second one has a measurable target.

But Why? What’s the point?

Trading work usually falls into two buckets.

The first bucket is well-defined work.

Example:

“Add Binance futures support to my backtesting engine.”

You know the shape of the solution. You need API integration, order models, fee logic, funding rates, position sizing, and error handling.

That can be planned upfront.

The second bucket is exploratory work.

Example:

“Find a way to reduce false breakout entries in my BTC momentum system without killing upside.”

You don’t know the answer upfront.

Maybe the solution is volatility filtering.
Maybe it is session filtering.
Maybe it is volume confirmation.
Maybe the strategy has no edge and should be killed.

This is where goal-based AI work becomes powerful.

You give the agent a metric, a dataset, constraints, and permission to test multiple paths. Then it explores.

Bad trading goals vs good trading goals

Bad goal:

“Make this strategy better.”

This is useless.

Better means nothing. Better on what metric? Sharpe? CAGR? Drawdown? Win rate? Profit factor? Lower variance? Less exposure? More trades? Fewer trades?

A better goal:

“Improve the strategy’s out-of-sample Sharpe from 0.85 to at least 1.15 on BTC/ETH 4H data from 2019–2025, including 0.06% fees, 0.03% slippage, no lookahead bias, and max drawdown under 22%.”

Now the system knows when to stop.

Even better:

“If the target cannot be reached without overfitting, produce a rejection report explaining why the edge is likely not robust.”

That protects you from the most expensive failure in trading research: false confidence.

The key rule: do not accept proxy signals

A lot of trading research dies because people optimize proxy metrics.

High win rate does not mean edge.
High backtest return does not mean robustness.
Low drawdown on one period does not mean risk is controlled.
Great in-sample performance usually means nothing.

The agent should not accept proxy signals.

A valid result needs:

• out-of-sample validation

• transaction costs

• slippage

• position sizing rules

• drawdown limits

• regime testing

• no lookahead bias

• no survivorship bias

• clear failure conditions

If uncertainty remains, the goal is not achieved.

That one principle alone deletes most garbage trading systems.

Give the agent a real surface to act on

A trading agent is only as useful as the environment it can touch.

If you ask it to improve a strategy but only give it a price CSV, it will probably overfit indicators.

For real work, give it:

• your broker documentations

• clean historical data

• execution logs

• fee model

• slippage assumptions

• spread data if available

• existing backtest engine

• walk-forward framework

• risk limits

• benchmark strategy

• rejected previous experiments

• broker sandbox, not live capital

Do not give it live trading access until the research loop is boring, repeatable, and heavily constrained.

Live money is not a testing environment.

The right workflow

Use this sequence:

1. Exploration branch
   Let the agent test hypotheses aggressively.

2. Research report
   Force it to summarize what worked, what failed, and what was overfit.

3. Clean spec
   Convert the useful findings into a precise trading system spec.

4. Reimplementation
   Build the strategy again cleanly from the spec.

5. Validation
   Run walk-forward, stress tests, cost sensitivity, and regime splits.

6. Paper trading
   Only after the system survives research.

7. Tiny capital
   Only after paper trading matches expected behavior.

The first branch is allowed to be messy.
But the shipped trading system is not.

The Actual Trading Goal System

If you read this and still make the same mistake.

You probaly ask AI to “find a strategy.”

That is still too vague.

The better move is to give the model a research contract.

A research contract has four parts:

1. Objective

2. Constraints

3. Validation

4. Rejection condition

If one is missing, the output is probably useless.

Here is the exact structure I would use.

Prompt 1: Turn a vague idea into a real trading goal

Use this before you let AI build anything.

Read more

You’re probably staring at Claude Code thinking:

“How is this supposed to make my life easier?”

A black screen, a blinking cursor, and terms like context window, sub-agents, and MCP servers.

None of it feels built for a trader without a coding background.

After 900+ hours inside, I’m giving you the shortcut I wish I had.

27 concepts, explained in under 60 seconds each, through the lens of a trend-following trader.

1. What is Claude Code?

Most people already know chatbots like ChatGPT or Gemini. You type a message, you get a reply. But those tools can only talk to you. Claude Code is entirely different. It can create files, build backtest scripts, and install packages on your machine all from a simple conversation in plain English. Chatbots give you advice; Claude Code takes actions.

2. The Terminal

Claude Code doesn’t run in a browser like chat.

It runs in the terminal that black screen with white text that looks so cryptic you’ve probably seen developers use. But the terminal is actually really simple. It’s just another way to talk to your computer. Instead of clicking buttons, you type commands.

With Claude Code, you only need to know how to open it (claude), how to close it (Ctrl+C twice), and how to clear its head.

3. Prompts

A prompt is simply what you type to tell Claude Code what to do.

You write them in plain English. Like “build me a trend-following backtest for the S&P 500.”

There’s no special syntax. Just describe what you want. The more specific you are, the better the result.

Instead of “build me a backtest,” say “build me a daily trend-following backtest using the 200-period EMA and 2% risk.” Better prompts, better results.

4. Permissions

This is an incredibly important concept because Claude Code can make actual changes to your computer. It can create files, run commands, and even delete stuff. By default, it asks for your permission before it does anything significant. You stay in control.

5. Pre-approving Safe Stuff

If you’re clicking “approve” every 10 seconds during a backtest project, it really kills your flow.

There is a better way. You can pre-approve specific “safe” actions like reading your data files or running the dev server so Claude works faster without stopping you constantly.

6. Tool Use

What makes Claude Code more powerful is that it has access to tools. It has built-in capabilities like “Read” (to look at your files), “Write” (to create new ones), and “Bash” (to run commands like installing backtest libraries). You don’t need to tell Claude which tool to use.

You just describe the goal, and Claude picks the tools automatically.

7. Context Window

This is Claude’s short-term memory.

It’s everything Claude can see and think about right now.

Every message you send and every file Claude reads lives inside this window. But it has a limit.

8. Context Rot

When a conversation gets too long, too much info piles up and Claude starts losing track of the earlier stuff you said.

This is “context rot.”

It’s when outputs get worse and Claude seems to forget your trade rules.

The fix is simple: keep your conversations focused and short. i mean short not bearish ;)

9. /Clear and /Compact

These are how we manage context. (If you are using terminal not an App)

If Claude gets confused mid-session, you can use the /compact command to summarize the key info and clear out the noise. Or use /clear to wipe the conversation for a fresh start on a new strategy.

10. Conversation History

Claude Code automatically saves your sessions.

If you close your laptop and come back the next day, you can just type claude --resume.

It drops you straight back into the same project with all the context of the previous conversation. You pick up right where you left off.

11. Token Usage

When you use Claude Code, it costs money, and that’s calculated through token usage. A token is roughly 3/4 of a word. Every prompt you send and every file Claude reads uses tokens.

You can keep an eye on your spending using the /cost command in the terminal.

12. CLAUDE.md

Every time Claude starts working on your project, it needs to know how you want to get things done. Without guidance, it’s going to guess and guessing leads to crap results. CLAUDE.md is a simple markdown file where you write your preferences and rules.

“We only use US stocks,” “Always include a 2% stop loss.” Claude reads this first every single time. It’s the most important file you’ll create.

13. Auto-Memory

Claude Code also has an auto-memory file that stores facts that persist between your different sessions.

If you always work in Python or prefer a certain trading style, it’s going to be automatically saved to memory. Claude learns your preferences over time, not just within a single chat.

14. Compact Context

We talked about context length earlier. If you don’t manage it, Claude starts losing track. Claude Code can actually do this automatically.

When it gets to 85-95% full, it summarizes the key info and clears out the noise in the background without you doing anything.

15. Models

When people say “Claude Code,” they’re actually referring to a family of AI models. Sonnet is the all-rounder good at most things and reliable.

Opus is the most intelligent one for handling complex strategy problems that require serious thinking. You can switch between them mid-conversation by using the /model command.

16. Denying Access to Files

Not every file in your project should be passed to Claude. Some are massive and waste your context, and some contain sensitive data like API keys. You can add a “deny list” in your settings so Claude won’t even discover those files. They are completely off-limits.

17. Flags

Flags are options you use when you launch Claude Code. They let you customize how it behaves before it even starts. You can use flags to choose a specific model or to control which tools it has access to. They’re just launch shortcuts.

18. Extended Thinking

Some tasks are simple, but some need Claude to genuinely reason through a problem before it acts. Extended Thinking gives Claude a dedicated “reasoning budget” in tokens to think through a complex build step-by-step. It’s on by default and ensures Claude plans the work before taking any actions.

19. Slash Commands

Typing a forward slash triggers a specific action, like /init to set up a project or /help to see all your shortcuts. Think of slash commands as repeatable shortcuts for tasks you do on a day-to-day basis.

The Professional Trader’s Edge

Everything you’ve read so far is the baseline. It’s what 99% of people using Claude Code are doing. But if you want to use this to build serious trading infrastructure, you need to step into the “Advanced” side of the tool.

The next 8 concepts cover how to move from talking to Claude to building an autonomous system.

We’re talking about the EDGE. This is the industrial-grade side of the tool. ⬇️

Read more

Probably you’ve been using AI like a calculator. Type in a question, get an answer, close the tab. Every chat you close is a tool you could have kept running. Here’s what changes when you stop asking and start building.

Gemini has a workspace mode that produces clickable, interactive tools from your data in minutes - no coding, no developer, nothing to install.

Right now, your AI workflow probably looks like this. You paste a prompt, read the output, copy something useful, and close the tab. Tomorrow you re-prompt because the output is gone. No artifact. No tool you can open again next week.

This works fine for a quick answer. It breaks down when you need something repeatable.

Your trade log is a good test case. Hundreds of rows. Every month you open it, squint at totals, try to spot patterns by eye, and make half-informed decisions. You’ve asked AI to analyze it before. You got a paragraph back.

What if you got a dashboard instead?

The gap between getting text and getting a tool comes down to one thing: the mode you’re working in.

Standard Gemini gives you chat. Ask it to build a position sizing calculator and it writes out the formula. Useful to read. Nothing to click. Ask it to visualize your equity curve and it describes what the chart would look like. Gemini Canvas is different. It opens a working panel next to the chat where Gemini actually builds the tool. Not a description of the thing. The thing itself.

Here is what this looks like with real data. You have 3 years of trades in a spreadsheet. Entry date, ticker, setup type, win/loss, return. Copy all of it. Paste it into Gemini with Canvas turned on.

Type:

Read more

Pasting in 10-K text. Asking it to analyze charts. Getting back the same generic summaries you could find on Yahoo Finance. Then I switched to Claude Code and the whole workflow changed.

Claude Code is not the chatbot. It is a separate tool that runs in your terminal, reads your files, executes commands, and builds things on your computer. The difference matters because for traders, the bottleneck was never “getting answers.” It was doing the work. Gathering data, organizing it, running screens, formatting results.

Here are 15 concepts you need to understand before you start.

1. Claude Code vs. the chatbot

Regular Claude is a conversation. You paste information in, it responds. Claude Code is an agent. You describe what you want done and it does it.

• Creates files.

• Runs scripts.

• Installs packages.

• Opens databases.

For trading, that means you can say “pull the last four quarterly earnings for AAPL, MSFT, and GOOG and put them in a spreadsheet” and walk away….

2. The terminal

Claude Code runs in that black screen with white text. Sounds intimidating. It’s not. You type claude to open it. You type plain English after that. The terminal is just the container.

You never need to learn terminal commands because Claude handles all of that underneath your plain English instructions.

3. Prompts

Same idea as typing into ChatGPT. But specificity matters more here because Claude Code takes actions, not just generates text.

“Analyze my portfolio” gives you garbage.

“Read my positions.csv file, calculate expected return and expected volatility and make visual plot” gives you a finished result.

Better prompts, better automation.

4. Permissions

Claude Code can create files, delete files, run commands on your machine. By default it asks permission for everything. That gets annoying fast when you’re running a 20-step research workflow.

The fix: pre-approve safe actions like reading files, running your Python scripts, and git operations. Keep gates on anything that touches the internet, installs packages, or sends data.

5. Tools

Claude Code has built-in capabilities. Read (looks at your files), Write (creates new files), Bash (runs terminal commands). You never tell it which tool to use. You describe your goal. It picks the right tool. When you say “backtest this strategy on the last 5 years of SPY data” it knows it needs to read your data file, run a Python script, and write the results.

6. Context window

This is Claude’s short-term memory. Every message you send, every file it reads, every response it generates fills up the window. When it gets full, Claude starts forgetting your earlier instructions. For trading workflows that involve reading multiple filings or large CSV files, this fills fast. Keep your sessions focused. One task per session.

7. claude.md

The single most important file in any project. It’s a markdown file where you write your rules and preferences. Claude reads it first, every time. For trading, mine says things like: “Always use adjusted close prices. Default position size is 2% of portfolio. When backtesting, include transaction costs of 0.1%. Output all returns as percentages.” Write it once. Every session follows those rules automatically.

8. Memory

Different from claude.md. Memory is what Claude learns about you across sessions automatically. If you always work with daily OHLCV data, it remembers. If you prefer a certain output format for your trade journal, it remembers. You can also tell it to remember things. “Remember that my broker is Interactive Brokers and my account is margin-enabled.” That sticks across every future conversation.

9. Models

Three options.

1. Haiku is fast and cheap for simple tasks like renaming files.

2. Sonnet is the workhorse for most trading research.

3. Opus is the most intelligent for complex reasoning like multi-step strategy logic or debugging a backtest that produces weird results.

I use Sonnet 90% of the time. Switch to Opus when the task actually requires thinking through dependencies.

10. Context management

Long sessions make Claude confused. Two fixes. First: the /compact command summarizes the conversation and clears noise. Second: start fresh sessions for new tasks. If you’ve been building a screener and now want to analyze earnings, don’t continue the same session. Type /clear or open a new terminal. Clean context produces better output. Every time.

11. MCP servers

This is where it gets interesting for traders. MCP stands for Model Context Protocol. It connects Claude Code to external tools and APIs. Think about this: Claude Code connected to your broker API. To TradingView. To your Notion research database. To a financial data provider. Once connected, Claude can pull live data, push updates, and interact with your entire trading stack from one conversation window.

12. Slash commands and skills

Slash commands are shortcuts for repetitive tasks. /init sets up a project. /compact clears context. You can create your own. I have one called /morning-brief that pulls overnight news, checks pre-market movers, and summarizes earnings announced after yesterday’s close. Skills go deeper. They’re pre-written instruction sets that make Claude expert at specific tasks. A backtesting skill. A fundamental analysis skill. You build them once and Claude follows them automatically when the task matches.

13. Sub-agents

When a task is complex, Claude Code can spin off specialist agents that work in their own separate context. Each sub-agent gets a clean memory, does its job, and reports back. For a full portfolio review, the main agent might send one sub-agent to analyze technicals, another to pull fundamentals, and a third to check recent news. They run in parallel.

You get results faster and each agent stays focused instead of one agent trying to hold everything in memory at once.

14. Headless mode

Add the -p flag when starting Claude Code and it runs completely on its own. No conversation, no approvals etc. No waiting for your input. It processes your request and outputs the result.

I run my end-of-day trade journal update this way.

One command, scheduled at 4:30 PM, runs every trading day. By the time I check it, my journal is already updated with every trade, P&L calculated, notes column ready.

15. Worktrees

You can run multiple Claude Code instances on the same project without them interfering. One instance is building a new screener. Another is fixing a bug in your backtest script. A third is analyzing this week’s trades. Each gets its own isolated copy of your files. When one finishes, you merge the changes back. This is how you parallelize your entire trading research workflow.

That’s the full map.

You don’t need all 15 on day one. Start with concepts 1 through 5. Get comfortable talking to Claude Code in plain English and letting it handle your file work. Then set up your claude.md with your trading rules. That alone will change your output quality overnight.

The traders who figure this out early won’t be the ones with the best chart patterns or the fastest data feeds. They’ll be the ones who stopped doing mechanical work manually and pointed an agent at it instead.

Every hour you spend gathering data is an hour you’re not spending on the only thing that actually moves your account.

The decision.

The thing about learning to use AI for trading is that you pay for every mistake in time. Wrong workflow, wasted hours. Bad prompt, wasted afternoon. Start over from scratch, wasted week. I’ve made all of them.

This is everything I wish I knew earlier, compressed.

Plan before you build.

Ive seen most traders describe their strategy in one paragraph and ask for a backtest. The AI writes 200 lines. It errors then they debug and it errors differently. Three hours later, they haven’t run a single clean test.

The problem isn’t the code. There was no plan.

Before any code: tell Claude your strategy idea and ask it to ask you questions. Not “write my backtest.” Just: “I want to build a mean reversion system on S&P 500 stocks. Ask me everything you need to know before we write a line of code.”

What comes back is a list of decisions you hadn’t made yet. Data source. Timeframe. How do you define the entry signal exactly. What’s the exit, fixed stop, time-based, reversal. How do you handle earnings dates, halts, gaps. Each one matters. Making them during planning costs nothing. Making them after 300 lines of code costs a full afternoon.

AI moves fast. Without a plan, fast is the problem.

Voice your prompts.

This one sounds trivial. It isn’t.

Typed prompts for trading instructions tend to be short. “Build a momentum screener.” “Add a stop loss.” When you type, you edit yourself. You cut context you think is obvious.

When you describe a trading strategy out loud, something different happens. You add detail naturally. You say things like “...but only when volume is above average, because that’s when the signal is actually clean” detail you’d never type. Voice prompts run two to three times longer and more specific. The AI gets better instructions. The code reflects what you actually wanted.

If you’re building at home, try it for one session.

Also I use WisprFlow, it’s free.

Connect Claude to live data with MCP servers.

Traders haven’t heard of MCP servers yet. The simplest way to think about them: a USB port that connects Claude to external data sources.

For trading, the useful ones are market data feeds, broker APIs, financial data providers. Instead of downloading a CSV, cleaning it, and pasting it into Claude, you point Claude at the source directly. It reads your data as part of the workflow.

Practical example: connect to your broker API and describe what you want. “Pull the last 90 days of SPY price data and flag every day where the close was more than 1.5% below the prior close.” Claude pulls the data, runs the logic, returns the result. No file management, no reformatting.

Better context goes in. Better output comes out. That’s the mechanic.

Treat AI like a junior quant with ADHD :)

The most useful mental model for working with Claude on trading tools: junior quant. Capable. Fast. Can build things you couldn’t build alone in a week. But left with a vague brief, it guesses and it guesses confidently.

“Build a backtest” produces 200 lines that may or may not reflect your actual strategy.

“Write a Python function called calculate_signals that takes a DataFrame with columns [date, close, volume] and returns a Boolean column called signal True when the 10-day return exceeds 5% and today’s volume is above 1.5x its 20-day average. Nothing else.”

produces exactly what you asked for.

Your job isn’t to code. It’s to make the instructions tight enough that the AI’s guesses are correct ones.

Give your AI a permanent memory.

Every new session, most traders re-explain everything. Data format. Broker API. How signals are defined. Position sizing rules. Claude starts cold every time, and you spend the first 15 minutes of every session getting it back up to speed.

There’s a file called CLAUDE.md. It lives in your project folder. Claude reads it automatically at the start of every session.

Put everything in it you’d otherwise repeat: your data format (daily bars, date/open/high/low/close, no dividend adjustment), your broker setup (Alpaca, paper trading only), how you define entries and exits, your risk rules, your Python library preferences, any quirks in your dataset. Build it once. Update it as decisions get made.

The codebase gets smarter with each session. By month two, Claude knows your system setup before you’ve typed a word. That’s compound engineering the same idea as compounding returns, applied to context.

The traders building working AI tools are not the ones with the most coding experience.

They’re the ones who figured out that the human’s job is to make the AI’s guesses better through planning, specific instructions, live context, and a system that remembers.

That’s 900 hours in one read. Nothing magical ;)

Most traders have the same problem. They know what to look for but they don’t have time to look.

• Earnings reports.

• 10-K filings.

• Sector news.

• Transcripts.

• Position tracking etcetc

By the time you’ve gathered everything and put it in one place, the opportunity has moved.

There’s a version of Claude that most people are either using wrong or not using at all.

Claude Co-work doesn’t answer questions. It does the work.

Here’s the actual difference between Claude the chatbot and Claude Co-work.

Normal Claude: you paste information in, it responds. You do the fetching. You do the organizing. You do the copy-pasting. Claude just processes what you hand it.

Claude Co-work: it controls your computer. It browses websites. It opens files. It creates spreadsheets. It organizes folders. You describe the task, walk away, and come back to finished work.

For most tasks, that’s a productivity upgrade. For trading research, it’s something else entirely.

Think about what you actually do before entering a position.

You open EDGAR. Download the latest 10-K. Scan for revenue trends. Open another tab for the earnings call transcript. Cross-reference with the sector ETF. Pull up the balance sheet separately. Open Excel. Start typing numbers in manually.

That workflow runs 45 minutes per company on a good day.

Here’s what I ran instead.

I told Co-work:

“Go to EDGAR, find the last three annual reports for these five tickers, extract revenue, gross margin, and net debt from each one, and put them side by side in a comparison spreadsheet.”

It opened my browser, navigated to the right pages, downloaded the filings, read them, pulled the numbers, and built the spreadsheet. I was making coffee.

Twenty-three minutes. Five companies. Formatted and ready.

That’s not Co-work being smarter than you. It’s Co-work doing the part of research that doesn’t require intelligence. The tedious part. The part that burns your time and patience before you’ve started actually thinking.

The real analysis is still yours. Co-work clears the runway so you can use it.

The fastest place to start is your trade journal.

Most traders either don’t keep one or let it fall behind because manual entry is a chore at the end of a session. You’re tired… you skip it. Three weeks later it’s useless.

Tell Co-work:

“After each session, go to my broker’s trade history page, pull all trades from today, and log them into my trade journal spreadsheet with entry price, exit price, size, P&L, and a blank notes column.”

One task, runs in under three minutes (sometimes takes up to 10min). Your journal stays current without you touching it.

From there you layer on. Pull earnings dates for your watchlist every Sunday morning. Check investor relations pages for new filings on positions you hold. Flag any company in your portfolio that put out a press release this week.

Each task is a separate instruction. Each one you set up once. Co-work handles the rest.

The traders who pull ahead from here won’t necessarily be the ones with the sharpest chart reading.

They’ll be the ones who identified which parts of their process are purely mechanical and handed those off. Every hour spent on data gathering is an hour not spent on the only thing that actually moves your account: the decision itself.

Co-work doesn’t make the decision for you. It makes sure you have everything you need when it’s time to make one.

That’s the job.

Share