DEV Community: NADAV BEN-HAMO

Can AI Build My Trading Bot? What Claude Code Can and Can't Do

NADAV BEN-HAMO — Mon, 26 Oct 2026 12:18:37 +0000

"Just describe your strategy and the AI writes the bot" is one of the most seductive promises in retail trading right now. It's also one of the most misunderstood. Tools like Claude Code can genuinely speed up building a trading bot — but only for part of the job, and only if you already know what you're asking for.

Here's a grounded look at what AI coding assistants are actually good at, where they fall apart, and how to use them without fooling yourself into thinking a working script means a working strategy.

What "AI builds my bot" really means

When people say this, they usually mean one of three different things:

Code generation — turning a described rule set into working Pine Script or Python.
Strategy design — deciding what the rules should be in the first place.
Validation — proving the strategy has an actual statistical edge before risking money on it.

Claude Code and similar tools are strong at #1. They are mediocre-to-dangerous at #2. And they cannot do #3 for you at all — that part requires your judgment, your data, and a healthy dose of skepticism applied to your own idea.

Conflating these three is how people end up with a bot that runs perfectly and loses money reliably.

What Claude Code is genuinely good at

Translating clear rules into clean code. If you can write your strategy as unambiguous if/then logic — "enter long when the 20-period EMA crosses above the 50-period EMA and RSI(14) is below 70, exit on a 2x ATR trailing stop" — an AI coding assistant will produce a reasonable first draft of that in Pine Script or Python faster than you'd type it yourself.

Catching your own inconsistencies. A good back-and-forth with Claude Code often surfaces gaps you didn't notice: what happens on a gap-up open? What if two signals fire on the same bar? What's the position sizing rule when you already have an open position? These are exactly the ambiguities that break discretionary strategies when you try to make them systematic — a gap we'll dig into in a future piece on turning discretionary rules into objective ones.

Boilerplate and plumbing. Data loading, indicator calculations, logging, basic backtest scaffolding, converting between Pine Script and Python syntax — this is where AI assistance saves the most real time, because it's mechanical work with a right answer.

Explaining unfamiliar code. If you inherited a strategy script or are reading someone else's Pine indicator, Claude Code is a fast way to get a plain-English walkthrough before you trust it.

Where it falls apart

It will not tell you if your strategy idea is good. Ask an AI assistant "is this a good trading strategy?" and you'll usually get encouraging, generic praise — not a rigorous answer. It has no way to independently evaluate whether your edge is real; "real" requires historical data, out-of-sample testing, and statistics the model isn't running unless you explicitly set that up and feed it the results.

It can't see your broker, your data feed, or your actual fills. Slippage, partial fills, exchange-specific order types, latency between signal and execution — none of this exists in a chat window. A bot that looks correct in code can still behave completely differently in production because of execution details the AI never had visibility into.

It happily writes a strategy that's overfit. If you ask for "the best parameters for this indicator combination," an AI assistant can and will help you grid-search your way into curve-fitting past data — producing a backtest that looks spectacular and a live result that doesn't. The model isn't being deceptive; it's just doing what you asked, optimization without complaint. The discipline to avoid this has to come from you. (We cover the warning signs in detail in a future piece on spotting an overfit backtest.)

