Research Peer Review and Code Review
Having a second person independently check both the reasoning behind a strategy and the code that implements it, before capital is committed — a habit borrowed from software engineering and academic peer review that catches errors a solo researcher is unlikely to catch in their own work.
A researcher who has spent weeks developing a strategy has a strong incentive, often unconscious, to see the result as good — they've invested effort in it, they want it to work, and by the time it's finished they've usually stopped questioning assumptions they made early on. This isn't dishonesty; it's a normal feature of working closely on something for a long time. A second person coming to the work fresh doesn't share that investment and is far more likely to notice the assumption that quietly doesn't hold, the parameter that was tuned a few too many times, or the line of code that does something subtly different from what the researcher believes it does.
Two different things being checked
Code review looks at the implementation: does this function actually do what the researcher intended, are there off-by-one errors in date alignment, does the backtest correctly avoid using future information. Research review, sometimes distinct from code review, looks at the reasoning: does the strategy have an economic rationale beyond "the backtest looked good," is the sample size long enough to trust the result, were reasonable robustness checks run, and is the writeup honest about the strategy's weaknesses and not just its strengths. Both matter, and a review process that only checks the code while taking the underlying logic on faith will still let through a strategy that is well-implemented but fundamentally spurious.
A concrete case
A researcher presents a strategy with an impressive backtested Sharpe ratio and a clean writeup. In review, a colleague asks a simple question: what's the economic reason this pattern should exist and persist, rather than just "it worked in the data"? The researcher, pressed, realizes the explanation they'd been giving themselves was mostly post-hoc — the parameters had actually been tuned after seeing several backtest results, not chosen up front for a principled reason. That's a red flag review is specifically designed to surface, and it likely wouldn't have come up if the researcher had simply kept refining the writeup alone.
What this means in practice
Effective review requires the reviewer to have enough context and independence to push back — a reviewer who is too junior, too rushed, or too deferential to the original researcher won't catch much. It also requires a culture where finding a problem in review is treated as the review working correctly, not as a failure by the researcher, since a review process people are afraid to fail in front of tends to become a rubber stamp rather than a genuine check.
An independent reviewer, checking both the code and the underlying reasoning of a strategy, catches the assumptions and errors that the original researcher is unlikely to notice in their own work precisely because they're too close to it.
Further reading
- Fowler, Refactoring, ch. 1 (on code review practice)