Your Tools Got Powerful. Get Boring.
The most powerful tools in history reward the most boring strategies. The gap widens every time they improve.
The bored trader beats the machine
On one side of the trade sits a market-making engine that represents the genuine state of the art: Hawkes processes modelling order arrivals, Kyle’s lambda pricing the impact of each fill, Avellaneda-Stoikov inventory control balancing the book in real time. Years of mathematics, running on hardware that did not exist a decade ago.
On the other side is a momentum trader whose entire system is price, volume, and three moving averages. He sits in cash most of the year doing nothing, waiting for a setup he could describe to you in a sentence. His stack is deliberately primitive. His edge is patience and the discipline to follow his own rules when they are boring and to sit out when they are silent.
Over a full market cycle, the boring one is more likely to still be standing.
This is uncomfortable, because it runs against an intuition almost everyone shares: better tools should let you run better, more sophisticated strategies. More compute, more data, more powerful models, therefore more elaborate approaches and better results. It feels obviously true. It is the logic behind most of what gets built, bought, and bragged about.
It is also, across domain after domain, wrong. And the interesting part is the shape of the curve.
The gap widens as the tools get stronger
Here is the pattern the most successful practitioners keep seeing, whether they are trading, building software, learning, or shipping products. Powerful tools do not pay off when you point them at more complex strategies. They pay off when you point them at simple strategies and execute those faster, more consistently, and with less drift than anyone else.
More power applied to a simple strategy compounds. The same power applied to a complex one mostly buys you more ways to be wrong.
Sit with the second half of that, because it is the part people miss. A sophisticated strategy is not free. Every additional layer needs to be specified, verified, maintained, and monitored, and all of that consumes exactly the capacity the powerful tool was supposed to give back. A simple strategy spends its new power on doing the simple thing relentlessly well. A complex one spends its new power feeding its own machinery.
The reason this matters more now than it ever has is that the tools have never been this strong. When your instruments are weak, the gap between the simple-and-disciplined path and the complex-and-fragile path is small, because nobody can do much of either. As the instruments get more powerful, both paths open up, and the distance between them widens. The most capable tools in history make disciplined simplicity more effective than ever, and they also make unmanageable complexity easier to build than ever. We are living through the largest gap between those two paths that has ever existed, and most people are sprinting down the wrong one with a faster engine.
What complexity quietly costs
The bill for sophistication does not arrive when you build it. It arrives later, in instalments, and it is always larger than it looked.
The first instalment is verification. A simple system you can hold in your head and check. A complex one you cannot, so you build monitoring to watch it, and the monitoring becomes its own system that can drift and mislead. Every layer you add is a layer you now have to confirm is still doing what you think it does, and the confirming never ends.
The second instalment is the day it breaks. A simple strategy fails legibly: you can see which rule was wrong and fix it. A sophisticated one fails in the seams between its parts, at the worst possible moment, in a way no single person fully understands. The elaborate model that printed money for two years becomes, in the drawdown, a black box nobody can debug while it is bleeding. Complexity does not only add capability. It adds failure modes that stay hidden until the system is under stress, which is the exact moment you have no spare capacity to handle them.
The deepest cost is fragility to your own success. A strategy with many parameters has many surfaces the world can destabilise once it starts reacting to you. The more elaborate the machine, the more places reality can reach in and pull a lever you forgot you had wired up. Simple, constrained systems survive contact with the world because there is less of them to break.
Sophistication is a loan against your future attention, taken out at a rate you cannot see until the system is under stress and the whole balance comes due at once.
Why we reach for sophistication anyway
If simplicity wins, why does almost everyone instinctively add complexity? Smart, capable people do it constantly, because the incentives reward it.
Every incentive in the room rewards the complexity you can show and punishes the discipline you cannot.
Sophistication is visible. A complex model, an elaborate architecture, a clever framework can be shown to a boss, a client, an investor, a peer. Discipline cannot be shown. Sitting in cash for three months, deleting half your code, pausing before you speak, refusing to ship the extra feature: none of it photographs well. The market pays for what it can see, and it can see complexity far more easily than it can see restraint.
Complexity also feels like work. Building an intricate system produces the sensation of progress all day long, even when the effort is going into the layer with the least leverage. Doing the boring, correct thing and then waiting produces the sensation of doing nothing, which the nervous system reads as failure. The feeling and the result point in opposite directions, and the feeling usually wins.
And an entire economy is built on convincing you the work is harder than it is. Every tool vendor, every course, every consultancy has a structural interest in making its domain look more complex than it needs to be, because simplicity is terrible for business. The people who write about a field emphasise its hardest parts, which is what makes them experts, rather than its simplest parts, which is what produces the results. The perceived difficulty of almost everything is inflated, and the inflation is nobody’s accident.
What the constrained version keeps proving
The clearest place to watch this play out right now is in how people use AI, because the tool is so powerful that the trap is stark.
The most effective way to get good work out of a frontier model is to take capability away from it. The prompts that consistently produce strong code are the ones that forbid things: no verbose comments, no scattered logging, small functions only, review your own output before returning it. The best debugging prompts are the most constrained ones: strict ordered steps, and a hard rule to verify before changing anything. The most powerful model on the planet does better work when you give it fewer options. People reach for AI expecting more power to mean more freedom. What it rewards is more power inside tighter constraints.
The same shape shows up wherever someone is quietly winning with powerful tools. The builders who ship profitable products solo run on deliberately boring technology, the kind a fashionable engineer would be embarrassed by. They ship ugly first versions fast while better-resourced teams are still choosing a framework. The plain name for what those teams are doing is over-engineering, and the powerful tools make it easier than ever. The people who learn fastest take fewer notes, not more. They delay and compress until a page of dense understanding replaces a folder of neat transcription. The creators who grow post less, because the algorithm rewards depth per post and punishes the volume that easy tools make tempting. Different fields, one lesson: the powerful tool is best spent removing steps.
The people quietly winning with the strongest tools are using them to do less, and to do it more reliably than anyone else.
None of these people are anti-technology. They are using the most powerful tools available. They are simply pointing them at the boring fundamentals and refusing the upgrade to a more complicated game.
The test that catches you in the act
The trap is hard to escape by intention alone, because it is driven by feeling, and the feeling does not announce itself as a bias. It announces itself as ambition. So you need a question sharp enough to cut through the feeling in the moment you are reaching for complexity.
When you catch yourself building something more sophisticated, ask: am I adding this because the problem genuinely requires it, or because the simple version feels uncomfortable?
If the honest answer is discomfort, you are in the trap. The simple version feels too easy, too exposed, too much like you are not earning your keep, so you reach for a layer that makes you feel substantial. That layer is where the cost lives.
The operational rule is narrow and worth memorising. Reduce complexity until the system is something you can verify, and not one notch past that. A simple strategy with strict rules and clean checks beats a sophisticated one you cannot fully see into, and the advantage grows the more powerful your tools become. When a strategy has more moving parts than you have the discipline or the data to support, the parts are not power. They are surface area for failure.
So the next time more compute, a better model, or a new tool lands in your hands, notice the instinct to finally build the elaborate thing you have been wanting to build. That instinct is the trap closing. The tool should be powerful. The strategy it serves should be almost embarrassingly simple. And the discipline that holds the two together should be boring enough that nobody, including you, finds it impressive.
That last part is why it works. The edge is boring on purpose, which is exactly why it is still available.
What is the most sophisticated thing in your current setup, and what would happen if you deleted it?
New to The Durability Curve? It is a standing argument about what survives when the tools get powerful and the surface gets cheap. Subscribe for the rest, or start with what survives.