Paper trading results, not financial advice. Every number on this site is a simulated backtest or a simulated forward paper run with no real money. Past or hypothetical performance does not predict future results. Nothing here is a recommendation to buy, sell or hold anything.

Free prompt library

Prompts that rebuild each viral bot with ChatGPT, Claude or Grok, each linked to the bot it produces and that bot's leaderboard entry. Free forever. No paid prompt packs.

How we test: we paste the prompt into the chatbot, run the script it writes as-is (paper/backtest only, no broker keys), and compare it with our own engine's backtest of the same rules. Pass = runs, follows the rules, matches ours closely. Partial = runs but deviates or has a bug. Fail = doesn't run.

20/50 Moving-Average Crossover (SPY)

Builds: The 14-Minute Claude Bot (20/50 MA Crossover) 路 Leaderboard: +92.1% backtest vs SPY buy & hold +244.4%

Tested 2026-10-16 路 ChatGPT Free (GPT-5.x "Instant" model; exact name not shown) Grade: Partial

ChatGPT's script: +92.1%, max drawdown -28.2%, 16 trades 路 Our engine: +92.1%, max drawdown -28.2%, 16 trades backtest

Backtest numbers matched ours exactly (+92.1% vs +92.1%, same 16 trades), and no look-ahead bug. But the script crashes on its very last line: it calls json.dumps without `import json`. The output files still get written. It also exits when the two SMAs are exactly equal (harmless here).

Wording tightened after test The grade above is for the original wording. The prompt below has been tightened and is not yet retested. What changed: Added: keep the position when the SMAs are exactly equal; paper mode must place the strategy's own orders (with --dry-run); script must run end to end with all imports.

Works with: ChatGPT, Claude, Grok. Copy and paste:

You are a careful quant developer. Build me a backtestable trading bot for SPY using a 20-day / 50-day simple moving-average crossover: go fully long when the 20-day SMA closes above the 50-day SMA, and sell to cash when it closes below. If the two SMAs are exactly equal, keep the current position. Backtest from 2019-01-02 to today. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables, computes the same signal from the latest completed daily bar, and automatically places the matching order with the same sizing (and stops, if any) as the backtest; add a --dry-run flag that only prints the order. Never hard-code keys and never use a live trading endpoint. Make sure the script runs end to end without errors (all imports present) before you answer.
Original wording (the version ChatGPT was tested on)
You are a careful quant developer. Build me a backtestable trading bot for SPY using a 20-day / 50-day simple moving-average crossover: go fully long when the 20-day SMA closes above the 50-day SMA, and sell to cash when it closes below. Backtest from 2019-01-02 to today. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables. Never hard-code keys and never use a live trading endpoint.

HMM Regime-Switching Bot (SPY)

Builds: The 34-Minute Regime Bot (HMM Bull/Bear/Sideways) 路 Leaderboard: +83.8% backtest vs SPY buy & hold +244.4%

Tested 2026-10-16 路 ChatGPT Free (GPT-5.x "Instant" model; exact name not shown) Grade: Partial

ChatGPT's script: +105.3%, max drawdown -10.3%, 67 trades 路 Our engine: +83.8%, max drawdown -11.0%, 64 trades backtest

Runs cleanly and follows the rules, with a properly walk-forward HMM and no look-ahead found. Its result (+105.3%) is about 21 points above ours (+83.8%). HMM regimes are sensitive to fitting details the prompt left open: how states get labeled, the random seed, and how today's state is picked. It also fills trades on unadjusted prices, so dividends are missed. Paper mode is a manual buy/sell helper, not the strategy.

Wording tightened after test The grade above is for the original wording. The prompt below has been tightened and is not yet retested. What changed: Pinned the HMM details (label by model.means_, causal trailing-250-day state, random_state=7, n_iter=200, min_covar=1e-3); adjusted prices for signals AND fills; paper mode must run the strategy automatically; script must run end to end.

Works with: ChatGPT, Claude, Grok. Copy and paste:

