Why AI Fails at Automating Trading Strategies

When we started with trading automation, we discovered that coming up with a strategy idea is not the difficult part. Turning that idea into a safe, working, and hopefully profitable algorithm is. There were no publicly available AI models that could just code up anything you ask of it. Automating trading strategies had to be done the hard way, by actually writing code yourself. 

Fast forward 6 years, and we see how much the industry has progressed when it comes to the adoption of automated trading. The AI hype has entered the trading space, and people show off their AI-generated algorithms as if they discovered the holy grail of trading. Funnily enough, not much has changed since the space is still filled with people selling a dream with very little proof to back up the claims. 

Large Language Models (LLMs), as would be the correct term to describe the AI models used by people to generate code and strategy ideas, undoubtedly have a massive impact on how anyone can now create basic automated trading strategies without having to write a single line of code themselves. When we ventured out to build Profectus, we already saw this coming, but continued building our platform anyway.

The main reason for our continued efforts is that there are distinct differences between the actual output of an LLM and the output of a Profectus-generated algorithm.

We did not build Profectus to compete with idea generation and code generation. We built it because in automation, the real challenge is not generating possibilities. The real challenge is building something precise, explainable, testable, and safe enough to trust with execution.

ChatGPT helps traders think better about automated strategies.

Profectus helps them build better automated strategies.‍

False confidence

Let’s be very clear about something: AI is awesome! We use LLMs ourselves for a variety of tasks, including coding. But there are some serious problems to consider before trusting your trading capital with an AI-generated trading strategy. 

LLMs require very precise instructions to generate exactly what you want. An LLM output is only as good as your prompt. The big problem is that a lot of people expect too much from the LLM and start throwing random strategy ideas, expecting a fully coded and profitable strategy in return after 20 seconds. For instance:

“Give me a profitable scalping strategy for XAUUSD”

This is a prompt that is most likely being used thousands of times. The worst part is that the LLM will happily start coding a strategy for you based on these very basic instructions. It will spit out a code file, let’s say, in MQL5 syntax that looks flawless. It will add some adjustable inputs for risk management and some indicator settings on its own initiative to really boost that confidence. Everything looks amazing until you try to compile the file and try running a backtest.

The problem is that there is an internal reward system that gets triggered when you download the code file generated by the LLM. It almost feels like you have done the work yourself. However, you and the LLM have no idea if the code is working properly and what the actual strategy is doing. An LLM might give you something that sounds coherent, but if the underlying logic contains hidden ambiguity, conflicting conditions, or edge cases you never noticed, those problems do not disappear when the system goes live. 

Most people overestimate the capabilities of these AI tools, and that creates false confidence.  

The problem is not that LLMs are useless, because they are clearly not. The problem is that they are optimized for fluency, while trading automation depends on getting all the specifics right. Profectus complements this by creating an environment where strategy logic must become more precise before it can move forward. Building a trading bot in Profectus invites you to consider all the details before you can think of running it.

Getting out of the Black Box

The Black Box refers to a system where the user knows what the inputs are and what the outcomes are, but doesn’t actually know what happens inside the system that produces the outcomes. In a lot of machine learning algorithms, this is not so much a bad thing. But if you are an inexperienced coder, it can be quite worrisome to not know exactly what is happening inside your trading system.

Profectus was built around the opposite principle: make the logic visible, make the structure explicit, and reduce hidden assumptions before they become expensive surprises. Visually creating the logic for your trading algorithms helps you understand exactly what is in them and what rules the system is following.

Even when you use one of the many pre-built strategy templates, you can follow all the steps and open the blocks to understand the trading rules in plain English. 

Blindly copying code from an LLM and running it on your trading account is a perfect example of Black Box automation. The issue with Black Box automation is not that the output looks wrong. A well-known problem of LLMs is hallucinating and hiding contradictions in code. LLM-generated strategies have been shown to include: 

• Entry rules that have not been described by the user
• Added filters for “better” performance without the user’s request
• Conditions that create unrealistic backtest assumptions (no commissions, spreads or high-frequency assumptions)
• Contradicting indicator conditions that will never present themselves in a live market

It is that it often looks right before it has really been challenged. LLMs are excellent at producing plausible strategy logic, but automation becomes dangerous when plausibility is mistaken for reliability. 

Strategic combination of LLMs and Profectus

LLMs such as ChatGPT and Claude are designed to be broadly helpful across many domains. They can help you with writing, idea generation, data analysis, coding, and so much more. That is exactly why they are so powerful. It seems that LLMs can do everything, and it’s very hard to argue that they cannot. But trading automation is a narrow domain with very specific requirements: rule clarity, logical consistency, and safe implementation. 

Profectus was built around those requirements from the start. The platform was designed to go beyond what LLMs can do for you and offer services that are actually helpful for traders. It was designed to be the driver for all those wonderful ideas you can generate with LLMs.

There is a strong strategic advantage to combine Profectus with LLMs. The best workflow is often not LLMs or Profectus. It is LLMs for exploration and strategy development, and Profectus for structure, implementation, and verification. LLMs are used for the exploration of ideas. Profectus allows you to build those ideas out into trustworthy systems that provide direct feedback.

With Profectus moving toward cloud backtesting inside the builder, the workflow becomes even tighter: a trader can move from idea, to structure, to validation without breaking context or relying on disconnected tools. Cloud backtesting will change the way you develop and automate your trading algorithms. It’s the direct feedback loop that instantly tells you if your ideas are worth pursuing or if they need serious adjustments. 

Conclusion 

Profectus was built for the part of the workflow where strategy ideas need to become safe, working trading algorithms. It helps traders move beyond vague descriptions and toward something a machine can actually understand, execute, and eventually verify. In that sense, Profectus is not trying to replace the usefulness of LLMs. It is solving the harder downstream problem they were never designed to solve on their own.. 

In a world where AI can generate endless trading ideas, the real edge will belong to the traders who can turn those ideas into clear, testable, trustworthy systems. That is exactly where Profectus stands apart.

‍