Working with an existing NinjaTrader Strategy can become difficult during a longer AI development conversation. The original source code may be buried in earlier messages, requirements can change over time, and users may find themselves repeatedly uploading or pasting the same NinjaScript files.
Following valuable feedback from our beta customers, we have improved the Working with an Existing Strategy workflow in Xen AI for NinjaTrader. Existing-code projects can now retain the current Strategy source, supporting source files, confirmed requirements and important clarification decisions as durable project state.
This makes it easier to review, repair, extend or merge existing NinjaScript without relying entirely on the chat history.
Watch the Improved Existing Strategy Workflow
This demonstration shows how an existing NinjaTrader Strategy can be loaded into Xen, reviewed and then modified while the important source files and development decisions remain connected to the project.
Watch the existing NinjaTrader Strategy AI tutorial on YouTube
Add the NinjaScript as Dedicated Source Code
When you want to modify an existing NinjaTrader Strategy, Xen now provides a dedicated Add source code workflow. You can paste the complete source into a dedicated editor or load an existing .cs file directly from your computer.
The attached source is stored separately from the normal conversation history. Chat messages can still provide useful instructions and context, but they are no longer the sole source of truth for the Strategy Xen is expected to review or modify.
If a complete NinjaScript Strategy is pasted into the normal message box, Xen can redirect it into the source-code attachment workflow instead. This helps prevent a large source file from becoming just another message inside a long conversation.
The Current Codebase
The first Strategy attached to the project becomes the Current codebase. This is the authoritative Strategy Xen uses when reviewing or processing later modification requests.
If you later have a newer version, you can add the file and select Replace current source. The new file then becomes the current Strategy.
Only one file can be the current source at a time. This gives Xen a clear answer to an important development question: which version of the Strategy should actually be changed?
Use Additional NinjaScript Files for Merging or Reference
An existing-code project can contain up to four source files. Additional files can be used when you want Xen to merge NinjaScript source from another project or study an existing implementation as a reference.
When another source file is added, you choose how Xen should use it:
- Integrate with current source means relevant functionality should be incorporated into the current Strategy.
- Use as reference only means Xen may study the source as an example without automatically merging all of its functionality.
- Replace current source makes the newly attached file the authoritative Strategy.
The workspace identifies files as current source, additional source or reference source, making their purpose clear throughout the project.
Remove Incorrect or Obsolete Attachments
Every source attachment also includes a remove control. If the wrong file is attached, an old version is no longer needed or a reference file becomes irrelevant, it can be removed from the project.
If the current source is removed, Xen requires another current source before it can continue reviewing or modifying the Strategy. This prevents an existing-code task from continuing without a clearly defined codebase.
Review the Strategy Before Changing It
Once the current source has been saved, a Review strategy button becomes available.
This asks Xen to review NinjaScript code across the attached files, explain the existing Strategy behaviour, identify potential defects or development risks, and highlight requirements or decisions that still need clarification.
The review stage is analysis-only. Xen should not rewrite or generate a replacement Strategy during this step.
This is particularly useful for traders with limited programming experience. Before asking AI to change unfamiliar code, you can first understand what the existing Strategy is doing and identify areas that may need further explanation.
A Practical Example
Imagine you already have an EMA trend Strategy and want to add a trailing-stop system from another NinjaScript Strategy.
You would first add the EMA Strategy as the current source. The second Strategy could then be attached using Integrate with current source, telling Xen that relevant trailing-stop functionality should be merged into the main Strategy.
Before requesting the merge, you could use Review strategy. Xen may identify a decision that needs clarification, such as whether the trailing stop should activate immediately after entry or only after a defined profit threshold.
Once you answer that question, the decision can be retained with the project. You can then request the modification without pasting both Strategies and all the earlier requirements back into the message box.
Requirements and Decisions Stay with the Project
The improved workflow also retains requirements, clarification answers and approved user decisions for existing-code projects.
When you later ask Xen to modify or merge the Strategy, the request can be reconstructed using the current source, additional and reference files, retained requirements, clarification answers, previous user decisions, the latest generated working version and recent chat as supplementary context.
This is not unlimited AI memory. It is durable project state for existing-code tasks, designed to preserve the important information required for continued NinjaTrader Strategy development.
The practical benefit is fewer repeated uploads, less chance of confirmed requirements disappearing from context and fewer AI tokens being spent repeatedly sending the same source code.
Continue from the Latest Working Version
When Xen returns a complete revised Strategy, that code becomes the latest working version available to the next modification request.
For example, if Xen first adds a trailing stop and you then request a trading-time filter, the next change can be applied to the revised Strategy instead of accidentally returning to the original source.
You should still download, compile and test each meaningful version before moving on to unrelated changes. Keeping tested development checkpoints makes it much easier to identify when a later modification introduces unexpected behaviour.
Code Actions Only Appear for Complete NinjaScript Files
The existing-code interface has also been improved so code-specific controls are displayed only when Xen returns a complete NinjaScript file.
Download .cs, Download Add-On, Build Check and Verify Requirements are therefore not displayed beneath Strategy reviews, clarification questions, requirements lists or small code snippets.
This makes it clearer whether Xen is analysing your Strategy or has produced a complete file ready for the next development stage.
Build, Check, Compile and Test Every Strategy
AI can accelerate NinjaTrader Strategy development, but generated or modified code still needs to be verified. AI output is not guaranteed to compile successfully or satisfy every development requirement.
After Xen produces a complete Strategy, use Build Check for an initial validation. You should then download the .cs file, compile it in NinjaTrader and resolve any reported errors.
Once the Strategy compiles, test its behaviour carefully before considering any live use. This is especially important when you merge NinjaScript source from multiple projects because individually valid components can interact in unexpected ways when entry, exit, risk-management or state-management logic is combined.
A Better Way to Modify Existing NinjaTrader Strategies with AI
The improved workflow gives Xen a more structured foundation for AI NinjaTrader coding when the project already contains working or partially working NinjaScript.
Instead of repeatedly pasting source code and trying to preserve important decisions inside a growing conversation, you can maintain the current Strategy, supporting files, confirmed requirements and clarification decisions as part of the project.
For traders who want to review, repair, extend or merge an existing NinjaTrader Strategy, this provides a cleaner and more reliable approach to AI-assisted NinjaScript development.