You are a careful quant developer. Build a regime-switching trading bot for SPY. Features: daily log return and 20-day rolling volatility, standardized using ONLY the training window. Fit a 3-state Gaussian HMM (hmmlearn, diagonal covariance) on the previous 756 trading days and refit every 63 days (walk-forward, never train on future data). Label states by the fitted model's mean of the (standardized) return feature (model.means_): lowest = bear, middle = sideways, highest = bull. Each day's regime = the last state of model.predict() on the trailing 250 days ending today (causal; standardized with the training-window mean/std). Use random_state=7, n_iter=200, min_covar=1e-3. Rules: bull = hold SPY; bear = cash; sideways = RSI(2) mean reversion (buy when RSI(2) < 10, sell when RSI(2) > 70). Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data (use split- and dividend-adjusted OHLC, auto_adjust=True, for both signals and fills). Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables, computes the same signal from the latest completed daily bar, and automatically places the matching order with the same sizing (and stops, if any) as the backtest; add a --dry-run flag that only prints the order. Never hard-code keys and never use a live trading endpoint. Make sure the script runs end to end without errors (all imports present) before you answer.
Original wording (the version ChatGPT was tested on)
You are a careful quant developer. Build a regime-switching trading bot for SPY. Features: daily log return and 20-day rolling volatility, standardized using ONLY the training window. Fit a 3-state Gaussian HMM (hmmlearn, diagonal covariance) on the previous 756 trading days and refit every 63 days (walk-forward, never train on future data). Label states by mean return: lowest = bear, middle = sideways, highest = bull. Rules: bull = hold SPY; bear = cash; sideways = RSI(2) mean reversion (buy when RSI(2) < 10, sell when RSI(2) > 70). Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables. Never hard-code keys and never use a live trading endpoint.

Multi-Asset Mean-Reversion + Momentum + Trend Bot

Builds: The 'Claude Built Her a Trading Bot' Multi-Asset Bot 路 Leaderboard: +370.7% backtest vs SPY buy & hold +244.4%

Tested 2026-10-16 路 ChatGPT Free (GPT-5.x "Instant" model; exact name not shown) Grade: Partial

ChatGPT's script: +320.9%, max drawdown -17.2%, 229 trades 路 Our engine: +370.7%, max drawdown -13.8%, 230 trades backtest

Runs cleanly, with no look-ahead bug. +320.9% vs our +370.7%. We traced the whole gap to the prompt's wording: ChatGPT computed Bitcoin's breakout levels on US trading days only and used a slightly different Bollinger std. When we rerun our engine that same way, we get +320.7%. Paper mode drops the ATR stops and uses a fixed 10% position size.

Wording tightened after test The grade above is for the original wording. The prompt below has been tightened and is not yet retested. What changed: Spelled out: compute BTC indicators on its full 7-day history but trade only on US sessions; Bollinger uses sample std (ddof=1); keep open positions at the end; paper mode must use the same sizing and stops; script must run end to end.

Works with: ChatGPT, Claude, Grok. Copy and paste:

