TRADING STRATEGY WITH CHATGPT, EXPLANATION: (please read carefully this post)

Upon opening a new chat with ChatGPT, copy/paste the initial prompt contained in the corresponding attachment (either the one for a strategy or the one for an indicator). Then press ENTER.
Then you can start making requests.

Why this initial prompt?
It allows you to start a discussion by defining a lexical field and a template for what will be asked later.

Example of a prompt for the creation of a “simple” strategy:
code a strategy that: buy when rsi cross above oversold zone and price is above supertrend

The code returned should be of this type:

defparam cumulateOrders = false 

// Define parameters for RSI and SuperTrend
rsiLength = 14
rsiOversold = 30
stLength = 10
stMultiplier = 3

// Calculate the RSI and SuperTrend
rsiValue = rsi[rsiLength](close)
stValue = supertrend[stMultiplier,stLength]

// Define the trading conditions
if rsiValue crosses over rsiOversold and close > stValue then
  buy at market 
endif

As you can see, the code is correct, with no instruction or syntax errors.

Example of another prompt:

code a strategy that: set buy pending order at bollinger upper band, add a takeprofit, add a trailing stop

resulting code is:

defparam cumulateOrders = false 

// Setting the parameters for the Bollinger Band
Length = 20
Deviations = 2

// Define the Bollinger Bands
UpperBand = BollingerUp[Length, Deviations]

// Define the take profit and trailing stop levels (in points)
TakeProfitLevel = 50
TrailingStopLevel = 25

if not onmarket then
  if close crosses under UpperBand then
    buy stop at UpperBand next bar at market
    set target pprofit TakeProfitLevel
    set stop ptrail TrailingStopLevel
  endif
endif

Here the code is incorrect, it does not know how to correctly place a BUY STOP order, the definition of the high bollinger is incorrect (syntax), the trailing stop instruction is also incorrect.
In case of detection of an incorrect code, I modify the initial prompt in order to give it more knowledge for the next uses. So in this case I add to the initial prompt file, the following elements:

• To set a pending buy stop order at price X, price must be below the price X, use the instruction: BUY AT X STOP
• To add a trailing stop of X points, use the instruction: SET STOP PTRAILING X
• The upper bollinger band of period X iand deviation Y is calculated with the instruction: AVERAGE[X]+STD[X]*Y

I run the same prompt again for my strategy and the resulting code is:

defparam cumulateOrders = false 

// Setting parameters for the Bollinger Band
length = 20
deviation = 2

// Setting parameters for takeprofit and trailing stop
takeProfit = 50
trailingStop = 10

// Calculate Bollinger upper band
upperBand = average[length] + std[length]*deviation

// If price is lower than the upper band, set a pending buy stop order at the upper band
if close < upperBand then
    buy at upperBand stop
endif

// Setting takeprofit and trailing stop
set target pprofit takeProfit
set stop ptrailing trailingStop

We can see that he has perfectly understood the lesson!

In conclusion, the initial prompt shared here in the attached text file will have to be modified as we test and as you discover, to get a perfect understanding of the ProBuilder language and thus allow it to generate code with a minimum of possible errors.

Other examples of prompts:

1. code a strategy that: buy when stochastic cross above oversold zone and price is above both moving averages of periods 50 and 200 : https://www.prorealcode.com/topic/create-strategies-codes-with-chatgpt-for-prorealtime/#post-214593)
2. code a strategy that: buy with market orders at previous donchian high and sellshort with market orders at previous donchian low : https://www.prorealcode.com/topic/create-strategies-codes-with-chatgpt-for-prorealtime/#post-214594)
3. code a strategy that: buy at market each time the price cross under the lower bollinger bands, cumulate orders is true, close orders when profit is 10 in money : https://www.prorealcode.com/topic/create-strategies-codes-with-chatgpt-for-prorealtime/#post-214605
4. code a strategy that: buy at market on rebound of a strong bullish trend, use a trend following indicator to determine trend and an oscillator for timing of entries, add a trailing stop, cumulate orders is true : https://www.prorealcode.com/topic/create-strategies-codes-with-chatgpt-for-prorealtime/#post-214608
5. code a strategy that: buy at market each X points, in an uptrend, cumulate orders is true, add a trailing stop : https://www.prorealcode.com/topic/create-strategies-codes-with-chatgpt-for-prorealtime/#post-214611
6. create a strategy for: buy at market when a short term hull average change from red to green, in a strong uptrend, add a takeprofit of X and a stoploss of Y : https://www.prorealcode.com/topic/create-strategies-codes-with-chatgpt-for-prorealtime/#post-214613

