Tushare Data
zillionare/zillionare
面向中文自然语言的 Tushare 数据研究技能。用于把“看看这只股票最近怎么样”“帮我查财报趋势”“最近哪个板块最强”“北向资金在买什么”“给我导出一份行情数据”这类请求,转成可执行的数据获取、清洗、对比、筛选、导出与简要分析流程。适用于 A 股、指数、ETF/基金、财务、估值、资金流、公告新闻、板块概念与宏观数据等研究场景。
Options trading strategy analysis and simulation tool. An agent skill from tradermonty/claude-trading-skills.
$ npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install tradermonty/claude-trading-skills options-strategy-advisor --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/tradermonty/claude-trading-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/options-strategy-advisor .claude/skills/options-strategy-advisor && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "options-strategy-advisor" agent skill from https://github.com/tradermonty/claude-trading-skills/tree/main/skills/options-strategy-advisor into .claude/skills/options-strategy-advisor/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "options-strategy-advisor", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/tradermonty/claude-trading-skills/tree/main/skills/options-strategy-advisorType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install tradermonty/claude-trading-skills options-strategy-advisor --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/tradermonty/claude-trading-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/options-strategy-advisor .agents/skills/options-strategy-advisor && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "options-strategy-advisor" agent skill from https://github.com/tradermonty/claude-trading-skills/tree/main/skills/options-strategy-advisor into .agents/skills/options-strategy-advisor/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "options-strategy-advisor", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install tradermonty/claude-trading-skills options-strategy-advisor --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/tradermonty/claude-trading-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/options-strategy-advisor .cursor/skills/options-strategy-advisor && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "options-strategy-advisor" agent skill from https://github.com/tradermonty/claude-trading-skills/tree/main/skills/options-strategy-advisor into .cursor/skills/options-strategy-advisor/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "options-strategy-advisor", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/tradermonty/claude-trading-skills.git --path skills/options-strategy-advisor--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install tradermonty/claude-trading-skills options-strategy-advisor --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/tradermonty/claude-trading-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/options-strategy-advisor .gemini/skills/options-strategy-advisor && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "options-strategy-advisor" agent skill from https://github.com/tradermonty/claude-trading-skills/tree/main/skills/options-strategy-advisor into .gemini/skills/options-strategy-advisor/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "options-strategy-advisor", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install tradermonty/claude-trading-skills options-strategy-advisorInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/tradermonty/claude-trading-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/options-strategy-advisor .github/skills/options-strategy-advisor && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "options-strategy-advisor" agent skill from https://github.com/tradermonty/claude-trading-skills/tree/main/skills/options-strategy-advisor into .github/skills/options-strategy-advisor/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "options-strategy-advisor", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install tradermonty/claude-trading-skills options-strategy-advisor --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/tradermonty/claude-trading-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/options-strategy-advisor .opencode/skills/options-strategy-advisor && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "options-strategy-advisor" agent skill from https://github.com/tradermonty/claude-trading-skills/tree/main/skills/options-strategy-advisor into .opencode/skills/options-strategy-advisor/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "options-strategy-advisor", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
options-strategy-advisorOptions trading strategy analysis and simulation tool. An agent skill from tradermonty/claude-trading-skills.
Options Strategy Advisor is an agent skill from tradermonty/claude-trading-skills. 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.
Its SKILL.md is about 7.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 10 other files, including scripts and reference files (for example `README.md`, `references/black_scholes_methodology.md` and `scripts/black_scholes.py`).
It sits in Business, Finance & HR, covering Trading and backtesting. The repository describes itself as: Claude Code skills for equity investors and traders — market analysis, technical charting, economic calendars, screeners, and trading strategy development. The licence is MIT.
9 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit eab8d5c. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Ships 4 files in scripts/ (Python), which the agent can run.
Shell commands in SKILL.md call:
python3pipFrom the folder's file list and the shell code blocks in SKILL.md.
Links to these hosts (documentation or services it may open):
optionsplaybook.comcboe.comFrom URLs in SKILL.md, links to its own repository left out.
Names these keys or tokens, usually read from environment variables:
FMP_API_KEYFrom names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Options Strategy Advisor loads about 7.3k tokens when it runs, and up to ~8.4k if it reads all its reference files. Until then it costs about 126 tokens; SKILL.md has 1,393 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.
The full file from tradermonty/claude-trading-skills at commit eab8d5c, republished under its MIT licence (© tradermonty). 1,393 words, ~7,252 tokens.
.claude/skills/options-strategy-advisor/SKILL.md (or your agent's skills folder). This skill also uses 7 other files; get the full folder from GitHub.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:
Data Sources:
Required:
numpy, scipy, requestsOptional:
FMP_API_KEY environment variable or --api-key argumentInstallation:
pip install numpy scipy requestsQuick 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 putUse this skill when:
Example requests:
Required from User:
Optional from User:
Fetched from FMP API:
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)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 daysOutput:
User Can Override:
--iv 28.0 parameterBlack-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 distributionAdjustments:
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_priceOutput for Each Option Leg:
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 dayVega (ν): 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% |
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_contractsKey Metrics:
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)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(pnl_values)
min_pnl = min(pnl_values)
lines = []
lines.append(f"\nP/L Diagram: {strategy_name}")
lines.append("-" * width)
# Y-axis levels
levels = np.linspace(max_pnl, min_pnl, height)
for level in levels:
if abs(level) < (max_pnl - min_pnl) * 0.05:
label = f" 0 |" # Zero line
else:
label = f"{level:6.0f} |"
row = label
for i in range(width - len(label)):
idx = int(i / (width - len(label)) * len(price_range))
pnl = pnl_values[idx]
price = price_range[idx]
# Determine character
if abs(pnl - level) < (max_pnl - min_pnl) / height:
if pnl > 0:
char = '█' # Profit
elif pnl < 0:
char = '░' # Loss
else:
char = '─' # Breakeven
elif abs(level) < (max_pnl - min_pnl) * 0.05:
char = '─' # Zero line
elif abs(price - current_price) < (price_range[-1] - price_range[0]) * 0.02:
char = '│' # Current price line
else:
char = ' '
row += char
lines.append(row)
lines.append(" " * 6 + "|" + "-" * (width - 6))
lines.append(" " * 6 + f"${price_range[0]:.0f}" + " " * (width - 20) + f"${price_range[-1]:.0f}")
lines.append(" " * (width // 2 - 5) + "Stock Price")
return "\n".join(lines)Example Output:
P/L Diagram: Bull Call Spread $180/$185
------------------------------------------------------------
+2500 | ████████████████████
| ██████
| ██████
| ██████
0 | ──────
| ░░░░░░
|░░░░░░
-2500 |░░░░░
|____________________________________________________________
$126 $180 $234
Stock Price
Legend: █ Profit ░ Loss ── Breakeven │ Current PriceProvide tailored guidance based on strategy type:
Covered Call:
Income Strategy: Generate premium while capping upside
Setup:
- Own 100 shares of AAPL @ $180
- Sell 1x $185 call (30 DTE) for $3.50
Max Profit: $850 (Stock at $185+ = $5 stock gain + $3.50 premium)
Max Loss: Unlimited downside (stock ownership)
Breakeven: $176.50 (Cost basis - premium received)
Greeks:
- Delta: -0.30 (reduces stock delta from 1.00 to 0.70)
- Theta: +$8/day (time decay benefit)
Assignment Risk: If AAPL > $185 at expiration, shares called away
When to Use:
- Neutral to slightly bullish
- Want income in sideways market
- Willing to sell stock at $185
Exit Plan:
- Buy back call if stock rallies strongly (preserve upside)
- Let expire if stock stays below $185
- Roll to next month if want to keep sharesProtective Put:
Insurance Strategy: Limit downside while keeping upside
Setup:
- Own 100 shares of AAPL @ $180
- Buy 1x $175 put (30 DTE) for $2.00
Max Profit: Unlimited (stock can rise infinitely)
Max Loss: -$7 per share = ($5 stock loss + $2 premium)
Breakeven: $182 (Cost basis + premium paid)
Greeks:
- Delta: +0.80 (stock delta 1.00 - put delta 0.20)
- Theta: -$6/day (time decay cost)
Protection: Guaranteed to sell at $175, no matter how far stock falls
When to Use:
- Own stock, worried about short-term drop
- Earnings coming up, want protection
- Alternative to stop-loss (can't be stopped out)
Cost: "Insurance premium" - typically 1-3% of stock value
Exit Plan:
- Let expire worthless if stock rises (cost of insurance)
- Exercise put if stock falls below $175
- Sell put if stock drops but want to keep sharesIron Condor:
Range-Bound Strategy: Profit from low volatility
Setup (example on AAPL @ $180):
- Sell $175 put for $1.50
- Buy $170 put for $0.50
- Sell $185 call for $1.50
- Buy $190 call for $0.50
Net Credit: $2.00 ($200 per iron condor)
Max Profit: $200 (if stock stays between $175-$185)
Max Loss: $300 (if stock moves outside $170-$190)
Breakevens: $173 and $187
Profit Range: $175 to $185 (58% probability)
Greeks:
- Delta: ~0 (market neutral)
- Theta: +$15/day (time decay benefit)
- Vega: -$25 (short volatility)
When to Use:
- Expect low volatility, range-bound movement
- After big move, think consolidation
- High IV environment (sell expensive options)
Risk: Unlimited if one side tested
- Use stop loss at 2x credit received (exit at -$400)
Adjustments:
- If tested on one side, roll that side out in time
- Close early at 50% max profit to reduce tail riskIntegration with Earnings Calendar:
When user asks about earnings strategies, fetch earnings date:
from earnings_calendar import get_next_earnings_date
earnings_date = get_next_earnings_date("AAPL")
days_to_earnings = (earnings_date - today).daysPre-Earnings Strategies:
Long Straddle/Strangle:
Setup (AAPL @ $180, earnings in 7 days):
- Buy $180 call for $5.00
- Buy $180 put for $4.50
- Total Cost: $9.50
Thesis: Expect big move (>5%) but unsure of direction
Breakevens: $170.50 and $189.50
Profit if: Stock moves >$9.50 in either direction
Greeks:
- Delta: ~0 (neutral)
- Vega: +$50 (long volatility)
- Theta: -$25/day (time decay hurts)
IV Crush Risk: ⚠️ CRITICAL
- Pre-earnings IV: 40% (elevated)
- Post-earnings IV: 25% (typical)
- IV drop: -15 points = -$750 loss even if stock doesn't move!
Analysis:
- Implied Move: √(DTE/365) × IV × Stock Price
= √(7/365) × 0.40 × 180 = ±$10.50
- Breakeven Move Needed: ±$9.50
- Probability Profit: ~30-40% (implied move > breakeven move)
Recommendation:
✅ Consider if you expect >10% move (larger than implied)
❌ Avoid if expect normal ~5% earnings move (IV crush will hurt)
Alternative: Buy further OTM strikes to reduce cost
- $175/$185 strangle cost $4.00 (need >$8 move, but cheaper)Short Iron Condor:
Setup (AAPL @ $180, earnings in 7 days):
- Sell $170/$175 put spread for $2.00
- Sell $185/$190 call spread for $2.00
- Net Credit: $4.00
Thesis: Expect stock to stay range-bound ($175-$185)
Profit Zone: $175 to $185
Max Profit: $400
Max Loss: $100
IV Crush Benefit: ✅
- Short high IV before earnings
- IV drops after earnings → profit on vega
- Even if stock moves slightly, IV drop helps
Greeks:
- Delta: ~0 (market neutral)
- Vega: -$40 (short volatility - good here!)
- Theta: +$20/day
Recommendation:
✅ Good if expect normal earnings reaction (<8% move)
✅ Benefit from IV crush regardless of direction
⚠️ Risk if stock gaps outside range (>10% move)
Exit Plan:
- Close next day if IV crushed (capture profit early)
- Use stop loss if one side tested (-2x credit)Position Sizing:
Account Size: $50,000
Risk Tolerance: 2% per trade = $1,000 max risk
Iron Condor Example:
- Max loss per spread: $300
- Max contracts: $1,000 / $300 = 3 contracts
- Actual position: 3 iron condors
Bull Call Spread Example:
- Debit paid: $2.50 per spread
- Max contracts: $1,000 / $250 = 4 contracts
- Actual position: 4 spreadsPortfolio Greeks Management:
Portfolio Guidelines:
- Delta: -10 to +10 (mostly neutral)
- Theta: Positive preferred (seller advantage)
- Vega: Monitor if >$500 (IV risk)
Current Portfolio:
- Delta: +5 (slightly bullish)
- Theta: +$150/day (collecting $150 daily)
- Vega: -$300 (short volatility)
Interpretation:
✅ Neutral delta (safe)
✅ Positive theta (time working for you)
⚠️ Short vega: If IV spikes, lose $300 per 1% IV increase
→ Reduce short premium positions if VIX risingAdjustments and Exits:
Exit Rules by Strategy:
Covered Call:
- Profit: 50-75% of max profit
- Loss: Stock drops >5%, buy back call to preserve upside
- Time: 7-10 DTE, roll to avoid assignment
Spreads:
- Profit: 50% of max profit (close early, reduce tail risk)
- Loss: 2x debit paid (cut losses early)
- Time: 21 DTE, close or roll (avoid gamma risk)
Iron Condor:
- Profit: 50% of credit (close early common)
- Loss: One side tested, 2x credit lost
- Adjustment: Roll tested side out in time
Straddle/Strangle:
- Profit: Stock moved >breakeven, close immediately
- Loss: Theta eating position, stock not moving
- Time: Day after earnings (if earnings play)Strategy Analysis Report Template:
# Options Strategy Analysis: [Strategy Name]
**Symbol:** [TICKER]
**Strategy:** [Strategy Type]
**Expiration:** [Date] ([DTE] days)
**Contracts:** [Number]
---
## Strategy Setup
### Leg Details
| Leg | Type | Strike | Price | Position | Quantity |
|-----|------|--------|-------|----------|----------|
| 1 | Call | $180 | $5.00 | Long | 1 |
| 2 | Call | $185 | $2.50 | Short | 1 |
**Net Debit/Credit:** $2.50 debit ($250 total for 1 spread)
---
## Profit/Loss Analysis
**Max Profit:** $250 (at $185+)
**Max Loss:** -$250 (at $180-)
**Breakeven:** $182.50
**Risk/Reward Ratio:** 1:1
**Probability Analysis:**
- Probability of Profit: ~55% (stock above $182.50)
- Expected Value: $25 (simplified)
---
## P/L Diagram
[ASCII art diagram here]
---
## Greeks Analysis
### Position Greeks (1 spread)
- **Delta:** +0.20 (gains $20 if stock +$1)
- **Gamma:** +0.03 (delta increases by 0.03 if stock +$1)
- **Theta:** -$5/day (loses $5 per day from time decay)
- **Vega:** +$8 (gains $8 if IV increases 1%)
### Interpretation
- **Directional Bias:** Slightly bullish (positive delta)
- **Time Decay:** Working against you (negative theta)
- **Volatility:** Benefits from IV increase (positive vega)
---
## Risk Assessment
### Maximum Risk
**Scenario:** Stock falls below $180
**Max Loss:** -$250 (100% of premium paid)
**% of Account:** 0.5% (if $50k account)
### Assignment Risk
**Early Assignment:** Low (calls have time value)
**At Expiration:** Manage positions if in-the-money
---
## Trade Management
### Entry
✅ Enter if: [Conditions]
- Stock price $178-$182
- IV below 30%
- >21 DTE
### Profit Taking
- **Target 1:** 50% profit ($125) - Close half
- **Target 2:** 75% profit ($187.50) - Close all
### Stop Loss
- **Trigger:** Stock falls below $177 (-$150 loss)
- **Action:** Close position immediately
### Adjustments
- If stock rallies to $184, consider rolling short call higher
- If stock drops to $179, add second spread at $175/$180
---
## Suitability
### When to Use This Strategy
✅ Moderately bullish on AAPL
✅ Expect upside to $185-$190
✅ Want defined risk
✅ 21-45 DTE timeframe
### When to Avoid
❌ Very bullish (buy stock or long call instead)
❌ High IV environment (wait for IV to drop)
❌ Earnings in <7 days (IV crush risk)
---
## Alternatives Comparison
| Strategy | Max Profit | Max Loss | Complexity | When Better |
|----------|-----------|----------|------------|-------------|
| Bull Call Spread | $250 | -$250 | Medium | Moderately bullish |
| Long Call | Unlimited | -$500 | Low | Very bullish |
| Covered Call | $850 | Unlimited | Medium | Own stock already |
| Bull Put Spread | $300 | -$200 | Medium | Want credit spread |
**Recommendation:** Bull call spread is good balance of risk/reward for moderate bullish thesis.
---
*Disclaimer: This is theoretical analysis using Black-Scholes pricing. Actual market prices may differ. Trade at your own risk. Options are complex instruments with significant loss potential.*File Naming Convention:
options_analysis_[TICKER]_[STRATEGY]_[DATE].mdExample: options_analysis_AAPL_BullCallSpread_2025-11-08.md
What Users Should Know:
Black-Scholes Assumptions:
Real vs Theoretical:
Best Practices:
Historical vs Implied Volatility:
Historical Volatility (HV): What happened
- Calculated from past price movements
- Objective, based on data
- Available for free (FMP API)
Implied Volatility (IV): What market expects
- Derived from option prices
- Subjective, based on supply/demand
- Requires live options data (user provides)
Comparison:
- IV > HV: Options expensive (consider selling)
- IV < HV: Options cheap (consider buying)
- IV = HV: Fairly pricedIV Percentile:
User provides current IV, we calculate percentile:
# Fetch 1-year HV data
historical_hvs = calculate_hv_series(prices_1yr, window=30)
# Calculate IV percentile
iv_percentile = percentileofscore(historical_hvs, current_iv)
if iv_percentile > 75:
guidance = "High IV - consider selling premium (credit spreads, iron condors)"
elif iv_percentile < 25:
guidance = "Low IV - consider buying options (long calls/puts, debit spreads)"
else:
guidance = "Normal IV - any strategy appropriate"Earnings Calendar:
Technical Analyst:
US Stock Analysis:
Bubble Detector:
Portfolio Manager:
Use Case 1: Learn Strategy
User: "Explain a covered call"
Workflow:
1. Load strategy reference (references/strategies_guide.md)
2. Explain concept, risk/reward, when to use
3. Simulate example on AAPL
4. Show P/L diagram
5. Compare to alternativesUse Case 2: Analyze Specific Trade
User: "Analyze $180/$185 bull call spread on AAPL, 30 days"
Workflow:
1. Fetch AAPL price from FMP
2. Calculate HV or ask user for IV
3. Price both options (Black-Scholes)
4. Calculate Greeks
5. Simulate P/L
6. Generate analysis reportUse Case 3: Earnings Strategy
User: "Should I trade options before NVDA earnings?"
Workflow:
1. Fetch NVDA earnings date (Earnings Calendar)
2. Calculate days to earnings
3. Estimate IV percentile (if user provides IV)
4. Suggest straddle/strangle vs iron condor
5. Warn about IV crush
6. Simulate both strategiesUse Case 4: Portfolio Greeks Check
User: "What are my total portfolio Greeks?"
Workflow:
1. User provides current positions
2. Calculate Greeks for each position
3. Sum Greeks across portfolio
4. Assess overall exposure
5. Suggest adjustments if neededProblem: IV not available
Problem: Negative option price
Problem: Greeks seem wrong
Problem: Strategy too complex
References:
references/black_scholes_methodology.md - Black-Scholes formulas, Greeks, and interpretationreferences/strategies_guide.md - All 17+ strategies explained (future)references/greeks_explained.md - Greeks deep dive (future)references/volatility_guide.md - HV vs IV, when to trade (future)Scripts:
scripts/black_scholes.py - Pricing engine and Greeksscripts/strategy_analyzer.py - Strategy simulationscripts/earnings_strategy.py - Earnings-specific analysisExternal Resources:
Version: 1.0 Last Updated: 2025-11-08 Dependencies: Python 3.9+, numpy, scipy, requests API: FMP API (Free tier sufficient)
© tradermonty, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 7 other files (scripts, references) in skills/options-strategy-advisor of tradermonty/claude-trading-skills.
Open the folder on GitHubat commit eab8d5c
We found 3 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 3 other GitHub owners. This page covers the copy in tradermonty/claude-trading-skills, which our catalogue first saw on October 7, 2026.
Options Strategy Advisor next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Options Strategy Advisor this skilltradermonty/claude-trading-skills | 3k | 3 repos | ~7.3k | Automated safety check: Pass | MIT | |
| Tushare Datazillionare/zillionare | 321 | 2 repos | ~2.3k | Automated safety check: Pass | None | |
| Tradingview MCPatilaahmettaner/tradingview-mcp | 5k | — | ~1.3k | Automated safety check: Pass | MIT | |
| Digital Oraclekomako-workshop/digital-oracle | 878 | — | ~5.9k | Automated safety check: Pass | MIT | |
| Polyclawchainstacklabs/polyclaw | 359 | 1 repos | ~2k | Automated safety check: Pass | Apache-2.0 | |
| Markdownfacioquo/stock-indicators-dotnet | 1.2k | — | ~812 | Automated safety check: Pass | Apache-2.0 |
zillionare/zillionare
面向中文自然语言的 Tushare 数据研究技能。用于把“看看这只股票最近怎么样”“帮我查财报趋势”“最近哪个板块最强”“北向资金在买什么”“给我导出一份行情数据”这类请求,转成可执行的数据获取、清洗、对比、筛选、导出与简要分析流程。适用于 A 股、指数、ETF/基金、财务、估值、资金流、公告新闻、板块概念与宏观数据等研究场景。
atilaahmettaner/tradingview-mcp
AI Trading Intelligence — live prices, 30+ technical indicators, backtesting (6 strategies), walk-forward overfitting detection, trade logs, equity curves, licensed news sentiment (Marketaux), and…
komako-workshop/digital-oracle
Answer prediction questions using market trading data, not opinions.
chainstacklabs/polyclaw
Trade on Polymarket via split + CLOB execution. An agent skill from chainstacklabs/polyclaw.
facioquo/stock-indicators-dotnet
Format and lint Markdown in this repository against GitHub Flavored Markdown and its markdownlint-cli2 configuration — headers, lists, code fences, callouts (VitePress containers on docs-site pages…
MobiusQuant/OpenMobius-skill
Provides multi-school trading Q&A, chart/OHLCV analysis, annotation, and fresh-market workflows covering ICT/SMC, ChanLun, Wyckoff, Price Action, Order Flow, VSA, and Elliott Wave.
tradermonty/claude-trading-skills
This skill should be used when analyzing weekly price charts for stocks, stock indices, cryptocurrencies, or forex pairs.
tradermonty/claude-trading-skills
Detect and analyze trending market themes across sectors. An agent skill from tradermonty/claude-trading-skills.
tradermonty/claude-trading-skills
Track investment theses across their lifecycle — from screening idea to closed position with postmortem.
tradermonty/claude-trading-skills
Critically review strategy drafts from edge-strategy-designer for edge plausibility, overfitting risk, sample size adequacy, and execution realism.
tradermonty/claude-trading-skills
This skill should be used when analyzing sector rotation patterns and market cycle positioning.
tradermonty/claude-trading-skills
Druckenmiller Strategy Synthesizer - Integrates 8 upstream skill outputs (Market Breadth, Uptrend Analysis, Market Top, Macro Regime, FTD Detector, VCP Screener, Theme Detector, CANSLIM Screener)…
Categories
Options trading strategy analysis and simulation tool. An agent skill from tradermonty/claude-trading-skills. Options Strategy Advisor is an agent skill from tradermonty/claude-trading-skills. Options trading strategy analysis and simulation tool.
Options Strategy Advisor fits situations like: user requests options strategy analysis; protective puts; options risk management.
Run `npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a claude-code`. Or copy the skill folder (skills/options-strategy-advisor in tradermonty/claude-trading-skills) into .claude/skills/options-strategy-advisor in your project. Claude Code loads it when a task matches its description.
Run `npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a codex`. Or copy the skill folder (skills/options-strategy-advisor in tradermonty/claude-trading-skills) into .agents/skills/options-strategy-advisor in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add tradermonty/claude-trading-skills --skill options-strategy-advisor -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/options-strategy-advisor, .gemini/skills/options-strategy-advisor, .github/skills/options-strategy-advisor and .opencode/skills/options-strategy-advisor in your project.
Going by SKILL.md and its folder, Options Strategy Advisor needs Python for the scripts in its folder, the command-line tools its instructions call (python3 and pip) and credentials named FMP_API_KEY. Our summary lists: Python 3; A credential in FMP_API_KEY.
SKILL.md names 2 domains. As links in the text: optionsplaybook.com and cboe.com. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.
Options Strategy Advisor is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 7.3k tokens (SKILL.md is roughly 29k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.1k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Options Strategy Advisor: Tushare Data (zillionare/zillionare, 321 stars), Tradingview MCP (atilaahmettaner/tradingview-mcp, 5k stars), Digital Oracle (komako-workshop/digital-oracle, 878 stars) and Polyclaw (chainstacklabs/polyclaw, 359 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
tradermonty (a GitHub user) maintains it in tradermonty/claude-trading-skills, which has 2,977 GitHub stars. The repository holds 74 skills in this directory. The repository was last updated on October 9, 2026.
Source: tradermonty/claude-trading-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.