5 Open‑Source Claude Code Skills to Turn It into a Quant Trading Expert

This article presents five Claude Code Skills—Backtest Expert, Market Data Pipeline, Signal Generator, Risk Manager, and Live Signal Monitor—and demonstrates how to assemble an algorithmic trading system using the EODHD API.

Claude Code Skills Overview

Claude Code is a terminal‑based intelligent agent that can read files and execute code. Skills are defined by SKILL.md recipes; installing a Skill equips Claude with domain‑specific expertise.

1. Backtest Expert – Systematic Strategy Testing

Source: tradermonty/claude-trading-skills (⭐ 16)

git clone https://github.com/tradermonty/claude-trading-skills.git
cp -r claude-trading-skills/skills/backtest-expert ~/.claude/skills/

Workflow

Confirm strategy rules and parameters.

Fetch historical OHLCV data for the target ticker and period.

Compute indicators from scratch (no black‑box libraries).

Generate explicit entry/exit signals.

Run a vectorised backtest and calculate total return, Sharpe ratio, max drawdown, and win rate.

Output an equity‑curve plot and a summary table.

If the in‑sample window is shorter than two years, flag a potential over‑fitting risk.

Code example – RSI backtest (EODHD)

import requests
import pandas as pd
import numpy as np

API_KEY = "YOUR_EODHD_KEY"
url = "https://eodhd.com/api/eod/AAPL.US"
params = {"api_token": API_KEY, "from": "2022-01-01", "to": "2024-12-31", "period": "d", "fmt": "json"}
data = requests.get(url, params=params).json()
df = pd.DataFrame(data)[["date", "adjusted_close", "volume"]]
df["date"] = pd.to_datetime(df["date"])
df.set_index("date", inplace=True)
df.columns = ["close", "volume"]
# RSI calculation
delta = df["close"].diff()
gain = delta.clip(lower=0).rolling(14).mean()
loss = -delta.clip(upper=0).rolling(14).mean()
df["rsi"] = 100 - (100 / (1 + gain / loss))
# Signal generation
df["signal"] = 0
df.loc[df["rsi"] < 30, "signal"] = 1   # buy
df.loc[df["rsi"] > 70, "signal"] = -1  # sell
# Vectorised returns
df["returns"] = df["close"].pct_change()
df["strategy"] = df["signal"].shift(1) * df["returns"]
sharpe = df["strategy"].mean() / df["strategy"].std() * np.sqrt(252)
total = (1 + df["strategy"]).prod() - 1
print(f"Sharpe ratio: {sharpe:.2f} | Total return: {total:.2%}")

Pros : Enforces a structured workflow, explicit over‑fitting checks, and transparent indicator logic.

Cons : Requires a well‑defined strategy description; vague inputs yield uninformative backtest results.

Best suited for : Quant traders who run 5‑10 strategy variants weekly and need repeatable, comparable backtest outcomes.

2. Market Data Pipeline – EODHD Integration

Source: JoelLewis/finance_skills (trading‑operations plugin)

npx skills add JoelLewis/finance_skills --plugin trading-operations

Workflow

Confirm required data type (EOD, intraday, fundamentals, real‑time).

Select the appropriate EODHD endpoint.

Build request parameters (ticker format, date range, period).

Normalize the API response into a DataFrame with unified column names.

Apply corporate‑action adjustments to historical prices.

Cache results to avoid duplicate calls within the same session.

Return a ready‑to‑use DataFrame for indicator calculations.

Bad data—survivorship bias, unadjusted prices, missing corporate actions—can silently inflate backtest performance.

import requests
import pandas as pd

API_KEY = "YOUR_EODHD_KEY"

def fetch_eod(symbol: str, start: str, end: str) -> pd.DataFrame:
    r = requests.get(
        f"https://eodhd.com/api/eod/{symbol}",
        params={"api_token": API_KEY, "from": start, "to": end, "period": "d", "fmt": "json"}
    )
    df = pd.DataFrame(r.json())
    df["date"] = pd.to_datetime(df["date"])
    return df.set_index("date")[["open", "high", "low", "close", "adjusted_close", "volume"]]

def fetch_intraday(symbol: str, interval: str = "1m") -> pd.DataFrame:
    r = requests.get(
        f"https://eodhd.com/api/intraday/{symbol}",
        params={"api_token": API_KEY, "interval": interval, "fmt": "json"}
    )
    df = pd.DataFrame(r.json())
    df["datetime"] = pd.to_datetime(df["datetime"])
    return df.set_index("datetime")[["open", "high", "low", "close", "volume"]]

def fetch_fundamentals(symbol: str) -> dict:
    r = requests.get(
        f"https://eodhd.com/api/fundamentals/{symbol}",
        params={"api_token": API_KEY, "fmt": "json"}
    )
    return r.json()

