Code Is No Longer a Constraint
"In theory, there is no difference between theory and practice. In practice there is." - Yogi Berra
I rebuilt part of my backtesting engine last month. The first time I wrote it, years ago before ChatGPT, it took the better part of three weeks. This time, with Claude Code, it took an afternoon. A few cycles of careful prompting and review, and the new version was better than the original.
For an operation like mine, code used to be the constraint. Not the only one, but a binding one. The sheer volume of plumbing code that a solo operator had to write, the effort needed, and systems maintenance was what stood between an idea and a running system. That pain is mostly gone now thanks to AI coding. The model code, the broker glue, the infrastructure that holds the whole thing together: most of the lines of code I once snorted are a weekend’s work for anyone with AI tools and the sense to use them.
That’s worth saying plainly. If code isn’t what constrains a trading operation anymore, then it’s worth writing about what does.
The build is a few weeks now
A senior quant who knows what they’re doing, paired with current AI coding tools, can stand up a working end-to-end MVP for a systematic equity stack in four to eight weeks. A signal model, a factor model, a backtester, broker integrations, data feeds, paper trading, a monitoring dashboard. Running. End to end.
That number is a guess from my own experience, not a benchmark. The direction isn’t in doubt. The plumbing that used to be hard for a solo operation is now mostly tractable for one person and a capable model. The stack isn’t the thing standing in the way anymore.
What constrains trading now
Several things still separate that prototype from a system you’d put leverage behind. Here’s the honest part: none of them is a wall that keeps a determined, smart, funded competitor out. They’re all technically surmountable. They’re also… expensive, slow, or both, and none of them gets cheaper because your tooling improved. The constraints shifted. They didn’t go away. They come in two kinds.
Task-based constraints
These include data, production exposure and validation. AI takes a lot of the grunt work out of these and leaves an tractable residual volume of work. The size of the residual determines the size of the constraint on trading.
Data
A complete, point-in-time-correct history is a procurement and hygiene problem that costs money and time. You have to account for:
Survivorship
De-listings
Corporate actions
Lookahead bias (the system cheats in backtests)
It’s wonderful that agentic coding compresses the cleaning grind, and not by a little. Point an agent at several vendors, have it cross-check corporate actions, flag the gaps, and generate adversarial tests that check whether anything references a fact dated after the as-of date. A lot of what I used to call manual work is now a monitored loop. The residual after agentic coding of a data cleaning pipeline: the time and effort you need to spend checking its work and iterating.
The real question here isn’t how much work an agent can reduce when it comes to cleaning financial data. It’s whether it’s sound to launch a data system that no human audited, with real capital riding. Someone needs to sign off, and that someone is accountable. Whether the agent can do the work is beside the point. Nobody ships on the strength of work they didn’t check, because the agent doesn’t lose the money when a silent error reaches the tape. Your firm does. Verification isn’t a step you finish and hand off. It’s a judgment that must be owned, which makes this less a data problem than a risk one. More on that below.
Production exposure
The bugs that hurt you most only show up once the system is alive: running against a real broker, in real markets, for real time. Tests won’t catch them. Keep a barrage of unit and integration tests anyway, because skipping them is indefensible now that AI writes most of them for you. But tests cover the failures you thought to imagine. The bugs that hurt are the ones you didn’t. A few from my own catalog:
Callbacks from the broker that sometimes silently never fire
The socket your broker de-authorized because it decided to
The malformed fill response at the close
That’s the broker deviating from orderly behavior, in undocumented ways. Some you can catch in paper trading. Some you can’t. You can shrink the rest with shadow runs and replayed message logs. But you can’t drive it to zero through prompting. At some point the only teacher is time on the tape with money behind it, and that time doesn’t compress. AI is great at fixing each bug once you’ve found it. Finding them, and building the logging that lets you see them, is the part that stays slow.
Validation you trust
AI will scaffold the validation for you: lookahead checks, fill-assumption tests, timestamp audits, generated fast. That’s the part it takes. What it can’t take is the belief. There’s a chasm between a backtest that looks right and one you’d put leverage behind, and crossing it means distrusting your own good result on purpose: hunting for the leak that flatters it, the fill assumption that’s too kind, the timestamp that’s off by a bar.
This is where the fast, accept-the-diff style of AI coding gets dangerous. Picture the nightmare: an AI auto-ships a one-line future-information bug that produces a gorgeous backtest, and then live trading drains the account. The discipline here is the opposite of speed, and it costs you one of two things. A lot of careful time, or a large negative number on the P&L when you skip it.
Judgment-based constraints
An example of a judgment deliberating and choosing which edges to develop, and how much you’re willing to lose if you’re wrong. Another is what markets to enter. Judgments matter because financial losses land on you and your firm, not the AI or its provider.
Judgments don’t reduce to tasks. You shouldn’t hand these to the machine, because the machine doesn’t bear what happens when it’s wrong.
The strategy
The strategy is the deepest of constraints, and it’s the one AI shrinks least. It sits beneath everything else: finish the above data, exposure, and validation tasks and you’ve still got nothing to trade without an edge. You can get an AI to hand you something that shows a little alpha on clean data, but trading that out of the box is a bad idea. What it gives you is a starting block, and the distance from there to something you’d put real money behind is still long and hard, paved with mistakes only you will make.
Owning the risk
Risk management as a task, AI does well: exposure monitors, factor-neutrality logic, position sizing against the volatility regime, stress scenarios. I expect it to become a serious part of risk management everywhere. This part compresses surprisingly well thanks to AI.
Owning the risk doesn’t compress at all. It stays with the firm, because it is the only part of the system that suffers when things go wrong. AI can run the machinery; it can’t set the risk appetite the machinery runs inside. The question that matters is how much you’re willing to lose if you turn out to be wrong about something upstream. That number is a judgment about consequences that land on your firm, and the machine can’t set it better than you can, because it bears none of the downside and you bear all of it.
Where the constraint went
Put it together and the constraint has moved, not vanished. It came off the keyboard and onto data you have to buy and clean. It’s the time you have to spend live trading, building monitors, and applying judgment to what your system tells you. It always included the risk you have to own completely. None of that walls your operation off from anyone. It’s just where the work is now. And lucky for me — it’s not easy (nor is it supposed to be).
If you already have those things, your build time collapses to a weekend, which is the clearest sign of where the value sits. If you don’t, there’s no prompt for them. You get them the slow way, the same way I did.
Takeaways
The thing that used to constrain a solo trading operation, the volume of code, is now cheap. Treat implementation as a commodity and stop guarding it.
The constraints that remain don’t vanish because your tooling improved. Trustworthy point-in-time data, live time on the tape, and validation you actually believe are all still hard.
Owning the risk is a person’s job, because only the person suffers when the system is wrong.
The strategy itself is the deepest constraint. AI hands you a starting block, not an operation.