AI-Assisted Trading Strategy Development Lifecycle¶
Series: The Intelligent Assistant (Article 12 of 13) Author: Bert Frichot Category: Trading Audience: Traders, Quant Developers Difficulty: Advanced Reading Time: 28 minutes Word Count: ~7,000
Abstract¶
How we built a systematic 7-stage trading strategy development lifecycle with AI assistance: from idea validation through backtesting, paper testing, and live deployment. This article covers the skills, state machines, and automated workflows that prevent the common pitfall of skipping paper testing—with real production code and actual implementation details.
1. The Strategy Development Problem¶
1.1 Common Failure Patterns¶
Most retail trading strategies fail for predictable reasons:
- Skipping Paper Testing: "Backtest looks great, let's go live!"
- Overfitting: Optimizing until the equity curve looks perfect
- No Stop Losses: "I'll manually exit if it goes bad"
- Unclear Edge: Cannot articulate why strategy works
- Deploy and Forget: No ongoing monitoring
The result: Strategies that look profitable on paper lose money in production.
1.2 The Solution: Systematic Lifecycle¶
We built a 7-stage lifecycle enforced by AI skills:
SCANNING → SETUP_DETECTED → ENTRY_APPROVED → ORDER_PLACED
↓
CLOSED ← ORDER_CLOSING ← EXIT_TRIGGERED ← HOLDING ← FILLED
Each stage has: - Gate conditions (must pass to proceed) - AI validation (skills enforce rules) - State machine enforcement (prevents invalid transitions)
Key principle: The AI assistant refuses to skip stages. Period.
2. The 7-Stage Lifecycle¶
2.1 Overview¶
| Stage | Duration | Purpose | Gate Condition |
|---|---|---|---|
| 1. Idea Validation | 30 min | Clarify hypothesis | Edge explanation exists |
| 2. Specification | 1-2 hr | Document rules | Entry/exit unambiguous |
| 3. Backtesting | 2-4 hr | Historical validation | Sharpe >2.0, Win Rate >35% |
| 4. Optimization | 1-2 hr | Parameter tuning | Out-of-sample validation |
| 5. Paper Testing | 24-48 hr | Live market validation | No critical bugs |
| 6. Go/No-Go Decision | 30 min | Systematic evaluation | All criteria pass |
| 7. Live Deployment | Ongoing | Monitored rollout | User approval |
Total: 3-5 days minimum (including paper test period).
2.2 Stage 1: Idea Validation¶
Purpose: Quickly determine if idea is worth pursuing.
# Strategy Idea: Micro-Cap Momentum
**Hypothesis**: Micro-cap stocks with volume spikes and earnings catalysts
exhibit momentum that persists for 2-5 days.
**Why This Edge Exists**:
- Institutional investors cannot trade micro-caps (position limits)
- Information flows slowly to retail traders
- Short-term momentum from catalyst creates entry window
**Entry Logic**:
1. Volume > 1.5x 20-day average
2. RSI(14) > 60
3. Price above 200-day SMA
4. Recent catalyst (earnings, FDA, contract)
**Exit Logic**:
- Stop loss: 3x ATR below entry
- Profit target: 3x ATR above entry
- Time stop: 5 days maximum hold
**Feasibility**: ✅ PROCEED
- Data available (Alpaca provides bars)
- Platform supports (paper trading available)
- Transaction costs manageable (commission-free)
Red Flags That Stop the Process: - ❌ Cannot explain WHY edge exists - ❌ Required data unavailable - ❌ Transaction costs eat profit - ❌ Edge explanation is circular ("works because it works")
2.3 Stage 2: Specification¶
Purpose: Document complete strategy logic before coding.
# Strategy Specification: Micro-Cap Momentum
## Entry Rules (ALL must be true)
1. **Volume Confirmation**:
- Today's volume > 1.5 × SMA(20) volume
- Ensures institutional interest
2. **Momentum Confirmation**:
- RSI(14) > 60
- Price > SMA(20)
- 7-day gain > 5%
3. **Trend Filter**:
- Price > SMA(200)
- Ensures long-term uptrend
4. **Volatility Filter**:
- ATR% < 5% of price
- Avoids hyper-volatile penny stocks
## Exit Rules
### Stop Loss (Non-negotiable)
- Price: Entry - (3 × ATR)
- Type: Stop market order
- Timing: Placed immediately after fill
### Profit Target
- Price: Entry + (3 × ATR)
- Type: Limit order (bracket)
### Time Stop
- Max holding: 5 trading days
- Action: Market sell at close
## Risk Parameters
- Max position size: $1,000
- Max portfolio allocation: 20%
- Max concurrent positions: 5
- Daily loss limit: $500
## Success Criteria (Backtest)
| Metric | Target |
|--------|--------|
| Sharpe Ratio | ≥2.0 |
| Win Rate | ≥35% |
| Max Drawdown | ≤25% |
| Trade Count | ≥100 |
| Profit Factor | ≥1.5 |
Review Checklist: - [ ] Entry logic is unambiguous - [ ] Exit logic covers all scenarios - [ ] Risk parameters are specific - [ ] Success criteria are measurable
3. Backtesting Infrastructure¶
3.1 Strategy Tester Tool¶
Our strategy_tester.py provides interactive backtesting:
class StrategyTester:
def __init__(self, env_file=None):
"""Initialize with paper trading credentials."""
# Use PAPER credentials only
self.api_key = os.getenv('ALPACA_PAPER_API_KEY')
self.api_secret = os.getenv('ALPACA_PAPER_SECRET_KEY')
# Initialize clients
self.trading_client = TradingClient(
self.api_key,
self.api_secret,
paper=True # Always paper for testing
)
def calculate_atr(self, bars, period=14):
"""
Calculate Average True Range (ATR) - Measures volatility.
Higher ATR = more volatile stock.
"""
true_ranges = []
for i in range(1, len(bars)):
high = float(bars[i].high)
low = float(bars[i].low)
prev_close = float(bars[i-1].close)
# True Range = max of:
# 1. Current High - Current Low
# 2. abs(Current High - Previous Close)
# 3. abs(Current Low - Previous Close)
tr = max(
high - low,
abs(high - prev_close),
abs(low - prev_close)
)
true_ranges.append(tr)
return sum(true_ranges[-period:]) / period
Key insight: ATR-based stops adapt to each stock's volatility rather than using fixed percentages.
3.2 Enhanced Momentum Strategy¶
The actual implementation with all filters:
def strategy_momentum(self, symbol, position_size=100):
"""
Momentum Strategy (Enhanced with ATR & Volatility Filters):
Entry Criteria:
- Price ABOVE 200-day SMA (long-term uptrend)
- RSI > 60 (strong momentum)
- Price above 20-day SMA (short-term uptrend)
- Recent gains > 5%
- ATR% < 5.0% (not too volatile)
Exit: ATR-based stops (3x ATR)
"""
# Get extended data for 200-SMA
bars = self.get_stock_data(symbol, days=250)
# Calculate indicators
rsi = self.calculate_rsi(bars)
sma_20 = self.calculate_sma(bars, 20)
sma_200 = self.calculate_sma(bars, 200) # Long-term trend
atr = self.calculate_atr(bars, 14)
atr_pct = self.calculate_atr_percent(bars, 14)
# Recent performance
price_7d_ago = float(bars[-7].close)
gain_7d = ((current_price - price_7d_ago) / price_7d_ago) * 100
# Check signals
buy_signal = (
current_price > sma_200 and # Long-term uptrend
atr_pct < 5.0 and # Not too volatile
rsi > 60 and # Strong momentum
current_price > sma_20 and # Short-term uptrend
gain_7d > 5 # Recent hot stock
)
if buy_signal:
# ATR-based risk/reward
stop_price = current_price - (3 * atr)
target_price = current_price + (3 * atr)
return self._execute_order(symbol, qty, OrderSide.BUY, atr=atr)
3.3 Order Execution with Bracket¶
All orders include stop loss and profit target:
def _execute_order(self, symbol, qty, side, strategy_name, atr=None):
"""Execute a market order with bracket (stop loss + take profit)."""
current_price = self.get_current_price(symbol)
if atr and atr > 0:
# ATR-based stops (3x ATR)
stop_loss_price = round(current_price - (3 * atr), 2)
take_profit_price = round(current_price + (3 * atr), 2)
else:
# Fallback to fixed percentage
stop_loss_price = round(current_price * 0.95, 2)
take_profit_price = round(current_price * 1.10, 2)
order_request = MarketOrderRequest(
symbol=symbol,
qty=qty,
side=side,
time_in_force=TimeInForce.DAY,
order_class=OrderClass.BRACKET,
stop_loss=StopLossRequest(stop_price=stop_loss_price),
take_profit=TakeProfitRequest(limit_price=take_profit_price)
)
return self.trading_client.submit_order(order_request)
Critical: The bracket order ensures stop loss is placed atomically with entry. No separate order, no chance of forgetting.
4. Paper Testing: The Non-Negotiable Stage¶
4.1 Why Paper Testing Is Mandatory¶
The paper-test-strategy skill enforces a minimum 24-48 hour paper test:
**Safety Rules I Enforce**:
- ❌ NEVER skip paper testing (no exceptions)
- ❌ NEVER deploy to live without 24hr minimum observation
- ❌ NEVER proceed if critical bugs found
- ✅ ALWAYS wait for minimum 5 trades in paper
- ✅ ALWAYS document issues discovered
- ✅ ALWAYS start live with smaller sizes (50% of paper)
The AI assistant will refuse to help deploy to live without completing paper testing.
4.2 Paper Test Workflow¶
The skill guides through an 8-step process:
# Step 1: Review strategy code
ls -la unified_api/strategies/
# Step 2: Run unit tests
pytest tests/test_*strategy*.py -v
# Step 3: Run backtest (must pass)
uv run python3 tools/strategy_tester.py \
--strategy micro_cap \
--start 2024-01-01 \
--end 2024-10-31
# Step 4: Configure paper environment
grep ALPACA_PAPER .env
docker exec trading-redis redis-cli SET capital:micro_cap:available 19800
# Step 5: Deploy to paper
launchctl load ~/Library/LaunchAgents/com.trading.micro_cap_paper_trader.plist
# Step 6: Monitor execution (24-48 hours)
tail -f /tmp/micro_cap_paper_trader.log
# Step 7: Daily review
uv run python3 tools/portfolio_fetcher.py --paper --history
# Step 8: Validation checklist
# All 8 boxes must be checked to proceed
4.3 Validation Checklist¶
After 24-48 hours, verify ALL criteria:
- [ ] No critical errors in logs
- [ ] Stop losses executed correctly
- [ ] Position sizing within limits
- [ ] Win rate within ±5% of backtest
- [ ] No unexpected behaviors
- [ ] Risk constraints enforced
- [ ] API integration stable
- [ ] Minimum 5 trades executed
All boxes must pass to get GO recommendation.
4.4 Paper Test Report Output¶
{
"strategy": "micro_cap_momentum",
"test_duration_hours": 48,
"backtest_metrics": {
"sharpe_ratio": 2.35,
"win_rate": 0.38,
"max_drawdown": 0.22
},
"paper_metrics": {
"trades_executed": 5,
"win_rate": 0.40,
"realized_pnl": 125.50,
"stop_losses_triggered": 3,
"profit_targets_hit": 2
},
"validation": {
"no_critical_errors": true,
"stop_losses_working": true,
"win_rate_matches_backtest": true
},
"recommendation": "GO",
"reasoning": "All validation criteria passed."
}
5. Trade State Machine¶
5.1 Why State Machines Matter¶
Without state machines, invalid operations are possible:
# ❌ BAD: Can skip steps
trade.place_order() # But setup wasn't validated!
trade.close() # But order wasn't filled!
# ✅ GOOD: State machine enforces order
trade.detect_setup() # SCANNING → SETUP_DETECTED
trade.approve_entry() # SETUP_DETECTED → ENTRY_APPROVED
trade.place_order() # ENTRY_APPROVED → ORDER_PLACED
5.2 Trade State Machine Implementation¶
class TradeState(Enum):
"""Trade lifecycle states."""
SCANNING = "SCANNING"
SETUP_DETECTED = "SETUP_DETECTED"
ENTRY_APPROVED = "ENTRY_APPROVED"
ORDER_PLACED = "ORDER_PLACED"
FILLED = "FILLED"
HOLDING = "HOLDING"
EXIT_TRIGGERED = "EXIT_TRIGGERED"
ORDER_CLOSING = "ORDER_CLOSING"
CLOSED = "CLOSED"
class TradeStateMachine:
"""
State machine for trade lifecycle management.
Enforces valid state transitions and tracks trade data.
"""
def __init__(self, symbol: str, trace_id: Optional[str] = None):
self.symbol = symbol
self.trace_id = trace_id or f"trade-{symbol}-{datetime.now().timestamp()}"
self.state = TradeState.SCANNING
self.data = TradeData(symbol=symbol)
def _validate_transition(self, target_state: TradeState):
"""Validate that transition to target state is allowed."""
valid_transitions = {
TradeState.SCANNING: [TradeState.SETUP_DETECTED],
TradeState.SETUP_DETECTED: [TradeState.ENTRY_APPROVED],
TradeState.ENTRY_APPROVED: [TradeState.ORDER_PLACED],
TradeState.ORDER_PLACED: [TradeState.FILLED],
TradeState.FILLED: [TradeState.HOLDING],
TradeState.HOLDING: [TradeState.EXIT_TRIGGERED],
TradeState.EXIT_TRIGGERED: [TradeState.ORDER_CLOSING],
TradeState.ORDER_CLOSING: [TradeState.CLOSED],
TradeState.CLOSED: []
}
allowed = valid_transitions.get(self.state, [])
if target_state not in allowed:
raise InvalidTransitionError(
f"Invalid transition: {self.state.value} → {target_state.value}"
)
Invalid transitions raise exceptions before any action is taken.
5.3 Complete Trade Lifecycle Example¶
# Initialize trade
trade = TradeStateMachine(symbol="AAPL", trace_id="trade-123")
# Scan → Setup (entry identified)
trade.detect_setup(entry=175.50, stop=166.72, target=201.82)
# Setup → Approved (risk management passed)
trade.approve_entry(quantity=5)
# Approved → Order Placed (broker acknowledged)
trade.place_order(order_id="order-abc")
# Order Placed → Filled (execution confirmed)
trade.filled(fill_price=175.50)
# Filled → Holding (stop loss set)
trade.set_holding()
# Holding → Exit Triggered (target hit!)
trade.trigger_exit(reason="TARGET_HIT")
# Exit Triggered → Closing (exit order placed)
trade.place_exit_order(order_id="order-xyz")
# Closing → Closed (final settlement)
trade.closed(exit_price=201.82)
# Get final P&L
print(f"P&L: ${trade.data.pnl:.2f}") # +$131.60
5.4 Trade Data Tracking¶
Each trade carries complete history:
@dataclass
class TradeData:
"""Trade data associated with state machine."""
symbol: str
entry_price: Optional[float] = None
stop_price: Optional[float] = None
target_price: Optional[float] = None
quantity: Optional[int] = None
entry_order_id: Optional[str] = None
exit_order_id: Optional[str] = None
fill_price: Optional[float] = None
exit_price: Optional[float] = None
exit_reason: Optional[str] = None # TARGET_HIT, STOP_HIT, TIME_STOP
pnl: Optional[float] = None
pnl_pct: Optional[float] = None
state_history: list = field(default_factory=list)
Every state transition is recorded for audit trail.
6. The Strategy Workshop Skill¶
6.1 Interactive AI Guidance¶
The strategy-workshop skill provides step-by-step guidance:
## What I Do
I guide you through the complete trading strategy development
lifecycle with a systematic, repeatable process. I prevent
skipping critical steps, validate assumptions, and ensure
every strategy meets quality standards before risking capital.
## When to Use Me
- New strategy idea - Need to validate and implement
- Strategy modification - Need to revalidate
- Strategy underperforming - Diagnose fix vs abandon
- Before live deployment - Final validation checklist
6.2 Gate Conditions¶
Each stage has explicit gates:
## Stage 3: Backtesting
**Required Metrics** (must meet ALL criteria):
- Sharpe Ratio: ≥2.0
- Win Rate: ≥35%
- Max Drawdown: ≤25%
- Avg Win/Loss Ratio: ≥1.5
- Total Trades: ≥20
**Red Flags**:
- ❌ Sharpe <1.5 (not worth the risk)
- ❌ Win rate <30% (psychologically hard to trade)
- ❌ Max drawdown >20% (too volatile)
- ❌ Trade count <50 (not enough data)
6.3 Optimization Without Overfitting¶
# Walk-Forward Analysis (prevents overfitting)
train_period = "2020-2022"
test_period = "2023"
# Optimize on training period
optimal_params = optimize(train_period)
# Validate on out-of-sample period
results = validate(optimal_params, test_period)
# Only proceed if out-of-sample performance matches
if results.sharpe < 0.8 * backtest.sharpe:
print("❌ Strategy may be overfitted")
Anti-Overfitting Rules: - ✅ Use walk-forward analysis - ✅ Limit parameters (fewer = less overfitting) - ✅ Use round numbers (RSI 30 vs RSI 28.73) - ❌ Don't optimize until "perfect" - ❌ Don't add parameters for single bad trade
7. Go/No-Go Decision Framework¶
7.1 Evaluation Matrix¶
| Criterion | Target | Actual | Pass? |
|-----------|--------|--------|-------|
| Backtest Sharpe | >2.0 | 2.35 | ✅ |
| Backtest Win Rate | >35% | 38% | ✅ |
| Backtest Max DD | <15% | 12% | ✅ |
| Paper Test Duration | >24h | 48h | ✅ |
| Paper Test Execution | 0 errors | 0 | ✅ |
| Paper vs Backtest | Within 20% | 5% | ✅ |
| Risk Management | Stops working | Yes | ✅ |
| Psychological | Handle max DD | Yes | ✅ |
7.2 Decision Rules¶
**GO**: All criteria pass, no red flags
**GO with modifications**: Minor issues, plan to address
**NO-GO**: Any critical failure
7.3 Decision Document¶
# Go/No-Go Decision: Micro-Cap Momentum
**Date**: 2025-11-04
**Decision**: GO
## Evaluation Summary
- Backtest: ✅ All criteria met (Sharpe 2.4, Win Rate 42%)
- Paper Test: ✅ Successful (48h, 7 trades, 0 errors)
- Risk Management: ✅ Stop losses working
- Edge Clarity: ✅ Clear hypothesis
- Psychological: ✅ Comfortable with 12% max drawdown
## Next Actions
1. Deploy to live with 50% of paper size
2. Monitor daily for first week
3. Review at day 7 before increasing size
8. Daily Trading Reports¶
8.1 End-of-Day Analysis¶
The daily-trading-report skill generates comprehensive EOD reports:
# Daily Trading Report - 2025-11-04
## Summary
- **Net P&L**: +$1,247.50 (+6.3%)
- **Realized**: +$1,287.00
- **Unrealized**: -$39.50
- **Trades**: 5 executed (3 wins, 1 loss, 1 open)
- **Win Rate**: 75.0%
- **Sharpe Ratio**: 2.41 (30-day rolling)
## Trades Executed
| Time | Symbol | Side | Qty | Price | P&L | Status |
|------|--------|------|-----|-------|-----|--------|
| 09:35 | PLTR | BUY | 50 | $19.80 | - | FILLED |
| 10:12 | PLTR | SELL | 50 | $20.45 | +$32.50 | FILLED |
| 11:45 | IONQ | BUY | 100 | $8.20 | - | FILLED |
| 14:30 | IONQ | SELL | 100 | $8.35 | +$15.00 | FILLED |
| 15:15 | MARA | BUY | 30 | $18.50 | - | FILLED |
## Risk Status
- **Capital Used**: $555 / $19,800 (2.8%)
- **Stop Losses**: 1/1 active ✅
- **Risk Limits**: All respected ✅
8.2 Report Generation Workflow¶
# Step 1: Calculate P&L
uv run python3 check_yesterday_pnl.py
# Step 2: Extract trades from logs
tail -200 /tmp/micro_cap_paper_trader.log | grep -E "BUY|SELL|FILLED"
# Step 3: Review positions
uv run python3 tools/portfolio_fetcher.py
# Step 4: Check risk status
docker exec trading-redis redis-cli GET capital:micro_cap:used
# Step 5: Generate report
# Report saved to:
# ~/Documents/memory/entities/lessons/trading/daily-reports/2025-11-04.md
8.3 Auto-Indexing¶
Reports are automatically indexed to Qdrant:
# Searchable by date, P&L, symbols, or observations
uv run python3 tools/query_memory.py "daily report 2025-11-04"
# Find winning trades
uv run python3 tools/query_memory.py "trades with profit target hit"
# Review strategy performance over time
uv run python3 tools/query_memory.py "micro-cap momentum performance"
Pattern matching over time enables learning from historical performance.
9. Multi-Agent Trading Architecture¶
9.1 Agent Boundaries¶
Each agent has single responsibility:
┌─────────────────────────────────────────────────────────────────┐
│ Message Bus (Redis) │
└────┬──────────┬──────────┬──────────┬──────────┬───────────────┘
│ │ │ │ │
┌────▼───┐ ┌────▼────┐ ┌───▼───┐ ┌────▼───┐ ┌────▼─────┐
│Market │ │ Order │ │Strategy│ │ Risk │ │Position │
│ Data │ │Execution│ │ Agent │ │ Agent │ │Management│
│ Agent │ │ Agent │ │ │ │ │ │ Agent │
└────────┘ └─────────┘ └────────┘ └────────┘ └──────────┘
9.2 Message Flow Example¶
1. StrategyAgent: strategy.candidate_found (AAPL setup detected)
2. RiskAgent: risk.calculate_size → risk.size_calculated (5 shares)
3. RiskAgent: risk.approve_trade → risk.trade_approved
4. OrderAgent: order.submit → order.submitted
5. OrderAgent: order.filled
6. PositionAgent: position.track → position.opened
7. PositionAgent: position.set_stop → position.stop_set
9.3 Circuit Breakers¶
API failures are handled gracefully:
# Circuit breaker configuration
ALPACA_BREAKER = CircuitBreaker(
failure_threshold=3, # 3 failures
timeout=60, # 60s recovery
half_open_requests=1 # 1 test request
)
# Usage
@ALPACA_BREAKER.protect
def get_quote(symbol):
return alpaca_client.get_latest_quote(symbol)
State: CLOSED → OPEN (after failures) → HALF-OPEN (test) → CLOSED
10. Common Mistakes and Solutions¶
10.1 Skipping Paper Testing¶
Mistake: "Backtest looks great, let's go live!"
Solution: AI skill refuses to help with live deployment:
10.2 Overfitting to Backtest¶
Mistake: Optimizing until equity curve is perfect.
Solution: Walk-forward analysis required:
# WRONG: Optimize on all data
best_params = optimize(all_data)
# RIGHT: Optimize on training, validate on test
train_params = optimize(training_data)
out_of_sample = validate(train_params, test_data)
10.3 No Stop Loss¶
Mistake: "I'll manually exit if it goes bad."
Solution: Bracket orders enforce automatic stops:
order_request = MarketOrderRequest(
order_class=OrderClass.BRACKET,
stop_loss=StopLossRequest(stop_price=stop_loss_price),
take_profit=TakeProfitRequest(limit_price=take_profit_price)
)
10.4 Unclear Edge¶
Mistake: Cannot explain why strategy works.
Solution: Stage 1 gate condition:
❌ Red Flag: Edge explanation is vague or circular.
Must articulate:
- Market condition creating opportunity
- Why edge exists
- How sustainable the edge is
10.5 Deploy and Forget¶
Mistake: No ongoing monitoring after deployment.
Solution: Daily trading report skill:
**Best Practices**:
- Run every trading day at market close
- Document even "no trades" days
- Record losses accurately (learning opportunity)
- Always include actionable recommendations
11. Results and Metrics¶
11.1 Strategy Success Rates¶
Strategies completing all 7 stages: - 70%+ profitable in first month - Average Sharpe: 2.1 - Average Win Rate: 42% - Max Drawdown: <15%
Strategies skipping stages: - 30% profitable in first month - Common failure: Stop loss not set correctly
11.2 Time Investment¶
| Stage | Time | Value |
|---|---|---|
| Idea Validation | 30 min | Prevents wasted effort |
| Specification | 1-2 hr | Eliminates ambiguity |
| Backtesting | 2-4 hr | Historical validation |
| Optimization | 1-2 hr | Parameter robustness |
| Paper Testing | 24-48 hr | Live market validation |
| Go/No-Go | 30 min | Systematic decision |
| Total | 3-5 days | Production-ready strategy |
11.3 Lesson Learned¶
2025-10-27 "Mystery Trade" Incident: - Trade appeared with no audit trail - Took 2 hours to reconstruct what happened - Root cause: State machine not enforced
Fix: All trades now flow through TradeStateMachine with complete history:
Conclusion¶
Systematic strategy development with AI assistance delivers:
- No Skipped Steps: Skills enforce lifecycle stages
- Objective Decisions: Gate conditions are measurable
- Audit Trail: State machines track every transition
- Ongoing Monitoring: Daily reports enable pattern learning
- Risk Management: Bracket orders guarantee stop losses
Key insight: The AI assistant's value isn't just generating strategies—it's enforcing discipline that humans struggle to maintain.
Series Navigation: - Previous: Article 11 - Aurora Architecture Patterns - Current: Article 12 - Strategy Development Lifecycle - Next: Article 13 - Documentation as Living Code - Prerequisites: Articles 8, 10