Putting My Actual Trades on the Chart: TradingView Remix + Claude Code

A trade review without a chart is just a spreadsheet apologizing for itself. I can read that my discipline was 4/10 and that I chased Microsoft below VWAP, but the lesson does not land until I see the arrows sitting on the candles where I actually clicked buy and sell. So I built that — two ways — and wired the whole thing into Claude Code so it happens as part of my daily review instead of as a chore I skip.

I keep my trading life in Notion: daily game plans, the daily trading journal, and the trader report card all live there. The missing piece was getting charts into those documents without hand-exporting screenshots every day. This is the story of that integration: TradingView Remix for the charts I mark up by hand, a data-driven pipeline for the charts that draw my fills automatically, and a hosting path on my own site so both kinds drop straight into Notion by URL.

Two kinds of trading chart

There are two charts I care about, and they have completely different jobs.

The game-plan chart is the one I think with. Levels, structure, the line in the sand where the thesis is wrong. This is human work — I want to draw on it, argue with it, mark the spot where I will get in. That is exactly what TradingView’s new Remix AI Chart Copilot is good at: I can ask it to label premarket highs, mark the 200-day, sketch the levels, and it does it on a real chart in my real session.

The review chart is the one I learn from. It is not about what I planned — it is about what I did. Where did the fills actually happen? Above or below VWAP? Did I add to a winner or average down a loser? That chart should not require any drawing at all, because the truth is already in the broker data. It should draw itself.

I stopped trying to make one tool do both.

The Remix side: driving my own browser

Remix runs as a browser extension in my logged-in TradingView session. The problem: my automation lives in WSL, and a headless robot browser does not have my TradingView login or my extensions. The fix turned out to be clean — Chrome’s remote debugging protocol.

I run a dedicated Chrome profile launched with --remote-debugging-port=9222, cloned from my real profile so the TradingView login and the Remix extension come along. From WSL, my tooling connects to that running browser over CDP and drives the real session — the same one with the copilot in it. I mark up a chart with Remix, say “capture it,” and the script screenshots that exact tab, uploads it to my site, and hands me back a URL I can paste into the day’s game plan in Notion.

A few things I learned the hard way, in case you try this:

• Chrome 136+ silently ignores the debug flag on your default profile. You need a separate --user-data-dir. It will look like it is working and simply not open the port.
• The WSL-to-Windows hop is not localhost. WSL’s resolv.conf nameserver is a virtual DNS address, not the host — use the default-route gateway, and forward the port through.
• Clone your profile rather than starting fresh, or you will be logging into everything again.

The payoff: the AI copilot stays a human-in-the-loop tool — I do the thinking and the marking — and the machine just handles capture and publishing. That division of labor matters. The copilot is not making trading decisions; it is making my charts faster to produce.

The review side: charts that draw my fills

For the review chart I went the other direction — no browser at all. My DAS Trader exports already contain every fill: timestamp, side, quantity, price. My market-data provider gives me the intraday candles. matplotlib does the rest.

The script pulls one-minute bars for the session, overlays VWAP, and drops a green up-arrow at every buy and a red down-arrow at every sell, at the actual fill price and time. Then it crops to the trade window so a five-minute scalp is not lost inside a full session, and titles the chart with the real execution count.

That last part bit me first, and it is a good lesson in fidelity. My first version used five-minute candles and a six-fill Microsoft trade rendered as “1 buy / 2 sell bars” — nonsense, because four of the six fills had collapsed into the same candle and overwrote each other. The fix was one-minute resolution and counting executions, not candles. Now the title reads “6 executions (3 buys / 3 sells)” and every fill is visible where it happened. The chart tells the truth about the trade, which is the only thing a review chart is for.

What is public and what is not

The charts are hosted on my own domain so Notion can embed them by URL — which means the image is publicly reachable, so I had to be deliberate about what goes out. My rule:

• Account dollars and account numbers are private. Published performance is expressed in R-units — risk-normalized, so I can share the quality of a decision without broadcasting my balance.
• Account IDs become labels. A chart says “live” or “swing,” never the real account number.
• Chart prices are fine. The market printed those prices for everyone; the teaching value is in where I entered relative to them.

The full-dollar version of every review goes to a private vault. The Notion journal that I share — the report card the community sees — carries the R-unit version. Same trade, same lesson, no overshare.

Why wire it into the AI at all

I could do all of this by hand. I would not. That is the real reason the integration matters: a review step that takes effort is a review step I skip on the days I most need it — the red ones. When the chart draws itself from my broker data, sanitizes itself, and drops into my Notion journal as a URL, the friction that used to kill the habit is gone.

AI did not make me a better trader. The discipline did. But the AI removed every excuse I had for not looking at the discipline — and on a 4-out-of-10 day, looking is the whole game.

David Duncan is a momentum trader, Fedora Cloud SIG contributor, and builder of AI-assisted trading infrastructure at davidduncan.org.