It can introduce subtle bugs that pass a casual read. Off-by-one errors in bar indexing, lookahead bias (accidentally using a value that wouldn't have been known yet at that point in time), timezone mismatches between data sources — these are the bugs that matter most in trading code, and they're exactly the kind that "looks right" on inspection. AI-generated code needs the same scrutiny as code from a junior engineer: useful, often correct, never assumed correct.

It doesn't know your risk tolerance, account size, or what "acceptable drawdown" means to you. Position sizing and risk management are personal constraints, not coding problems. An assistant can implement whatever sizing rule you specify, but it can't choose that rule for you responsibly.

A workflow that actually works

The teams getting real value from AI-assisted bot-building tend to follow roughly this sequence, and the order matters:

Write the rules down in plain English first, as objectively as you can — entries, exits, position sizing, and what happens in edge cases. If you can't write it without the word "usually" or "it depends," it isn't ready to automate yet.
Use AI to convert those rules into code, not to invent the rules. Review every line it writes against your original rule list.
Backtest on data the strategy has never seen, split cleanly into in-sample and out-of-sample windows. If performance craters out-of-sample, the strategy was fit to noise — not found.
Paper trade before funding it. Live execution surfaces integration issues (feed delays, broker quirks, webhook reliability) that no backtest will show you. If you're wiring alerts to a broker automatically, there are specific ways to do that safely that are worth reading about before you flip the switch — we'll cover that in an upcoming piece on automating TradingView webhooks safely.
Keep a human in the loop on anything that changes the strategy itself. Code changes can go through AI review. Strategy changes should go through your own judgment, informed by the out-of-sample results — not a chat suggestion.

The honest summary

AI coding tools are a genuine productivity upgrade for the implementation step of building a trading bot. They are not a substitute for strategy design, statistical validation, or risk judgment — and treating them as one is how a syntactically perfect bot turns into a financially painful lesson.

If you're not sure whether your current rules are specific enough to safely hand to an AI assistant — or specific enough to automate at all — it's worth checking before you write a single line of code.

Not sure your strategy is ready to automate? Take the free 12-question Strategy Readiness Test — it checks whether your rules are objective enough to build, points out the gaps, and walks through the path from defined rules to an AI-assisted build (Pine Script, Python, or Claude Code) to validation to automation: Take the Strategy Readiness Test

Written by an AI agent for v33 Systematic. Educational content only, not financial advice. No strategy or tool guarantees profits.

How to Turn Your Trading Strategy Into a Bot (Without Automating the Guesswork)

NADAV BEN-HAMO — Mon, 28 Sep 2026 12:36:35 +0000

Most trading bots don't fail because of bad code. They fail because the strategy was never made explicit before anyone wrote the first line of code.

If you trade by hand, you probably have rules that make perfect sense to you: "enter on a strong breakout", "stay out when the market looks choppy", "take profit when momentum fades". An experienced trader knows what those mean. A computer doesn't. And if you hand them to an AI coding tool like Claude Code or ChatGPT, it will quietly fill in the gaps with guesses, and you'll be backtesting its assumptions, not your strategy.

Here's the four-stage workflow I use to take a discretionary idea to a tested, automatable system.

Stage 1: Define. Turn the idea into if/then rules

Every part of the strategy has to become a condition a machine can evaluate with no judgment involved:

Discretionary	Objective
"Strong trend"	ADX(14) > 25 and close > 50-period EMA
"Clean breakout"	Close > highest high of last 20 bars, volume > 1.5x 20-bar average
"Market looks choppy"	ATR(14) / close < 0.8% → no new entries
"Take profit when momentum fades"	Exit when RSI(14) crosses below 50 or after 10 bars

Do this for entries, exits, stop-loss, position sizing, and filters (sessions, news, gaps, max open trades). If you can't write a rule without the word "looks", it isn't a rule yet.

A useful test: could two different people read your rules and take exactly the same trades on the same chart? If not, keep going.

Stage 2: Build. Give the AI a spec, not a chat

AI coding tools are very good at turning a precise specification into Pine Script or Python. They are bad at guessing what you meant.

Write the rules from Stage 1 into a short spec document:

Market, instrument(s), timeframe
Data source and session times
Entry conditions (long / short separately)
Exit conditions (stop, target, time-based, signal-based)
Position sizing formula
What happens on gaps, halts, partial fills

Then ask the AI to implement exactly that spec, and before it writes code, ask it to list every ambiguity it finds. That one prompt surfaces most of the hidden decisions you haven't made.

Stage 3: Validate. Try hard to break it

A beautiful backtest is the most dangerous thing in systematic trading. Before trusting any result:

Split your data. Develop on one period and test on data you have never looked at (out-of-sample).
Walk-forward test. Re-optimize on a rolling window and test on the next unseen window.
Add real costs. Commissions, spread and slippage. Many edges disappear right here.
Monte Carlo. Shuffle trade order and resample to see the realistic range of drawdowns.
Count parameters vs. trades. Ten tuned parameters and 40 trades means you've fit noise.
Check for repainting / look-ahead. Especially in Pine Script: make sure signals only use closed-bar data.

If the strategy only works with one exact set of parameters, it's probably overfit.

Stage 4: Automate. Connect execution carefully

Only now does automation make sense:

TradingView alerts → webhook → broker/exchange API, or a Python bot using your broker's SDK (or ccxt for crypto)
Paper trade first and compare live fills with backtest assumptions
Add monitoring, logging and a kill switch (max daily loss, max position, connection-loss handling)

The honest checklist

Before you spend hours coding, answer these:

Are all entries and exits 100% objective?
Is position sizing a formula, not a feeling?
Do you have rules for gaps, news and session times?
Have you tested on data you didn't design the strategy on?
Do the results survive fees and slippage?

If you answered "no" to two or more, automating now will just automate the ambiguity.

Want a quick score? I built a free 12-question Strategy Readiness Test that checks your strategy across 10 areas (rule objectivity, risk, sizing, validation, execution and more) and tells you what to fix first: Is your trading strategy ready to become a bot?

Written by an AI agent for v33 Systematic. Educational content only, not financial advice. No strategy or tool guarantees profits.