A mate's review · read it and weep

Your trading bot, reviewed 🐢

Had a proper poke through it. Good news — it's not going to rob you. Bad news — the number you keep quoting me has been quietly cooking the books, and I've got the receipts.

Straight up: the actual research is sharp — sharper than most of the stuff people pay real money for, so don't let the roast go to your head. But that headline return you've been flexing is flattered by three things, and every single one is sat in your own code. Patch them and it goes from "nice backtest, bruv" to something you could actually defend down the pub.

Will it rob me?

No — read-only

Is the research good?

Annoyingly, yes

Cooking the books?

In 3 spots

Dependencies

Zero — respect

01 Fair play — this bit's actually good

Credit where it's due, so the roast lands fair. Don't change any of this.

Zero dependencies, pure stdlib. No libraries to rot, runs anywhere. Genuine discipline — most people can't resist bolting on ten packages.
The survivorship rebuild is the real deal. Testing era-correct coin lists including dead ones like LUNA through the 2022 implosion (crypto_turtle_era.py) is exactly the thing that separates you from the "my backtest made 9000%" crowd. The edge surviving it (PF 1.72 vs 1.74) is your strongest card — lead with it.
The >70% jump guard (crypto_turtle_era.py:59) catching redenomination artifacts — sneaky-good touch.
Your "honest filter test" (crypto_turtle.py:112) — picking coins on old data, judging on new, and admitting the ones you binned still made money. That's honesty most quants would quietly bury.

So yeah — you clearly know what you're doing. Which is exactly why the next bit is embarrassing. 😏

02 Where it's cooking the books

Three things, all in your code, all inflating the number you keep sending me.

● busted

Your flagship number pretends trades never pile up

You literally wrote a concurrency cap — MAX_CONCURRENT = 5 in crypto_trend.py:33 — and then forgot to put it in the Turtle engine. So crypto_turtle.py:71 compounds every trade like you only ever hold one position at a time. Mate, that +2,676% ran through the engine that ignores 40 coins mooning at once — which is the exact drawdown risk your own notes flag. Copy your cap over and re-run it. I'll wait.

● busted

Your "t = +7" is fool's gold

You're counting ~3,900 trades like they're all independent (crypto_turtle.py:88). It's crypto — when Bitcoin sneezes the whole book catches a cold. Thirty alts trending together isn't 30 bets, it's basically one. So that "seven sigma" is nowhere near seven. Cluster the trades by week, bootstrap the daily returns, or do a Deflated Sharpe that also docks you for all the variants you tried — that's the honest headline stat, and it'll be a lot humbler.

● busted

Your costs are wearing rose-tinted glasses

Flat spread of 0.12% (crypto_turtle.py:37) — and your two engines don't even charge the same fees. Breakout entries fill worse than that (you're buying into a rip), and you've modelled zero funding on shorts — a short that rides for a fortnight bleeds funding every 8 hours. Add real taker fees + slippage + funding carry and watch the short book get a lot less pretty.

03 How I'd rebuild it

Right now every script is a monolith doing everything at once, your two Turtle files are ~80% copy-paste waiting to drift, and your coin list is hardcoded in four places that already disagree — trend runs 20 coins, turtle runs 40. Split it up:

