SkillAgentSearch skills...

options-strategy-advisor

Options trading strategy analysis and simulation tool. Provides theoretical pricing using Black-Scholes model, Greeks calculation, strategy P/L simulation, and risk management guidance

Install / Use

npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

95/100

Category

Marketing

Supported Platforms

Universal

Tags

Our assessment of options-strategy-advisor

options-strategy-advisor scores 95/100 on our quality scale, 84th of 642 Marketing skills we index (top 14%).

Its SKILL.md is 28 KB long, well organised into 62 sections with 34 code examples: a thorough specification that gives an agent plenty to work with.

With 2,885 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
15/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so options-strategy-advisor is actively maintained.
  • Our last check on 2026-11-16 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-09-29. Automated pattern scan on 2026-09-29. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

options-strategy-advisor compared with similar skills

All 4 of these similar skills score higher than options-strategy-advisor; compare them before choosing.

SkillScoreStarsUpdatedFormat
options-strategy-advisor (this skill)by tradermonty952.9k53d agoSKILL.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md
pptxby anthropics100177.9k55d agoSKILL.md
designby nextlevelbuilder100149.0k6d agoSKILL.md

Frequently asked questions

How do I install options-strategy-advisor?
Run npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor. The install tabs above show the steps for each supported agent.
Which AI agents does options-strategy-advisor work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is options-strategy-advisor safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is options-strategy-advisor still maintained?
The repository was last updated about 2 months ago, so options-strategy-advisor is actively maintained.

name: options-strategy-advisor description: Options trading strategy analysis and simulation tool. Provides theoretical pricing using Black-Scholes model, Greeks calculation, strategy P/L simulation, and risk management guidance. Use when user requests options strategy analysis, covered calls, protective puts, spreads, iron condors, earnings plays, or options risk management. Includes volatility analysis, position sizing, and earnings-based strategy recommendations. Educational focus with practical trade simulation.

Options Strategy Advisor

Overview

This skill provides comprehensive options strategy analysis and education using theoretical pricing models. It helps traders understand, analyze, and simulate options strategies without requiring real-time market data subscriptions.

Core Capabilities:

  • Black-Scholes Pricing: Theoretical option prices and Greeks calculation
  • Strategy Simulation: P/L analysis for major options strategies
  • Earnings Strategies: Pre-earnings volatility plays integrated with Earnings Calendar
  • Risk Management: Position sizing, Greeks exposure, max loss/profit analysis
  • Educational Focus: Detailed explanations of strategies and risk metrics

Data Sources:

  • FMP API: Stock prices, historical volatility, dividends, earnings dates
  • User Input: Implied volatility (IV), risk-free rate
  • Theoretical Models: Black-Scholes for pricing and Greeks

Prerequisites

Required:

  • Python 3.9+ with numpy, scipy, requests

Optional:

  • FMP API key (for real-time stock prices and historical volatility)
    • Set via FMP_API_KEY environment variable or --api-key argument
    • Without API key: Use manual inputs for stock price and volatility

Installation:

pip install numpy scipy requests

Quick Start Examples:

# Basic call option pricing (no API key needed)
python3 scripts/black_scholes.py

# With FMP API key for real-time data
python3 scripts/black_scholes.py --ticker AAPL --api-key $FMP_API_KEY

# Custom option parameters
python3 scripts/black_scholes.py --stock-price 180 --strike 185 --days 30 --volatility 0.25

# Put option analysis
python3 scripts/black_scholes.py --stock-price 180 --strike 175 --days 30 --option-type put

When to Use This Skill

Use this skill when:

  • User asks about options strategies ("What's a covered call?", "How does an iron condor work?")
  • User wants to simulate strategy P/L ("What's my max profit on a bull call spread?")
  • User needs Greeks analysis ("What's my delta exposure?")
  • User asks about earnings strategies ("Should I buy a straddle before earnings?")
  • User wants to compare strategies ("Covered call vs protective put?")
  • User needs position sizing guidance ("How many contracts should I trade?")
  • User asks about volatility ("Is IV high right now?")

Example requests:

  • "Analyze a covered call on AAPL"
  • "What's the P/L on a $100/$105 bull call spread on MSFT?"
  • "Should I trade a straddle before NVDA earnings?"
  • "Calculate Greeks for my iron condor position"
  • "Compare protective put vs covered call for downside protection"

Supported Strategies

