5 skills de Claude Code para trading algorítmico

La mayoría de los traders cree que el cuello de botella es la estrategia.

No lo es.

El cuello de botella es el tiempo entre "tengo una idea" y "esto está corriendo en producción". Escribir código repetitivo, conectar APIs, depurar errores de vectorbt a las 2 de la madrugada. Ahí es donde mueren la mayoría de las estrategias.

Si estás:

• construyendo sistemas de trading sistemático en Python,
• probando indicadores técnicos antes de desplegar capital real,
• o intentando comprimir semanas de trabajo cuant en días,

esto te importa.

Claude Code no es el chatbot. Es un entorno agéntico que corre en tu terminal, lee tus archivos, y ejecuta código en tu máquina. Para el trading algorítmico, eso cambia lo que es posible.

El verdadero poder viene de las skills — archivos SKILL.md que funcionan como conjuntos de instrucciones, diciéndole a Claude exactamente cómo abordar una tarea específica. Piensa en ellas como recetas: flujos de trabajo paso a paso que Claude sigue automáticamente cuando la tarea encaja. Instalas una, y Claude se transforma en un especialista para ese dominio.

Aquí tienes 5 skills de repositorios públicos que hacen que Claude Code sea genuinamente útil para trading — con los comandos de instalación, las recetas por dentro, y código Python funcional usando EODHD para datos de mercado.

1. Backtesting Expert — Testing sistemático de estrategias

Fuente: 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/

Esta skill convierte a Claude Code en un analista de backtesting dedicado. La receta del SKILL.md le indica a Claude que siga un flujo de trabajo estructurado cada vez que describes una estrategia:

SKILL RECIPE (backtest-expert):
1. Confirm strategy rules and parameters
2. Fetch historical OHLCV data for the specified symbol and period
3. Compute indicator(s) from scratch — no library black boxes
4. Generate entry/exit signals with explicit conditions
5. Run a vectorized backtest: returns, Sharpe, max drawdown, win rate
6. Output equity curve + summary table
7. Flag overfitting risks if in-sample window < 2 years

En la práctica, describes tu idea en lenguaje natural. Claude sigue la receta.

import requests
import pandas as pd
import numpy as np
API_KEY = "YOUR_EODHD_KEY"
# Fetch EOD historical prices via EODHD REST API
url = f"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 from scratch
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))
# Signals
df["signal"] = 0
df.loc[df["rsi"] < 30, "signal"] =  1  # buy
df.loc[df["rsi"] > 70, "signal"] = -1  # sell
# Vectorized strategy 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: {sharpe:.2f} | Total return: {total:.2%}")

A partir de aquí puedes construir: bucles de validación walk-forward, screeners multi-ticker, grids de sensibilidad de parámetros.

Ventajas

• El flujo estructurado evita saltarse la comprobación de overfitting
• Fuerza una lógica de señal explícita — sin asunciones implícitas de librería

Desventajas

• Requiere una descripción de estrategia clara de entrada; inputs vagos producen backtests genéricos

Ideal para: cuants que prueban entre 5 y 10 variantes de estrategia a la semana y necesitan resultados reproducibles y comparables entre todas ellas.

2. Market Data Pipeline — Integración con EODHD

Fuente: JoelLewis/finance_skills · plugin trading-operations

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

Esta skill gestiona toda la capa de ingesta de datos. Su receta estandariza cómo Claude trae y estructura datos de mercado — precios EOD, barras intradía, fundamentales, y cotizaciones en tiempo real — desde un único proveedor.

SKILL RECIPE (market-data-pipeline):
1. Identify data type needed: EOD / intraday / fundamentals / real-time
2. Select the correct EODHD endpoint for that data type
3. Build the request with proper params (symbol format, date range, interval)
4. Normalize response to a DataFrame with standard column names
5. Apply corporate-action adjustments for historical price analysis
6. Cache the result to avoid redundant API calls in the same session
7. Return the DataFrame ready for indicator computation

Los datos malos son el asesino silencioso de los backtests. Sesgo de supervivencia, precios sin ajustar, eventos corporativos que faltan — estos no lanzan errores. Simplemente hacen que tu estrategia parezca mejor de lo que es.

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()
# Usage
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}")

EODHD cubre más de 70 mercados en todo el mundo — acciones de EE. UU., ETFs, forex, cripto — con precios ajustados por eventos corporativos y un plan gratuito para prototipar.

👉 Empieza con EODHD y consigue un 10% de descuento en cualquier plan de pago: eodhd.com

Ventajas

• EOD ajustado + intradía (1 minuto) + fundamentales + tiempo real desde una sola API
• Plan gratuito disponible; planes de pago desde 19,99 €/mes

Desventajas

• Las cotizaciones en tiempo real sin retraso requieren un plan de pago

Ideal para: cualquiera construyendo un sistema serio de backtesting o en vivo que necesite datos de calidad institucional a precios de desarrollador independiente.

3. Signal Generator — De lógica de estrategia a código ejecutable

Fuente: ScientiaCapital/skills · active/signal-generation

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

Tienes una estrategia. Vive en tu cabeza, en una nota de investigación, o en un Pine Script de TradingView. Necesitas tenerla en Python limpio y vectorizado. Esta skill se encarga de la traducción.