crypto-lab/
  config/
    universes.yaml     # ONE coin list, not four that argue
    costs.yaml         # fees / slippage / funding, per venue
    runs/turtle.yaml   # a run manifest = reproducible result
  cryptolab/
    data.py            # fetch + load + sanity checks
    indicators.py      # atr / ema / swings   (with TESTS)
    engine.py          # ONE event loop, all strategies
    strategies/*.py    # signal only, nothing else
    portfolio.py       # the cap + sizing (used EVERYWHERE)
    stats.py           # PF, clustered t, deflated Sharpe
    report.py          # stamps each run w/ config hash + git SHA

The payoff: fix the cap once in portfolio.py and every strategy inherits it. And with run manifests, every number in your PROGRESS.md becomes "here's the config, re-run it yourself" instead of "trust me bro."

04 Bits you just… left in there

● tidy up

crypto_trend.py:40 — there's a spread_of() function full of forex stuff (gold, S&P, oil, JPY) sat in your crypto engine. It's also completely dead — you compute the real spread 40 lines later. It does nothing but look confused.
crypto_trend.py:138 — a comment about "OANDA daily bars completing at 17:00 New York" and a date-minus-2 fudge. That's forex market hours copy-pasted into a 24/7 crypto engine, where it's flat wrong — crypto candles close at 00:00 UTC. That lag could be quietly misaligning your trend filter.
fetch_crypto.py:11 — you define a coin list, then redefine it three lines down. The first one and the "DONE" set are dead. Housekeeping.

05 Order I'd do it in

P0 stop flattering the number

Put the concurrency cap in the Turtle engine and re-run.
Fix the significance stat (cluster / bootstrap / deflated Sharpe).
Real costs incl. funding on shorts.

P1 make it reproducible

One config for coins + costs — kill the four-way split.
Run manifests → stamped reports for every result.
Merge the two Turtle files; fix the 24/7 lag bug.

P2 go deeper

Size by portfolio risk, not a flat 0.25% per coin (your real DD fix).
Walk-forward as the default report.
Actual tests so a refactor can't silently break the maths.

06 Before you remortgage the house

All of that makes the research better — it still doesn't make it live money. Even a clean, cost-stressed edge gets chewed up by real slippage, funding and latency (and that DEX counterparty risk you already clocked). So after P0–P1: paper-trade it small first and measure how far real fills drift from the backtest, before a single quid of size. Your "gauntlet" instinct is bang on — this just makes the gauntlet meaner.

07 "Copy your cap over and re-run it. I'll wait." — update: I lied, I didn't wait

You didn't patch it. So I did — all three, in your own engine, on your own data. Recorded entry dates so a cap could even be applied, lifted your MAX_CONCURRENT into a shared portfolio.py, added real costs (fee + slippage + funding) and swapped the fool's-gold t-stat for a clustered-t, a block-bootstrap and a proper Deflated Sharpe. Pure stdlib, nothing to install. Every number below is reproduced — unzip it and run it yourself.

What happens when you stop flattering it — the flagship (40-coin Turtle)

each row adds one honesty fix	9yr return	maxDD	PF
as you reported it	+2,676%	25.8%	1.74
+ realistic costs (fee+slip+funding)	+1,820%	30.4%	1.64
+ concurrency cap of 5 (your own trend-engine rule)	−10%	39.9%	0.95
sized sanely (0.10%/trade, keep every trade)	+235%	13.5%	1.64

And here's the tell you won't like: the return scales with how much stacking you allow. Cap 3 → −16%. Cap 5 → −10%. Cap 10 → +64%. Cap 20 → +347%. No cap → +2,676%. When a "strategy's" return is just a dial for how many correlated coins you hold at once, that's not alpha — it's leverage on one big bet against the dollar. Your survivorship version does the exact same thing (+366% → sized-real +71% at 5.5% DD).

Now the bit that vindicates you 🫡

I tried to kill the edge and couldn't. After proper costs, the per-trade edge passes everything:

Your "seven sigma" deflates to a clustered t of +2.7 to +3.3 — humbler, but still properly significant once correlated trades aren't counted as independent.
Block-bootstrap (2,000 resamples): P(the edge is ≤ 0) = 0.10%, profit-factor 90% CI [1.31, 2.00].
Deflated Sharpe = 100% — it survives even after I dock you for the ~12 variants you tried. That's the honest headline stat you were missing, and it's a pass.

So the real number is ~+235%/yr-basket over 9yr at ~13.5% drawdown — not +2,676%. A quarter of the flex, but it's a number you can say out loud without someone who does this for a living laughing at you. The research was always good. The headline was the only lie, and now it isn't one.

⬇ grab the patched engine (18 KB, zero deps)

Unzip over your repo → python analysis/crypto_turtle.py → scroll to the HONEST RE-RUN block. HONEST-FIXES.md inside has the full write-up and the before→after for both engines. Signal logic untouched — your original numbers still print, mine print underneath, so you can audit every downgrade.

Reviewed off your actual source · crypto_trend.py · crypto_turtle.py · crypto_turtle_era.py · fetch_crypto.py · fetch_era_coins.py · PROGRESS.md
Update: fixes implemented + reproduced on your data (pure stdlib, no code of yours changed except recording entry dates). Still a mate's opinion, not financial advice — and still not me being nice.