-> REMEMBER TO USE THE INITIAL PROMPT OF THE FIRST POST TO INITIATE A NEW DISCUSSION WITH CHATGPT <-

ATTACHED TEXT FILE IS THE CURRENT VERSION OF THE ABOVE STRATEGY PROMPT 

code a strategy that: buy with market orders at previous donchian high and sellshort with market orders at previous donchian low

Sure, here is a ProBuilder code that buys at the previous Donchian high and sells short at the previous Donchian low using market orders.

defparam cumulateOrders = false 

// Setting the parameters for the Donchian channel
Length = 20

// Calculate the Donchian channel
DonchianHigh = highest[Length](high)
DonchianLow = lowest[Length](low)

// If the close price is above the previous Donchian high, place a market buy order
if close > DonchianHigh[1] then
    buy at market 
endif

// If the close price is below the previous Donchian low, place a market sell short order
if close < DonchianLow[1] then
    sellshort at market 
endif

In this code, the previous Donchian high and low are represented by DonchianHigh[1] and DonchianLow[1], respectively. If the close price is above the previous Donchian high, a market buy order is placed. If the close price is below the previous Donchian low, a market sell short order is placed.

Please note that this code does not include any conditions for closing the positions. You might want to add those depending on your trading strategy.

TIP: You can also be more “generic” to let the IA determines itself what indicators to choose for your strategy:

code a strategy that: buy at market on rebound of a strong bullish trend, use a trend following indicator to determine trend and an oscillator for timing of entries, add a trailing stop, cumulate orders is true

To code your strategy, I’ll use the Moving Average Convergence Divergence (MACD) as the trend-following indicator and the Relative Strength Index (RSI) as the oscillator to time entries. The MACD shows the relationship between two moving averages of a security’s price, while the RSI compares the magnitude of recent gains and losses over a specified time period to measure speed and change of price movements.

defparam cumulateOrders = true // Cumulating orders is enabled

// Setting the parameters for the MACD and RSI indicators
MACDLengthFast = 12
MACDLengthSlow = 26
MACDLengthSignal = 9
RSILength = 14
OverSold = 30 // RSI level for oversold conditions

// Calculating the MACD and RSI
macdValue = ExponentialAverage[MACDLengthFast](close) - ExponentialAverage[MACDLengthSlow](close)
signalValue = ExponentialAverage[MACDLengthSignal](macdValue)
rsiValue = RSI[RSILength](close)

if macdValue > signalValue and rsiValue crosses over OverSold then
    buy at market
endif

// Set a trailing stop of X points
X = 15 // Define your own value for X
SET STOP PTRAILING X

This strategy buys at the market on a rebound from an oversold condition (as indicated by the RSI crossing over the oversold threshold) during a bullish trend (as indicated by the MACD line being above the signal line). A trailing stop is also set. Please adjust the parameters and thresholds as required for your strategy.

create a strategy for: buy at market when a short term hull average change from red to green, in a strong uptrend, add a takeprofit of X and a stoploss of Y

Sure, I’ll consider a strong uptrend to be when the long-term Hull Moving Average (HMA) is also increasing. I’ll use 21 periods for the long-term HMA, but you can adjust this to your liking. We’ll use a change from decreasing (red) to increasing (green) in the short-term HMA to trigger the buy condition.

Let’s denote X as the take profit target and Y as the stop loss limit.

Here is the strategy:

// Setting the parameters for the Hull Moving Averages
ShortTermLength = 9
LongTermLength = 21

TakeProfitX = 50 // adjust this to your liking
StopLossY = 25 // adjust this to your liking

// Calculate the Hull Moving Averages
ShortTermHMA = HullAverage[ShortTermLength](close)
LongTermHMA = HullAverage[LongTermLength](close)

// Identify when the ShortTermHMA changes from decreasing (red) to increasing (green) and LongTermHMA is also increasing
if (ShortTermHMA[1] < ShortTermHMA[2] and ShortTermHMA > ShortTermHMA[1]) and LongTermHMA > LongTermHMA[1] then
    buy at market
    set target pprofit TakeProfitX
    set stop ploss StopLossY
endif

In this code, ShortTermHMA[1] < ShortTermHMA[2] and ShortTermHMA > ShortTermHMA[1] checks if the short-term HMA is now increasing after decreasing, signaling a change from red to green. LongTermHMA > LongTermHMA[1] checks if the long-term HMA is increasing, which indicates a strong uptrend. When all these conditions are met, the code executes a buy at market order and sets the take profit and stop loss levels.