You are a careful quant developer. Build a multi-asset daily-bar trading bot with four sleeves: (1) SPY and QQQ mean reversion: buy when the close is below the lower 20-day, 2-standard-deviation Bollinger band (sample standard deviation, pandas default ddof=1); exit when it closes at or above the 20-day mean. (2) BTC-USD momentum breakout: buy when the close exceeds the prior 20-day high; exit when it closes below the prior 10-day low. (3) GLD trend following: buy when close > 50-day SMA > 200-day SMA; exit when close < 50-day SMA. Position sizing: risk 1% of total equity per trade with a hard stop 1 ATR(14) below entry (cap stop at 20%), and no sleeve larger than 25% of equity. Check stops against each day's low. Compute every indicator on each asset's own full daily history (for BTC-USD that includes weekends, so its 20-day high, 10-day low and ATR use 7-day-a-week bars), then make trading decisions and fills only on US equity trading days. Keep any position still open at the end marked to market (don't force a final sale). Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables, computes the same signal from the latest completed daily bar, and automatically places the matching order with the same sizing (and stops, if any) as the backtest; add a --dry-run flag that only prints the order. Never hard-code keys and never use a live trading endpoint. Make sure the script runs end to end without errors (all imports present) before you answer.
Original wording (the version ChatGPT was tested on)
You are a careful quant developer. Build a multi-asset daily-bar trading bot with four sleeves: (1) SPY and QQQ mean reversion: buy when the close is below the lower 20-day, 2-standard-deviation Bollinger band; exit when it closes at or above the 20-day mean. (2) BTC-USD momentum breakout: buy when the close exceeds the prior 20-day high; exit when it closes below the prior 10-day low. (3) GLD trend following: buy when close > 50-day SMA > 200-day SMA; exit when close < 50-day SMA. Position sizing: risk 1% of total equity per trade with a hard stop 1 ATR(14) below entry (cap stop at 20%), and no sleeve larger than 25% of equity. Check stops against each day's low. Run all sleeves on the US trading calendar. Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables. Never hard-code keys and never use a live trading endpoint.

Crypto Dip-Ladder Bot (BTC + ETH)

Builds: The Reddit Dip-Ladder Crypto Bot 路 Leaderboard: +266.3% backtest vs BTC-USD buy & hold +1970.0%

Tested 2026-10-16 路 ChatGPT Free (GPT-5.x "Instant" model; exact name not shown) Grade: Partial

ChatGPT's script: +141.4%, max drawdown -36.6%, 309 trades 路 Our engine: +266.2%, max drawdown -44.0%, 309 trades backtest

Runs cleanly, with no look-ahead bug. +141.4% vs our +266.2%. ChatGPT read 'split equity into slots' as fixed $1,000 slots that never grow; we resize each slot to the current account. Our engine with fixed $1,000 slots gives +141.4%, so the logic itself matches. It benchmarks against a 50/50 BTC/ETH mix, and paper mode only buys (no profit-target sells).

Wording tightened after test The grade above is for the original wording. The prompt below has been tightened and is not yet retested. What changed: Slot size = current total equity / 10 at each entry (not a fixed $1,000); benchmark vs BTC-USD (plus ETH-USD); paper mode must also place the +5% target sells; script must run end to end.

Works with: ChatGPT, Claude, Grok. Copy and paste:

You are a careful quant developer. Build a crypto dip-buying ladder bot for BTC-USD and ETH-USD on daily bars. Use 5 slots per coin (10 total). Size each new slot at the moment of entry as current total equity (cash + open slots marked at the last close) divided by 10, capped at available cash, so slot size grows and shrinks with the account. When a coin closes above its 100-day SMA AND is down 3% or more on the day, buy one empty slot for that coin at the next open. Each slot has a +5% profit-target sell (check against each day's high). No stop-loss. Report open (unrealized) slots separately from closed trades. Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against BTC-USD buy-and-hold (and also show ETH-USD buy-and-hold). Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables, computes the same signal from the latest completed daily bar, and automatically places the matching order with the same sizing (and stops, if any) as the backtest; add a --dry-run flag that only prints the order. Never hard-code keys and never use a live trading endpoint. Make sure the script runs end to end without errors (all imports present) before you answer.
Original wording (the version ChatGPT was tested on)
You are a careful quant developer. Build a crypto dip-buying ladder bot for BTC-USD and ETH-USD on daily bars. Split equity into 5 equal slots per coin (10 total). When a coin closes above its 100-day SMA AND is down 3% or more on the day, buy one empty slot for that coin at the next open. Each slot has a +5% profit-target sell (check against each day's high). No stop-loss. Report open (unrealized) slots separately from closed trades. Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables. Never hard-code keys and never use a live trading endpoint.

Moving-Average Mean-Reversion Bot (BTC)

Builds: The 'Beat the Market' MA Mean-Reversion Bot 路 Leaderboard: +83.0% backtest vs BTC-USD buy & hold +1970.0%

Tested 2026-10-16 路 ChatGPT Free (GPT-5.x "Instant" model; exact name not shown) Grade: Pass

ChatGPT's script: +83.0%, max drawdown -47.9%, 44 trades 路 Our engine: +83.0%, max drawdown -47.9%, 44 trades backtest

Runs cleanly. Results matched ours exactly: +83.0% vs +83.0%, same -47.9% drawdown, same 44 trades. No look-ahead bug. Gotcha: the 'paper mode' only checks your Alpaca paper account and never places an order.

Wording tightened after test The grade above is for the original wording. The prompt below has been tightened and is not yet retested. What changed: Paper mode must actually place the strategy's orders (with --dry-run); script must run end to end.

Works with: ChatGPT, Claude, Grok. Copy and paste:

You are a careful quant developer. Build a mean-reversion bot for BTC-USD on daily bars: buy with all equity when the close is 7% or more below its 20-day SMA; sell when the close gets back to or above the 20-day SMA. Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables, computes the same signal from the latest completed daily bar, and automatically places the matching order with the same sizing (and stops, if any) as the backtest; add a --dry-run flag that only prints the order. Never hard-code keys and never use a live trading endpoint. Make sure the script runs end to end without errors (all imports present) before you answer.
Original wording (the version ChatGPT was tested on)
You are a careful quant developer. Build a mean-reversion bot for BTC-USD on daily bars: buy with all equity when the close is 7% or more below its 20-day SMA; sell when the close gets back to or above the 20-day SMA. Backtest from 2019-01-02. Constraints: Python 3.11, pandas, yfinance for free daily data. Long-only, no leverage. Compute signals on the daily close and fill at the NEXT day's open (no look-ahead). Charge 5 bps slippage per fill on ETFs and 10 bps on crypto. Start with $10,000. Output a trade log CSV (entry/exit date, price, qty, P&L, exit reason) and an equity curve, and compare against buy-and-hold of the same asset. Then add an optional Alpaca PAPER trading mode (endpoint https://paper-api.alpaca.markets only) that reads keys from environment variables. Never hard-code keys and never use a live trading endpoint.

Generated code can contain bugs. Paper trade first. This is education, not financial advice.