SKILL RECIPE (signal-generation):
1. Parse strategy rules from natural language into explicit conditions
2. Map each condition to a pandas/numpy operation
3. Compute indicators using vectorized operations (no row-by-row loops)
4. Build entry and exit Series separately
5. Apply time-of-day or session filters if specified
6. Output DataFrame: [close, *indicators, signal, position]
7. Verify: no lookahead bias (all indicators shifted before signal comparison)

import requests
import pandas as pd
import numpy as np
API_KEY = "YOUR_EODHD_KEY"
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())
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date")[["high", "low", "adjusted_close"]].rename(columns={"adjusted_close": "close"})
# EMA crossover + ADX filter - no TA-Lib
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())

Ventajas

• La comprobación de lookahead bias viene integrada en la receta — Claude la señala antes de entregar el código
• Produce operaciones de pandas vectorizadas: código listo para producción, no de tutorial

Desventajas

• Valida siempre la lógica de la señal a mano antes de conectarla a capital real

Ideal para: traders que piensan en reglas de estrategia y quieren que Claude gestione la traducción a Python.

4. Risk Manager — Dimensionamiento de posiciones y control de exposición

Fuente: JoelLewis/finance_skills · plugin wealth-management (skill risk-measurement)

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

Una estrategia sin gestión de riesgo es especulación con pasos extra. Esta skill le da a Claude un marco de decisión estructurado para cada cálculo de dimensionamiento y exposición.

SKILL RECIPE (risk-management):
1. Calculate ATR-based stop distance for the current setup
2. Apply fixed-fractional sizing (default: 1% account risk per trade)
3. Check portfolio heat: flag if total exposure > 5% of equity
4. Compute Historical VaR (95% confidence) on the current portfolio
5. Output: entry, stop, shares, dollar risk, R-multiple target
6. Define kill-switch threshold: halt new entries if drawdown > X%

import requests
import pandas as pd
import numpy as np
API_KEY = "YOUR_EODHD_KEY"
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-period)
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      = 10_000
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:         ${entry_price:.2f}")
print(f"Stop (2×ATR):  ${stop_price:.2f}  |  ATR: ${atr:.2f}")
print(f"Position size: {shares} shares")
print(f"Dollar risk:   ${shares * abs(entry_price - stop_price):.2f}")

Ventajas

• Genera módulos reutilizables y parametrizados — no valores fijos por operación
• La receta incluye comprobación de "calor" de cartera junto al dimensionamiento por operación

Desventajas

• Los modelos de dimensionamiento requieren revisión humana — Claude no conoce tu tolerancia personal al drawdown

Ideal para: traders sistemáticos que corren varias estrategias a la vez y necesitan un marco de riesgo consistente y auditable.

5. Live Signal Monitor — Alertas en tiempo real

Fuente: roman-rr/trading-skills · skill trading-signals

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

La última skill cierra el círculo entre investigación y monitorización en vivo. En lugar de correr backtests, vigilas señales en tiempo real y disparas alertas cuando se cumplen las condiciones.

SKILL RECIPE (live-signal-monitor):
1. Fetch real-time quote and recent EOD bars via EODHD REST API
2. Maintain a rolling window of bars in memory
3. Recompute indicator(s) on each new bar
4. Evaluate signal conditions — entry, exit, or hold
5. On signal trigger: log timestamp, symbol, price, indicator values
6. Send alert (print / Telegram / email)
7. Never execute orders directly — output signal only

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]
    # Append live price as today's bar
    today = pd.Timestamp.now().normalize()
    close_series[today] = live_price
    rsi    = compute_rsi(close_series).iloc[-1]
    status = "OVERSOLD → BUY WATCH" if rsi < 30 else "OVERBOUGHT → SELL WATCH" 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 at {rsi:.1f} - review entry")
    time.sleep(60)

Combina esto con un bot de Telegram y tienes detección de señales automatizada corriendo 24/7 — sin vigilar gráficos a mano.

👉 Empieza con EODHD y desbloquea un 10% de descuento en cualquier plan de pago: eodhd.com

Ventajas

• El enfoque por polling funciona con el plan gratuito de EODHD — no requiere suscripción por WebSocket
• La skill fuerza la separación entre señal y ejecución — sin órdenes en vivo accidentales

Desventajas

• El polling cada 60 segundos no es adecuado para estrategias por debajo del minuto (usa el feed WebSocket de EODHD para esas)

Ideal para: traders de swing e intradía que quieren detección de señales automatizada sin construir un sistema de ejecución completo.

El cambio

Las skills de Claude Code no son magia. Son recetas estructuradas que eliminan el impuesto de "averiguarlo desde cero" en cada proyecto nuevo.

Cinco skills. Una capa de datos fiable. El cuello de botella se desplaza de la implementación a lo que siempre debería haber sido: decidir qué estrategias merece la pena probar.

A la mayoría de los cuants no les faltan ideas. Les falta el ancho de banda para implementarlas lo bastante rápido como para encontrar las que de verdad funcionan.

Eso es lo que cambia.

¿Buscas contenido técnico para tu empresa? Puedo ayudarte — LinkedIn · kevinmenesesgonzalez@gmail.com