Right now almost every job is being handed over to an AI agent. Writing, coding, research, customer support, data analysis — you name it, someone has already built an agent that does it end to end. So the obvious next question for anyone who trades is: why not let the agent place the order too?
I build my own scanners. I am a software engineer, I write Python every day, and my scanner already does the hard part — it goes through the entire universe of stocks and hands me a shortlist every evening. Adding the broker API on top of that is not a difficult piece of work. Technically I could have automated order placement months ago.
I have not. And this post is my honest reasoning for why, along with the conditions under which I would change my mind.
Execution Was Never the Hard Part
When people say "automated trading", they usually picture the order going out to the exchange without a human touching anything. That part is the easiest piece of the whole chain. Placing an order is an API call. Any developer can wire it up in an afternoon.
The hard part sits one step earlier, and it is a question the code cannot answer:
My scanner has listed these stocks. Do I actually want to buy them?
That is the entire problem in one line. A scanner does not produce trades. It produces candidates. The gap between a candidate and a trade is filled with judgement, and I have not yet found a way to write that judgement into a function.
What My Scanner Sees, and What It Doesn't
Take my RSI and price breakout setup as an example. The logic is precise and completely mechanical:
- Price breaking above a falling trendline drawn across the recent lower highs
- RSI breaking above its own trendline at the same time, so momentum confirms the price move
- Volume expansion on the breakout candle, not a quiet drift through the level
- The breakout candle closing above the level, not just poking through it intraday
Those rules run perfectly. The code does not get tired, does not skip a stock, does not have a bad day. It never draws the trendline slightly differently on a Friday evening because it is bored. If I described the rules correctly, the output is correct. I have covered the setup itself in my Trendline post, and how I built the scanner in How I Automated My Stock Scanning with Python.
But look at what those rules do not know:
| What the scanner sees | What it cannot see |
|---|---|
| Price closed above the falling trendline | Whether that was a genuine breakout or a one-day spike on a rumour |
| RSI broke its trendline on the same candle | That quarterly results are due in two days |
| Two points connected into a valid trendline | Whether a human would have drawn that same line, or picked a different swing high |
| Average volume over N days | Whether I can actually exit that SME counter without moving the price myself |
| The stock's own chart | That the index is breaking down and the whole sector is being sold |
| Yesterday's closing data | A gap-up open that has already eaten my entire planned reward |
Every one of those blind spots can be partially coded. I can add a results-calendar filter. I can add a liquidity floor. I can add an index-trend condition. And I have added some of them. But each new filter is another rule I have to be right about, and the list of things that can go wrong keeps growing faster than the list of things I have covered.
The Real Danger: Trading Bugs Are Silent
This is the point I would ask every developer-turned-trader to sit with.
In normal software, a bug is loud. Something crashes, a test fails, a user complains, an error appears in the log. You find out quickly.
In trading code, a bug is silent. If my RSI period is off by one, or my trendline is anchored to the wrong swing high, nothing crashes. The scanner runs, produces a clean list, and the list looks perfectly reasonable. I would have no way of knowing anything was wrong. The only place that bug shows up is in my profit and loss statement, weeks later, after it has already cost me money.
Now imagine that same silent bug with automatic order placement switched on. The bug does not just give me a slightly wrong watchlist to review. It buys. Repeatedly. In real quantity. Before I have any idea it exists.
That asymmetry is the core of my hesitation. When a human reviews the list, a strange output gets caught — I look at a name and think "that does not belong here", and I go check the code. Remove the human, and there is nobody left to notice.
I Spent a Month Verifying the Scanner Before I Even Trusted the Watchlist
When my scanner first started producing output, I did not trade from it. For roughly a month I opened every single name it gave me and checked the chart myself, one by one.
I was not doing this because I doubted Python. I was checking whether the rules I had written actually described the setup I had in my head. Those are two different things, and the gap between them is where most trading systems quietly fail.
That month found real problems — conditions that were technically correct but caught the wrong kind of stock, filters that were too loose, cases where the setup looked right on paper and obviously wrong on the chart. I fixed them because I was looking.
And note what the stakes were: this was just a watchlist. If a month of manual checking was needed before I trusted a list of names, how much verification does an automated order deserve?
My Rule: Six Months to One Year, Then Small Quantity
So here is the standard I hold myself to before any automation touches a live order:
- Backtest the scanner output over historical data. Not the strategy in theory — the actual list the code produces. These are not the same thing.
- Forward-test for six months to one year. Run the scanner daily, record every signal, and trade them manually. Live market conditions expose bugs that no backtest ever will.
- Keep a log of every failure. Every time the list gave me something I chose not to trade, write down why. That "why" is exactly the logic that is missing from the code.
- Fix the issues and re-verify. Every fix restarts the clock on the part of the system it touched.
- Only then, automate — starting with the smallest quantity you can place. Not your normal size. The smallest.
Six months to a year sounds slow, and it is. But an automated system that places orders is not something you test in a fortnight. You need it to have lived through a rally, a correction, a dull sideways stretch, and a results season. A system that has only seen a trending market has not been tested. It has been flattered.
Automation Does Not Fix Temperament
There is one more reason, and it is personal.
I lost my entire capital early in my trading career in futures and options. I have written about that in F&O vs Cash Market. The thing that finished me was not a lack of tools or information. It was position size and psychology.
Automation does not fix psychology. It removes the pause. Right now, between my scanner's list and my order, there is a gap where I look at the chart and occasionally decide not to take the trade. That gap is not inefficiency. It is a brake. Automating order placement removes the brake and lets a bad idea execute at machine speed.
I am also willing to admit the obvious: part of this is just that I am not comfortable yet. That may be a limitation of mine rather than a limitation of the technology. But in trading, doing something you are not comfortable with tends to end badly regardless of whether the logic is sound.
What I Do Automate
None of this means avoiding automation. I automate a great deal — just not the decision.
| Automated | Manual |
|---|---|
| Scanning the full universe daily | Final decision to buy or skip |
| Applying RSI and price trendline conditions | Position sizing |
| Volume and EMA retest filtering | Entry timing on the day |
| Pulling results, promoter and flow data for cross-checks | Reading whether the setup still makes sense today |
| Ranking and alerting | Exits, especially when a trade goes wrong |
The pattern is simple. I automate everything that is work. I keep everything that is judgement. Scanning 2,000 stocks by hand is work, and I am happy to never do it again. Deciding whether this particular breakout on this particular day deserves my money is judgement, and I am not ready to outsource it.
What Would Change My Mind
I am not against automated execution permanently. Here is what I would need first:
- A full year of forward-tested signals with a documented, honest hit rate
- A hard, coded maximum on daily loss and number of positions — a kill switch that does not need me to be awake
- A liquidity filter I trust completely, especially for the SME segment
- An exit rule that is at least as well tested as the entry rule, which is where most automated systems are weakest
- Three months of running it live at minimum quantity with no surprises
If all of that holds, I will automate. Until then, my scanner does the searching and I do the buying.
The Takeaway
AI and automation have genuinely changed how I trade. My scanner finds setups I would have missed and saves me hours every single day. That part is settled.
But there is a difference between a tool that finds opportunities and a system that acts on them. The first only costs you time when it is wrong. The second costs you capital, silently, before you know anything is wrong.
Backtest it. Forward-test it for six months to a year. Fix what breaks. Then start small.
The market is not going anywhere, and neither is the technology. There is no prize for automating first.
If you are just getting started, begin with Stock Market for Beginners and my Trading Strategy post before thinking about automation. Automating a strategy you do not fully understand is the fastest way to lose money efficiently.
Disclaimer: This post is for educational purposes only and is not investment advice. I am not a SEBI-registered advisor. Trading in the stock market involves risk of loss. Please do your own research or consult a registered advisor before making any investment decision.
Comments
Post a Comment