Income Strategies

  1. Covered Call - Own stock, sell call (generate income, cap upside)
  2. Cash-Secured Put - Sell put with cash backing (collect premium, willing to buy stock)
  3. Poor Man's Covered Call - LEAPS call + short near-term call (capital efficient)

Protection Strategies

  1. Protective Put - Own stock, buy put (insurance, limited downside)
  2. Collar - Own stock, sell call + buy put (limited upside/downside)

Directional Strategies

  1. Bull Call Spread - Buy lower strike call, sell higher strike call (limited risk/reward bullish)
  2. Bull Put Spread - Sell higher strike put, buy lower strike put (credit spread, bullish)
  3. Bear Call Spread - Sell lower strike call, buy higher strike call (credit spread, bearish)
  4. Bear Put Spread - Buy higher strike put, sell lower strike put (limited risk/reward bearish)

Volatility Strategies

  1. Long Straddle - Buy ATM call + ATM put (profit from big move either direction)
  2. Long Strangle - Buy OTM call + OTM put (cheaper than straddle, bigger move needed)
  3. Short Straddle - Sell ATM call + ATM put (profit from no movement, unlimited risk)
  4. Short Strangle - Sell OTM call + OTM put (profit from no movement, wider range)

Range-Bound Strategies

  1. Iron Condor - Bull put spread + bear call spread (profit from range-bound movement)
  2. Iron Butterfly - Sell ATM straddle, buy OTM strangle (profit from tight range)

Advanced Strategies

  1. Calendar Spread - Sell near-term option, buy longer-term option (profit from time decay)
  2. Diagonal Spread - Calendar spread with different strikes (directional + time decay)
  3. Ratio Spread - Unbalanced spread (more contracts on one leg)

Analysis Workflow

Step 1: Gather Input Data

Required from User:

  • Ticker symbol
  • Strategy type
  • Strike prices
  • Expiration date(s)
  • Position size (number of contracts)

Optional from User:

  • Implied Volatility (IV) - if not provided, use Historical Volatility (HV)
  • Risk-free rate - default to current 3-month T-bill rate (~5.3% as of 2025)

Fetched from FMP API:

  • Current stock price
  • Historical prices (for HV calculation)
  • Dividend yield
  • Upcoming earnings date (for earnings strategies)

Example User Input:

Ticker: AAPL
Strategy: Bull Call Spread
Long Strike: $180
Short Strike: $185
Expiration: 30 days
Contracts: 10
IV: 25% (or use HV if not provided)

Step 2: Calculate Historical Volatility (if IV not provided)

Objective: Estimate volatility from historical price movements.

Method:

# Fetch 90 days of price data
prices = get_historical_prices("AAPL", days=90)

# Calculate daily returns
returns = np.log(prices / prices.shift(1))

# Annualized volatility
HV = returns.std() * np.sqrt(252)  # 252 trading days

Output:

  • Historical Volatility (annualized percentage)
  • Note to user: "HV = 24.5%, consider using current market IV for more accuracy"

User Can Override:

  • Provide IV from broker platform (ThinkorSwim, TastyTrade, etc.)
  • Script accepts --iv 28.0 parameter

Step 3: Price Options Using Black-Scholes

Black-Scholes Model:

For European-style options:

Call Price = S * N(d1) - K * e^(-r*T) * N(d2)
Put Price = K * e^(-r*T) * N(-d2) - S * N(-d1)

Where:
d1 = [ln(S/K) + (r + σ²/2) * T] / (σ * √T)
d2 = d1 - σ * √T

S = Current stock price
K = Strike price
r = Risk-free rate
T = Time to expiration (years)
σ = Volatility (IV or HV)
N() = Cumulative standard normal distribution

Adjustments:

  • Subtract present value of dividends from S for calls
  • American options: Use approximation or note "European pricing, may undervalue American options"

Python Implementation:

from scipy.stats import norm
import numpy as np

def black_scholes_call(S, K, T, r, sigma, q=0):
    """
    S: Stock price
    K: Strike price
    T: Time to expiration (years)
    r: Risk-free rate
    sigma: Volatility
    q: Dividend yield
    """
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)

    call_price = S*np.exp(-q*T)*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
    return call_price

def black_scholes_put(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)

    put_price = K*np.exp(-r*T)*norm.cdf(-d2) - S*np.exp(-q*T)*norm.cdf(-d1)
    return put_price

