Disclosure: I use Strike Finance for copy trading, hold its token, and earn referral fees from Strike. I'm not affiliated with Strike. This article has no referral links, and the toolkit is free and MIT-licensed.
TL;DR
- Copying a trader doesn't give you the trader's results. In one week, the trader I copy lost about 4%, and my copy lost about 28%.
- So, I built Strike Copilot, a free toolkit that runs in Claude Code. You ask questions in plain English; it checks traders and replays them on your own settings.
- It can't place orders or withdraw, keeps your API key on your computer, and shows a dry run before every change.
- I ran it on the trader I copy myself. At 10x, the setting I use, the replay found 27 liquidations in 90 days; at 5x, 4, with more than double the profit.
- The main lesson: let scripts do the maths and let the AI explain it.
The Problem: A copy is a different trade.
Copy trading sounds simple. Find a good trader, copy them, get their results.
I've done it with my own money every day since late August, and the copy is never the same trade:
- Your leverage and margin, not theirs (by default). A trader using their whole account as collateral can sit through a dip that wipes out a copy with a fixed amount of margin.
- Your sizing. A copy is scaled to your account, not theirs.
- Your markets. You only get the trades on markets your copying venue lists.
- Your timing. Your copies fill seconds after theirs.
The week of 5 October showed how much this matters. The trader I copy lost about 4% of their account. My copy of them lost about 28%.
The venue, briefly.
Strike Finance is a perpetual futures exchange. Perpetual futures, or "perps", are leveraged bets on a price with no expiry date. Strike can copy any Hyperliquid wallet by address. Hyperliquid's positions and trades are public, so any wallet can be copied, and the trader doesn't have to sign up.
That makes choosing the trader the whole game. The usual tool for it, a leaderboard, answers the wrong question. It shows the trader's whole account. A copier only gets their perps trades on the markets Strike lists, after fees.
This week, someone in a trading Discord recommended a wallet with over $20M of all-time profit. On the markets a copier could actually follow, it was down about $3M since July.
How the toolkit is built.
It's a folder on your computer. There's no server and no tracking. It talks only to Strike's and Hyperliquid's public APIs, plus GitHub to check for updates and Strike's published API spec.
It has three parts:
- Skills. Markdown files that Claude Code loads when they're relevant. There are six: setup, sweep, check-trader, caps, apply-copy, and review. Each says what to run, how to explain the result, and what never to do.
- Scripts. Plain Python, with one extra package (
cryptography). They do the data work: fetching trades, replaying copies, scoring traders. CLAUDE.md. The rules for every conversation, such as "no orders" and "every change needs a yes."
The most useful design choice was keeping the AI out of the arithmetic. Claude picks the right script, reads its output, and explains it. Every number comes from a script, so it can be checked and it comes out the same each time.
Your API key never leaves your computer.
Strike's API uses a key pair: a private key that signs requests and a public key that Strike stores. Strike's website can create one for you, but then the private key sits in your browser, and you'd have to paste it into the tool.
Instead, the toolkit creates the key pair on your computer and shows you only the public half, which you paste into Strike yourself. The private key is saved in a hidden file only your user account can read, and it's never printed.
Each request is signed locally, like this:
message = METHOD:path:timestamp:nonce:sha256(body)
headers: X-API-Wallet-Public-Key, X-API-Wallet-Signature,
X-API-Wallet-Timestamp, X-API-Wallet-Nonce
The exchange adds two more limits: Strike's API keys can trade but can't withdraw, and you can set an expiry date. The toolkit suggests 90 days.
A small lesson from building it: Strike's published spec gave one header a different name from the one the server accepts. Only a live test found it. I now treat every spec as a claim to check, and the weekly review watches for spec changes.
Every change starts as a dry run
The toolkit can change only four kinds of things:
- leverage and margin mode on a market;
- adding margin to an open position, to move its liquidation price away (add only: there's no code to remove margin);
- starting a copy;
- changing a copy, setting a stop loss on it, or stopping it.
It has no code for orders at all.
Before any change, Claude shows the exact request, marked "DRY RUN: nothing sent", and explains it in a line. Then it offers four choices: make this change, skip it, explain more, or stop. None is marked as recommended.
That's slower than letting an AI act on its own, and that's the point. When money is involved, a person should see each change first.
Every change that goes through is also written to a local log, with the values before and after, in a folder outside the toolkit so updates never touch it. "Show my recent changes" reads it back. When something looks wrong a week later, the first question is always "what did I change?", and the log answers it.
Finding traders worth copying
A sweep checks about 5,000 Hyperliquid wallets that Strike already scores, plus Strike's own traders, in 20–30 minutes. A wide sweep covers Hyperliquid's whole leaderboard, about 45,000 wallets, in about an hour.
Each filter is there because skipping it cost me money:
- The profit must be copyable. At least 70% of the last 90 days' realised profit has to come from markets Strike lists, over at least 20 round trips.
- The edge must beat the costs. Copying a trade there and back costs about 0.15% in fees and price gap, so the trader must make at least 0.20% per dollar traded.
- The account must be solid. Profit mostly from perps, at least 180 days old, and never wiped out.
- A simulated copy must make money over both the last 90 and the last 30 days.
If nobody passes, it says so. No trader is better than a bad trader.
Replaying what you would have made
The key question isn't "what did the trader make?" but "what would I have made?"
The replay rebuilds the trader's trades from Hyperliquid's API and copies them the way Strike would: your amount per trade, your leverage, your limits, and excluded markets. When the trader closes part of a position, the copy closes the same share.
Open positions are valued at hourly prices, and every copied close is assumed to land 0.10% worse than the trader's, to allow for delay. It also checks every hourly high and low against Strike's margin rules, so a copy that would have been liquidated counts as liquidated.
I checked it against my real account. Over two weeks, the replay put the worst drop at −$577. The real figure was −$586. That's close enough to compare settings, though not to predict profit.
It compares the two ways Strike sizes copies:
- Fixed margin: the same dollar amount on every trade.
- Fixed ratio: each copy scaled to the trader's trade size relative to their account.
The winner is the one with the most profit per dollar of its biggest drop, over 90 and 30 days. If the two are within 10%, the smaller drop wins, because it's easier to sit through. If both lose money, it recommends neither.
It runs the whole comparison at 10x, 5x, 3x and 2x leverage and picks one per trader. An earlier version suggested 10x without modelling liquidations at all, and a copy with more leverage than the trader's own gets liquidated on moves the trader rides out.
On 26 October I ran it on the trader I copy myself, at 10x: a $7,000 account, up to half of it in copies, the last 90 days.
- 10x: fixed margin +$331, biggest drop −30%, 27 liquidations (fixed ratio +$248)
- 5x: +$825, −18%, 4 liquidations (fixed ratio +$441)
- 3x: +$402, −11%, 2 liquidations (fixed ratio +$420)
- 2x: +$204, −7%, 2 liquidations (fixed ratio +$390)
At 10x, fixed margin had the biggest drop and 27 liquidations, for less than half the profit of 5x. The verdict was "neither": no leverage passed, and at 2x, the safest tested, both modes lost money over the last 30 days. My own setting failed my own check. That's the check doing its job, and it's why setup now starts at 5x.
The same replay also tests limits on how much a copy can hold, side by side.
When the platform changes under you.
The hardest part wasn't the code. Strike changes fast.
On 12 October, it changed what happens when a copied trader is liquidated: your copy now closes too, where before it stayed open with nothing behind it. A day later, API routes that had refused my key started working.
So the weekly review does more than report profit. It checks for a newer version of the toolkit and for spec changes, and it flags anything that needs a decision:
- copies close to liquidation;
- copies the trader no longer holds;
- copies your limits blocked, and roughly what they'd be worth now;
- copies near or past their stop loss;
- settings that have drifted.
If nothing needs attention, it says so in one line.
A separate risk check asks what a sudden move would do to the open book: price shocks of 5%, 10%, and 20%, the weekend gap on stock and gold positions (their prices can jump between Friday's close and Monday's open, against the worst of the last 12 weekends), and copies holding opposite sides of the same market.
When a copy is close to liquidation, the fix is one request: "Add $50 margin to my BTC position", which shows the new liquidation price before you say yes. Adding margin moves the liquidation price away, but it also puts more money into that one position.
Four lessons for anyone building a trading agent.
- Keep the AI out of the arithmetic. Scripts calculate; the AI explains. Mistakes are easier to spot, and results repeat.
- Make the safe path the only path. No order code, no code to remove margin, keys that can't withdraw, a dry run for every change, and a log of every change made. Rules in a prompt help, but missing abilities are stronger.
- Check your simulation against reality, then run it on yourself. A backtest you haven't compared with real trades is a guess, and one that only ever approves your own choices isn't testing anything.
- Expect the platform to change. Build the check for change into your routine.
The toolkit is free on GitHub: github.com/benryandev/strike-copilot. It isn't financial advice, and it can't turn a bad trader into a good one. What it does is turn choosing a trader, a sizing mode, leverage, and limits into decisions based on numbers. A longer setup guide, skill by skill, is on X.