Larry Williams' Conditional Trading: Essential Lessons for MQL5 Strategy Development

Introduction

Larry Williams, the legendary trader who turned heads with an incredible 11,000% return in the 1987 World Cup Trading Championships, has shared insights that can transform the way we build trading algorithms in MQL5. His philosophy of "conditional trading" takes us beyond basic buy/sell signals into a smarter, more structured approach.

The Foundation: Conditional Trading Philosophy

What Makes Williams Different?

While most traders rely on simple technical indicators, Williams focuses on conditions before signals. As he puts it: "Charts don't move the market, conditions drive prices."

This mindset should reshape how we build our MQL5 Expert Advisors. Here’s a quick comparison:

Traditional Approach:

// Simple moving average crossover
if (MA_Fast > MA_Slow)
    Buy();

Williams' Conditional Approach:

// Check conditions first, then look for signals
if (MarketCondition_Bullish() && Seasonal_Favorable() && COT_Bullish()) {
    if (MA_Fast > MA_Slow)
        Buy();
}

The "Combination Lock" Strategy

Williams compares trading to opening a combination lock—you need several conditions (like numbers) to line up in the right order to unlock a successful trade.

The Four Key Condition Categories:

1. Fundamental Conditions

• Market valuation (e.g., vs gold)
• Commitment of Traders (COT) data
• Seasonal trends
• Spread relationships

2. Technical Confirmation

• Price patterns
• Momentum indicators
• Trend confirmation

3. Market Structure

• Premium vs discount zones
• Accumulation/distribution phases
• Smart money behavior

4. Cyclical Analysis

• Long-term market cycles
• Intermediate patterns
• Historical analogs

Implementing COT Analysis in MQL5

Williams' use of COT data is legendary. Here’s how to integrate it into your code.

Key COT Concepts:

1. Understand Trader Types:

• Commercials = Smart money, buy weakness
• Large specs = Trend followers
• Small specs = Usually wrong at turning points

2. Context Is Everything:

• Always compare COT data with price levels
• Watch open interest and positioning shifts

3. Sample MQL5 Pseudo-code:

// COT-based condition checker
bool IsCOT_Bullish() {
    return (Commercial_NetLong > Threshold) &&
           (Large_Spec_NetShort > Threshold) &&
           (Price < Historical_Average);
}

Money Management: The Williams Way

The 2–4% Risk Rule

One of Williams’ golden rules: never risk more than 2–4% per trade. It’s simple, but powerful.

• At 10% risk, 4 bad trades = 50% drawdown
• At 2% risk, same losses = ~8% drawdown
• Small risks allow you to survive and thrive

MQL5 Function Example:

double CalculatePositionSize(double stopLoss, double riskPercent = 2.0) {
    double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
    double riskAmount = accountBalance * (riskPercent / 100.0);
    double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
    double stopLossPoints = stopLoss * Point();

    return NormalizeDouble(riskAmount / (stopLossPoints * tickValue), 2);
}

Indicator Philosophy: Quality Over Quantity

Williams' Rules for Indicators:

1. No Redundancy

• Don’t stack similar indicators (e.g., RSI + Stoch + CCI)
• Each one should do something unique

2. Purpose-Driven Selection

• Trend identification
• Accumulation/distribution
• Cycle/timing
• Market conditions

3. Avoid Over-Optimization
Williams warns: "I see people with 15 indicators... loser."

Market Structure: Tops vs Bottoms

Key Insights:

Market Tops (harder to catch):

• Formed by fundamentals
• Slow and subtle
• Use higher timeframes and caution

Market Bottoms (more technical):

• Driven by panic
• Fast and sharp
• Use technical tools for quick entries

// Strategy for tops and bottoms
if (LookingForTop()) {
    // Fundamental-based, conservative
} else if (LookingForBottom()) {
    // Technical-based, aggressive
}

Psychology and System Development

Confidence = Testing

1. Backtesting:

• Diverse market conditions
• Walk-forward testing
• Out-of-sample verification

2. Demo Trading:

• Feel the strategy emotionally
• Use it to tweak risk levels

3. Slow Scaling:

• Start small
• Increase gradually
• Only risk what you can handle emotionally

Sample MQL5 Framework

A Williams-Style EA Skeleton:

class ConditionalTradingEA
{
private:
   // Condition checkers
   bool CheckSeasonalCondition();
   bool CheckCOTCondition();
   bool CheckValuationCondition();
   bool CheckTechnicalCondition();

   // Risk management
   double CalculateRisk();
   bool ValidateRiskParameters();

   // Market structure analysis
   bool IsMarketInTrend();
   bool IsAccumulationPhase();

public:
   // Main trading logic
   void OnTick()
   {
      int conditionCount = 0;

      if(CheckSeasonalCondition()) conditionCount++;
      if(CheckCOTCondition()) conditionCount++;
      if(CheckValuationCondition()) conditionCount++;

      // Need at least 3 conditions
      if(conditionCount >= 3)
      {
         if(CheckTechnicalCondition())
         {
            ExecuteTrade();
         }
      }
   }
};

Key Takeaways for MQL5 Developers

1. Condition First, Signal Second – Always.
2. Confirm with Multiple Layers – Aim for 3–4 confirming conditions.
3. Manage Risk Like a Pro – Hard-code 2–4% max risk per trade.
4. Smart Indicator Use – Less is more, but make it meaningful.
5. Structure-Based Logic – Tops and bottoms behave differently.
6. Backtest, Forward Test, Repeat – Confidence comes from results.

Conclusion

Larry Williams’ approach gives us a powerful blueprint for building smarter EAs in MQL5. Focus on conditions first, manage your risk wisely, and use indicators with a clear purpose. Whether you’re coding your first bot or refining a complex system, these principles can boost your success rate dramatically.

Final takeaway from Larry himself: "Find a condition, find an entry, find the target, find the trailing stop."

"The more you know, the better you'll be… this is a knowledge-driven business." – Larry Williams