Output for Each Option Leg:

  • Theoretical price
  • Note: "Market price may differ due to bid-ask spread and American vs European pricing"

Step 4: Calculate Greeks

The Greeks measure option price sensitivity to various factors:

Delta (Δ): Change in option price per $1 change in stock price

def delta_call(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return np.exp(-q*T) * norm.cdf(d1)

def delta_put(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return np.exp(-q*T) * (norm.cdf(d1) - 1)

Gamma (Γ): Change in delta per $1 change in stock price

def gamma(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return np.exp(-q*T) * norm.pdf(d1) / (S * sigma * np.sqrt(T))

Theta (Θ): Change in option price per day (time decay)

def theta_call(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    d2 = d1 - sigma*np.sqrt(T)

    theta = (-S*norm.pdf(d1)*sigma*np.exp(-q*T)/(2*np.sqrt(T))
             - r*K*np.exp(-r*T)*norm.cdf(d2)
             + q*S*norm.cdf(d1)*np.exp(-q*T))

    return theta / 365  # Per day

Vega (ν): Change in option price per 1% change in volatility

def vega(S, K, T, r, sigma, q=0):
    d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
    return S * np.exp(-q*T) * norm.pdf(d1) * np.sqrt(T) / 100  # Per 1%

Rho (ρ): Change in option price per 1% change in interest rate

def rho_call(S, K, T, r, sigma, q=0):
    d2 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) - sigma*np.sqrt(T)
    return K * T * np.exp(-r*T) * norm.cdf(d2) / 100  # Per 1%

Position Greeks:

For a strategy with multiple legs, sum Greeks across all legs:

# Example: Bull Call Spread
# Long 1x $180 call
# Short 1x $185 call

delta_position = (1 * delta_long) + (-1 * delta_short)
gamma_position = (1 * gamma_long) + (-1 * gamma_short)
theta_position = (1 * theta_long) + (-1 * theta_short)
vega_position = (1 * vega_long) + (-1 * vega_short)

Greeks Interpretation:

| Greek | Meaning | Example | |-------|---------|---------| | Delta | Directional exposure | Δ = 0.50 → $50 profit if stock +$1 | | Gamma | Delta acceleration | Γ = 0.05 → Delta increases by 0.05 if stock +$1 | | Theta | Daily time decay | Θ = -$5 → Lose $5/day from time passing | | Vega | Volatility sensitivity | ν = $10 → Gain $10 if IV increases 1% | | Rho | Interest rate sensitivity | ρ = $2 → Gain $2 if rates increase 1% |

Step 5: Simulate Strategy P/L

Objective: Calculate profit/loss at various stock prices at expiration.

Method:

Generate stock price range (e.g., ±30% from current price):

current_price = 180
price_range = np.linspace(current_price * 0.7, current_price * 1.3, 100)

For each price point, calculate P/L:

def calculate_pnl(strategy, stock_price_at_expiration):
    pnl = 0

    for leg in strategy.legs:
        if leg.type == 'call':
            intrinsic_value = max(0, stock_price_at_expiration - leg.strike)
        else:  # put
            intrinsic_value = max(0, leg.strike - stock_price_at_expiration)

        if leg.position == 'long':
            pnl += (intrinsic_value - leg.premium_paid) * 100  # Per contract
        else:  # short
            pnl += (leg.premium_received - intrinsic_value) * 100

    return pnl * num_contracts

Key Metrics:

  • Max Profit: Highest possible P/L
  • Max Loss: Worst possible P/L
  • Breakeven Point(s): Stock price(s) where P/L = 0
  • Profit Probability: Percentage of price range that's profitable (simplified)

Example Output:

Bull Call Spread: $180/$185 on AAPL (30 DTE, 10 contracts)

Current Price: $180.00
Net Debit: $2.50 per spread ($2,500 total)

Max Profit: $2,500 (at $185+)
Max Loss: -$2,500 (at $180-)
Breakeven: $182.50
Risk/Reward: 1:1

Probability Profit: ~55% (if stock stays above $182.50)

Step 6: Generate P/L Diagram (ASCII Art)

Visual representation of P/L across stock prices:

def generate_pnl_diagram(price_range, pnl_values, current_price, width=60, height=15):
    """Generate ASCII P/L diagram"""

    # Normalize to chart dimensions
    max_pnl = max

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars2.9k
CategoryMarketing
Updated1mo ago
Forks655

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions