Between January 9 and January 30, 2026, our AI-assisted trading system had seven significant incidents. The same root patterns — silent fallbacks, unverified deployments, training/inference mismatches — kept recurring despite post-mortems and a growing LESSONS_LEARNED.md. The lessons existed. The enforcement mechanism didn't.

This post is about the documentation system that emerged from those failures. Not documentation in the wiki sense — a self-reinforcing system where every incident writes the rules that prevent the next one, and those rules are embedded in the tools that AI coding agents read at the start of every session.

Post 5 ended with a tease: "I'll go deeper on the documentation system in the next post, including why we built it, how it prevents the kind of knowledge loss that contributed to our $78K incident, and how it works with AI coding agents." Here's the full story.

I spent weeks training a single PPO agent to make portfolio decisions. It worked well in calm markets. Then VIX spiked from 14 to 22 and the model froze — its learned policy didn't generalize to a volatility regime it hadn't trained in.

This isn't a novel observation. Any quantitative researcher who's deployed a single model to trade across regimes has hit this wall. The issue isn't the algorithm. It's that markets have structural breaks — volatility regimes, sector rotations, macro shocks — and no single model captures all of them.

As a professional data scientist, I've spent years building ML models in Jupyter notebooks. But I wanted to go beyond research. I wanted to deploy a full-stack, production-grade AI trading system. The catch? I needed to supplement my data science expertise with full-stack development, infrastructure, and operations knowledge I didn't have.

Enter AI coding agents.

Over the past few months, I used LLMs (primarily Claude via Cursor) to build an automated trading system from scratch: FastAPI backend, Celery workers, Next.js frontend, PostgreSQL database, AWS infrastructure (ECS, SageMaker, EventBridge), and a complete ML pipeline for training and deploying models.

Seven posts on architecture, context management, testing, deployment, ML failures, and operational assumptions.

But here's the real question: Does the system actually work?

In this final post, I'll show you a week of paper trading performance—the proof that all those lessons, fixes, and patterns resulted in a functioning trading system.

Celery beat logs:

[2025-11-18 09:32:00] Sending task: check_stop_loss_take_profit
[2025-11-18 09:34:00] Sending task: check_stop_loss_take_profit
[2025-11-18 09:36:00] Sending task: check_stop_loss_take_profit

Jan 8: "RL model deployed to SageMaker endpoint. Trading with trained model."

Jan 9: "RL model is active and making portfolio decisions."

Jan 10-13: Portfolio trades every day. System reports "working."

I committed a critical fix at 5:51 PM. Pushed to GitHub. CI passed. Green checkmark.

At 6:15 PM, the bug was still happening.

Why? The Docker containers were still running the old code.

Every RL tutorial on the internet ends the same way: train PPO on CartPole, watch the reward curve go up, celebrate. Maybe they graduate to Atari and show you a DQN playing Breakout.

None of them prepare you for what happens when your action space has 25 continuous dimensions, your reward signal is delayed by days, and your agent discovers that the optimal policy is to buy everything and never sell.

Go read any ML trading tutorial online. It's always the same: download some OHLCV data, train a model, show a backtest chart that goes up and to the right, collect Medium claps.

Nobody talks about what happens when you try to run that model every single day. When you need to retrain monthly without breaking the thing that's already trading. When the feature your model was trained on doesn't exist at inference time. When your processing job takes 8 hours and your data is stale by the time training starts.

Here's a confession: when I started this project, I was way more interested in building something impressive than something that worked.

Multiple LLM agents coordinating decisions. A dozen strategies running in parallel. Complex fallback hierarchies. HuggingFace endpoints for model inference. It was beautiful on the whiteboard.