I was reading Mike Bellafiore’s The Playbook recently when I came across this line: “Elite traders don’t rely on instinct. They rely on the Playbook they’ve built — every setup documented with entry conditions, context, and exit logic. Instinct is just a bad Playbook by another name.”
I sat with that page for a while.
Not because it was impressive — but because I suddenly realized that the 72-cell Regime Grid trading system J designed for me is fundamentally doing the same thing. We just wrote it in code instead of a notebook.
What Bellafiore Actually Means by “Playbook”
Bellafiore makes one point over and over in the book: the edge of a professional trader comes from how well they know their own setups, not how well they know the market.
The implication is straightforward. You don’t need to predict every move. You just need to know exactly what to do when your setup appears. Everything else, you can sit out.
That sounds simple. The hard part is execution — the human brain is wired to hunt for opportunity, and it will convince itself “this one feels close enough” at the worst possible moments. The Playbook externalizes a trader’s judgment framework into something checkable, rather than something felt.
There’s a detail in the book that stuck with me: new SMB traders don’t review how much they made at the end of the day. They check whether each trade matched their Playbook. Follow the Playbook and lose? Fine, keep going. Break the Playbook and make money? That still gets sent back for review.
That kind of clarity is rare.
What Our AI Playbook Looks Like
When J was designing the system, I wasn’t thinking about the Playbook framework at all. My problem was more concrete: crypto markets behave completely differently depending on conditions. Momentum strategies work when a trend is strong. Mean reversion makes more sense during consolidation. Risk parameters need to be different entirely during high volatility.
If you run one strategy regardless of regime, you’ll blow up in certain conditions — and then spend time wondering if the strategy itself is broken, when really the market environment just shifted.
J’s solution was to classify market states. Several dimensions describe the current regime: trend direction, volatility level, volume conditions, short-term momentum. Different combinations map to different cells — 72 in total. Each cell has its own entry and exit logic with its own risk parameters.
That’s the Regime Grid. 72 distinct market contexts, each running its own Playbook.
Not one strategy trying to handle every condition. 72 strategies each defending their own territory.
Setup Filtering: Not Every Cell Is Worth Running
The first thing Bellafiore emphasizes is selectivity — know which conditions your setup requires, and only act when those conditions are met.
Our version: every cell has a win rate threshold. When backtesting shows that certain market condition combinations are unstable or have too few samples, that cell stays empty. No strategy gets deployed there. J’s standard is that a setup has to clear a baseline win rate in backtesting before it even makes the candidate list.
The logic is identical to what Bellafiore describes: not “no opportunity,” but “this isn’t my setup.” If the conditions don’t match, the system doesn’t move.
I used to feel anxious on days when I hadn’t entered any trades — like I was missing something. Now it’s reversed. When the system doesn’t trigger any cells, I’m actually relieved. It means it’s holding discipline.
Regime Switching: Reading Context in Real Time
In manual trading, reading market context comes from staring at charts long enough to develop a feel. J turned that into an algorithm: every hour, the system calculates current market indicators, determines which Regime the market is in, and switches to the strategy for that cell.
This is exactly what Bellafiore calls “reading context” — you have to understand what kind of market you’re in before you can know whether your setup is valid.
The difference is that J automated it, removing my judgment from the loop. I used to misread downtrends as consolidation all the time, enter with a momentum strategy, and watch things go further south. Now the system makes the call. When context shifts, it switches. No hesitation. No “but it feels like it might be bottoming.”
Automated Review: Closing the Back Door on Self-Deception
The section of the book that hit hardest was Bellafiore’s point that reviewing trades isn’t about making traders feel bad — it’s about helping them understand when their Playbook works and when it breaks down. Without that feedback loop, you’re just repeating a process nobody actually knows is working.
Periodically, J runs a rolling win rate calculation across every Regime cell, comparing recent live performance against backtest expectations. If a cell’s actual win rate drops below a threshold, the system flags it and takes it offline until it’s revalidated.
That’s automated review. Nobody has to sit and watch every trade. The system audits its own execution quality.
This was actually harder to design than the trading logic itself — because you have to decide what counts as “degradation” versus “normal variance.” J adjusted that threshold quite a few times. Too strict and the system is constantly pausing. Too loose and the self-correction mechanism is meaningless.
The Book Was Written for Humans. The Logic Wasn’t.
Bellafiore wrote The Playbook with real traders in mind — people sitting at training desks. But the more I read, the more I felt that what he’s actually describing — selectivity, context reading, disciplined review — has nothing to do with being human.
These are the core principles that make any decision system work sustainably. Humans need a Playbook because the brain is too easy to convince. AI systems need a Playbook because without explicit rules, there are no rules.
Going around the long way, it turns out that designing a good AI quantitative trading system and training a good trader are solving the same fundamental problem.
That’s what I was thinking about late at night, somewhere between the last chapter and falling asleep.