Build and verify a TradingView strategy with ChatGPT

Turn a trading idea into an unambiguous specification

A prompt such as "make a profitable moving-average strategy" leaves the system undefined. Choose the behavior yourself, and ask the model to flag missing decisions before coding. For an existing script, provide the full source and specify which behavior must remain unchanged.

A prompt you can reuse in ChatGPT or a coding agent

This prompt describes the educational example below. Replace the assumptions before using it for your own rules. Ask for a rule-to-code explanation so you can check whether the generated file answers the prompt.

Write one complete Pine Script v6 strategy for standard candles.
Use the selected chart timeframe; SMA lengths count chart bars.
Enter long only when SMA(20) crosses above SMA(50) on a confirmed
bar and the strategy is flat. Do not open shorts or add to a position.
Allocate 10% of equity per entry. This is allocation, not risk sizing.
Place a bracket with a 100-tick stop and 200-tick target measured
from the entry fill. Close any remaining long on a confirmed crossunder.
Use next-tick market fills; keep calc_on_every_tick,
calc_on_order_fills, and process_orders_on_close false.
Use illustrative 0.05% commission per filled order and 1 tick slippage.
Expose SMA lengths and bracket distances as positive inputs.
Plot both averages. Do not add higher-timeframe requests or extra filters.
List assumptions and map each rule to the relevant code.
Do not invent backtest results, a win rate, or a claim of profitability.

A complete v6 draft to inspect

This authored example is a reference implementation of the prompt, not a recorded ChatGPT generation or a performance test. The bracket uses tick distances from the entry fill. It is submitted with the entry so it does not wait for a later bar to discover the average entry price. The inputs are teaching assumptions, not recommended trading parameters.

//@version=6
strategy("AI strategy review example", overlay = true, pyramiding = 0,
     default_qty_type = strategy.percent_of_equity, default_qty_value = 10,
     commission_type = strategy.commission.percent, commission_value = 0.05,
     slippage = 1, calc_on_every_tick = false, calc_on_order_fills = false,
     process_orders_on_close = false)

fastLength = input.int(20, "Fast SMA bars", minval = 1)
slowLength = input.int(50, "Slow SMA bars", minval = 1)
stopTicks = input.int(100, "Stop distance in ticks", minval = 1)
targetTicks = input.int(200, "Target distance in ticks", minval = 1)

fast = ta.sma(close, fastLength)
slow = ta.sma(close, slowLength)
enterLong = ta.crossover(fast, slow)
closeLong = ta.crossunder(fast, slow)

if barstate.isconfirmed and enterLong and strategy.position_size == 0
    strategy.entry("Long", strategy.long)
    strategy.exit("Bracket", "Long", loss = stopTicks, profit = targetTicks)

if barstate.isconfirmed and closeLong and strategy.position_size > 0
    strategy.close("Long")

plot(fast, "Fast SMA", color = color.blue)
plot(slow, "Slow SMA", color = color.orange)

Check syntax, then check the trading meaning

Paste the complete file into the Pine Editor, save it, and add it to the chart. If compilation fails, send the exact diagnostic and full current source back to the model. Request the smallest correction, then compile again. Keep the specification beside the code: a compiling script can still implement the wrong rule.

Trace the first trades before reading the equity curve

Use standard candles and record the symbol, timeframe, inputs, chart session, and strategy properties. Find a crossover and follow its entry through the trade list. With the sample settings, a market order generated at the close normally fills on the following bar open. The signal price and fill price can differ. A gap can also carry an exit beyond its planned stop.

• Verify that every entry starts while flat and that no short position appears.
• Check the bracket against the fill price, tick size, and recorded exit reason.
• Locate a crossunder while long and inspect whether the bracket or market close fills first.
• If stop and target are both inside one historical bar, inspect emulator assumptions and consider Bar Magnifier where available.

Evaluate costs and an untouched period

Choose development and evaluation dates before tuning. Save the code and inputs after development, then apply them unchanged to the later period. If you revise the strategy after seeing that period, it has become part of development; reserve another period for evaluation. This is a proposed procedure, not a test performed for this page.

• Replace illustrative fees and slippage with documented assumptions; compare a higher-cost scenario.
• Record trade count, net result after costs, drawdown, exposure, and the date range alongside each result.
• Inspect whether a few trades or one market regime account for most of the result.
• Forward-test with unchanged rules and record discrepancies between expected and observed behavior.

What AI assistance can and cannot verify

ChatGPT can help draft and explain a specification, but its answer can contain errors. Do not treat an assertion that code was tested as evidence: ask for the exact source, checker result, and test configuration. Pineify provides a Pine Script coding workflow with syntax diagnostics and editable source. Strategy behavior still needs review in TradingView, and this page reports no first-pass success rate or measured trading performance.