aapl = fetch_eod("AAPL.US", "2023-01-01", "2024-12-31")
fund = fetch_fundamentals("AAPL.US")
eps = fund["Highlights"]["EPS"]
print(f"EPS: {eps} | Latest adjusted close: ${aapl['adjusted_close'].iloc[-1]:.2f}")

Pros : Provides adjusted EOD, minute‑level intraday, fundamentals, and real‑time data from a single API; free tier available for prototyping.

Cons : Real‑time, zero‑latency quotes require a paid plan.

Best suited for : Developers building serious backtests or live systems who need institutional‑grade data without enterprise pricing.

3. Signal Generator – Translating Strategy Logic to Code

Source: ScientiaCapital/skills (active/signal‑generation)

git clone https://github.com/scientiacapital/skills.git
cp -r skills/active/signal-generation ~/.claude/skills/

Strategies may exist as natural‑language notes or TradingView Pine scripts. This Skill parses the description, maps conditions to pandas / numpy operations, and outputs a vectorised Python DataFrame.

Workflow

Parse natural‑language rules into explicit conditions.

Map each condition to pandas / numpy expressions.

Compute indicators using vectorised operations (no row‑by‑row loops).

Build separate entry and exit series.

Apply optional session‑filtering conditions.

Output a DataFrame with columns: close, indicators, signal, position.

Validate that all indicators are shifted before signal comparison to prevent look‑ahead bias.

import requests
import pandas as pd
import numpy as np

API_KEY = "YOUR_EODHD_KEY"
# Fetch TSLA data
r = requests.get(
    "https://eodhd.com/api/eod/TSLA.US",
    params={"api_token": API_KEY, "from": "2023-01-01", "to": "2024-12-31", "period": "d", "fmt": "json"}
)
df = pd.DataFrame(r.json()).set_index("date")[["high", "low", "adjusted_close"]]
df.rename(columns={"adjusted_close": "close"}, inplace=True)

def ema(s, n):
    return s.ewm(span=n, adjust=False).mean()

def compute_adx(df, n=14):
    tr = pd.concat([
        df["high"] - df["low"],
        (df["high"] - df["close"].shift()).abs(),
        (df["low"] - df["close"].shift()).abs()
    ], axis=1).max(axis=1)
    dm_pos = (df["high"] - df["high"].shift()).clip(lower=0)
    dm_neg = (df["low"].shift() - df["low"]).clip(lower=0)
    atr = tr.ewm(span=n, adjust=False).mean()
    di_pos = 100 * dm_pos.ewm(span=n, adjust=False).mean() / atr
    di_neg = 100 * dm_neg.ewm(span=n, adjust=False).mean() / atr
    dx = 100 * (di_pos - di_neg).abs() / (di_pos + di_neg)
    return dx.ewm(span=n, adjust=False).mean()

df["ema20"] = ema(df["close"], 20)
df["ema50"] = ema(df["close"], 50)
df["adx"] = compute_adx(df)
cross_up = (df["ema20"] > df["ema50"]) & (df["ema20"].shift() <= df["ema50"].shift())
adx_confirmed = df["adx"] > 25
df["signal"] = (cross_up & adx_confirmed).astype(int)
print(df[df["signal"] == 1][["close", "ema20", "ema50", "adx"]].tail())

Pros : Built‑in look‑ahead bias detection; delivers production‑grade vectorised code.

Cons : Signals must be manually verified before allocating live capital.

Best suited for : Traders who think in rule‑based terms and want Claude to translate those rules into clean Python.

4. Risk Manager – Position Sizing and Portfolio Controls

Source: JoelLewis/finance_skills (wealth‑management plugin)

npx skills add JoelLewis/finance_skills --plugin wealth-management

Workflow

Calculate ATR‑based stop‑loss distance using current settings.

Apply a fixed‑fraction position size (default: 1 % of equity per trade).

Check portfolio heat: warn if total exposure exceeds 5 % of net worth.

Compute historical VaR at 95 % confidence.

Output entry price, stop‑loss price, share count, dollar risk, and target R‑multiple.

Define a circuit‑breaker that halts new entries if drawdown exceeds a configurable threshold.

import requests
import pandas as pd
import numpy as np

API_KEY = "YOUR_EODHD_KEY"
# Recent EOD data for AAPL
r = requests.get(
    "https://eodhd.com/api/eod/AAPL.US",
    params={"api_token": API_KEY, "from": "2024-10-01", "to": "2024-12-31", "period": "d", "fmt": "json"}
)
df = pd.DataFrame(r.json())
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date")[["high", "low", "adjusted_close"]].rename(columns={"adjusted_close": "close"})
# ATR (14‑day)
tr = pd.concat([
    df["high"] - df["low"],
    (df["high"] - df["close"].shift()).abs(),
    (df["low"] - df["close"].shift()).abs()
], axis=1).max(axis=1)
atr = tr.ewm(span=14, adjust=False).mean().iloc[-1]

def size_position(equity, risk_pct, entry, stop):
    risk_per_share = abs(entry - stop)
    if risk_per_share == 0:
        return 0
    return int((equity * risk_pct / 100) / risk_per_share)

equity = 10000
entry_price = df["close"].iloc[-1]
stop_price = entry_price - (2 * atr)
shares = size_position(equity, 1.0, entry_price, stop_price)
print(f"Entry price:   ${entry_price:.2f}")
print(f"Stop price (2×ATR): ${stop_price:.2f} | ATR: ${atr:.2f}")
print(f"Position:      {shares} shares")
print(f"Dollar risk:   ${shares * abs(entry_price - stop_price):.2f}")

Pros : Generates reusable, parameterised modules and includes portfolio‑heat checks beyond single‑trade sizing.

Cons : The position model still requires human review because personal drawdown tolerance is not inferred.

Best suited for : Systematic traders running multiple strategies who need a consistent, auditable risk framework.

5. Live Signal Monitor – Real‑Time Alerts

Source: roman-rr/trading-skills (trading‑signals skill)

git clone https://github.com/roman-rr/trading-skills.git
cp -r trading-skills/trading-signals ~/.claude/skills/

This Skill closes the loop from research to live monitoring. It polls EODHD for real‑time quotes and recent EOD candles, recomputes indicators, evaluates signal conditions, and emits alerts without placing orders.

Workflow

Fetch real‑time quotes and recent EOD candles via the EODHD REST API.

Maintain a rolling window in memory.

Re‑compute indicators each time a new candle arrives.

Evaluate entry, exit, or hold conditions.

When a signal fires, record timestamp, ticker, price, and indicator values.

Send an alert (print, Telegram, email, etc.).

Never execute orders directly; the Skill only outputs signals.

import requests
import pandas as pd
import numpy as np
import time
from datetime import datetime

API_KEY = "YOUR_EODHD_KEY"

def fetch_live_quote(symbol: str) -> float:
    r = requests.get(
        f"https://eodhd.com/api/real-time/{symbol}",
        params={"api_token": API_KEY, "fmt": "json"}
    )
    return r.json().get("close", None)

def fetch_recent_eod(symbol: str, n: int = 30) -> pd.Series:
    r = requests.get(
        f"https://eodhd.com/api/eod/{symbol}",
        params={"api_token": API_KEY, "period": "d", "fmt": "json"}
    )
    df = pd.DataFrame(r.json()).tail(n)
    df["date"] = pd.to_datetime(df["date"])
    return df.set_index("date")["adjusted_close"].rename("close")

def compute_rsi(series, n=14):
    delta = series.diff()
    gain = delta.clip(lower=0).rolling(n).mean()
    loss = -delta.clip(upper=0).rolling(n).mean()
    return 100 - (100 / (1 + gain / loss))

symbol = "AAPL.US"
print(f"Monitoring {symbol} | {datetime.now():%Y-%m-%d %H:%M}")
while True:
    close_series = fetch_recent_eod(symbol, n=30)
    live_price = fetch_live_quote(symbol) or close_series.iloc[-1]
    today = pd.Timestamp.now().normalize()
    close_series[today] = live_price
    rsi = compute_rsi(close_series).iloc[-1]
    status = (
        "Oversold → watch buy" if rsi < 30 else
        "Overbought → watch sell" if rsi > 70 else
        "Neutral"
    )
    print(f"[{datetime.now():%H:%M:%S}] {symbol} | ${live_price:.2f} | RSI: {rsi:.1f} | {status}")
    if rsi < 30:
        print(f"  🔔 Alert: RSI oversold ({rsi:.1f}) – check entry opportunity")
    time.sleep(60)

Pros : Works on EODHD’s free tier (no WebSocket required); enforces separation of signal generation and order execution.

Cons : 60‑second polling is unsuitable for sub‑minute strategies that need higher‑frequency data streams.

Best suited for : Swing and intraday traders who want automated signal detection without building a full execution engine.

References

tradermonty/claude-trading-skills – https://github.com/tradermonty/claude-trading-skills

JoelLewis/finance_skills – https://github.com/JoelLewis/finance_skills

ScientiaCapital/skills – https://github.com/scientiacapital/skills

JoelLewis/finance_skills (risk‑measurement) – https://github.com/JoelLewis/finance_skills

roman-rr/trading-skills – https://github.com/roman-rr/trading-skills