# position-sizing

Calculates trade position sizes using five risk management models. Useful for setting up systematic trading rules and managing drawdown risks.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 572 installs · ★ 443
- Author: agiprolabs
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/agiprolabs/claude-trading-skills/tree/HEAD/skills/position-sizing/SKILL.md
- Updated: 2026-09-03
- HTML: https://affpapa.org/en/nevibecode/skills/position-sizing

## What it does

The skill equips the assistant with trade sizing formulas: fixed fractional risk, volatility adjustments via ATR, the Kelly criterion, anti-martingale streaks, and pool liquidity constraints for Solana tokens.

Calculations follow a sizing ladder. The agent evaluates theoretical edge via Kelly, risk tolerance, daily portfolio volatility, and pool limits across DEXes like Raydium, Orca, or Meteora. The final order size takes the minimum across all four constraints.

Full Kelly sizing is strictly avoided because empirical edge estimates contain noise. You should use fractional sizing such as 0.25x Kelly; if the Kelly value turns negative, the strategy lacks an edge and trading must halt.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill position-sizing -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/position-sizing/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/position-sizing/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill position-sizing -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/position-sizing/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill position-sizing -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/position-sizing/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install agiprolabs/claude-trading-skills position-sizing
```

2. **Manually: put the files in place**
- File: `.github/skills/position-sizing/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill position-sizing -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/agiprolabs/claude-trading-skills --path skills/position-sizing
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/position-sizing/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add agiprolabs/claude-trading-skills --skill position-sizing -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/agiprolabs/claude-trading-skills/tree/HEAD/skills/position-sizing/SKILL.md

## When to use it
- calculate position size based on account risk percentage
- normalize trade exposure across assets using ATR volatility
- cap order sizes against AMM pool depth to prevent slippage
- scale down trade size after consecutive losing streaks

## Example prompts
- Calculate position size for a $10,000 account risking 2% with entry at 1.50 and stop loss at 1.30
- Run quarter-Kelly sizing for a 55% win rate and a 2.0 payoff ratio
- Check max trade size for a Solana pool with 500 SOL and 2% max slippage

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: bb54d7320a22d34a.

BEGIN THIRD-PARTY FILE bb54d7320a22d34a
````text
---
name: position-sizing
description: Trade sizing methods including fixed fractional, volatility-adjusted, Kelly criterion, and liquidity-constrained sizing
---

# Position Sizing

Position sizing is the single most important risk management decision in trading. Your entry signal determines direction; your position size determines survival. A mediocre strategy with proper sizing will outperform a great strategy with reckless sizing over any meaningful time horizon.

**Core principle**: Size determines survival, not entries. Two traders with the same signals but different sizing will have wildly different outcomes. The one who sizes conservatively survives drawdowns and compounds capital; the one who oversizes blows up.

## Methods Covered

| Method | Best For | Key Input |
|--------|----------|-----------|
| Fixed Fractional | General trading, most recommended | Account risk % |
| Volatility-Adjusted | Volatile markets, multi-asset | ATR or realized vol |
| Kelly Criterion | Quantified edge with track record | Win rate + payoff ratio |
| Liquidity-Constrained | Low-liquidity Solana tokens | Pool depth |
| Anti-Martingale | Trend-following strategies | Recent P&L streak |

---

## 1. Fixed Fractional Sizing

The most recommended method for most traders. Risk a fixed percentage of your account on each trade.

### Formula

```
risk_amount = account_value * risk_percentage
price_risk_per_unit = entry_price - stop_loss_price
position_size_units = risk_amount / price_risk_per_unit
position_value = position_size_units * entry_price
```

### Risk Tiers

| Tier | Risk Per Trade | Use Case |
|------|---------------|----------|
| Conservative | 0.5–1% | New strategies, drawdown recovery |
| Standard | 1–2% | Most traders, proven strategies |
| Aggressive | 3–5% | High-conviction setups with strong, measured edge |

### Example

```python
account = 10_000  # $10,000 or 100 SOL
risk_pct = 0.02   # 2%
entry = 1.50
stop_loss = 1.30

risk_amount = account * risk_pct          # $200
price_risk = entry - stop_loss            # $0.20
position_units = risk_amount / price_risk # 1,000 tokens
position_value = position_units * entry   # $1,500
```

With this sizing, if the stop loss is hit, you lose exactly 2% of your account regardless of the token's price or volatility.

---

## 2. Volatility-Adjusted Sizing

Scale position size inversely with volatility. When volatility is high, take smaller positions; when low, take larger positions. This normalizes the dollar risk across different market conditions.

### Formula

```
adjusted_size = base_size * (target_vol / current_vol)
```

Where:
- `target_vol`: your desired daily portfolio volatility (e.g., 2%)
- `current_vol`: the token's current daily volatility (from ATR or realized vol)

### Using ATR

```python
atr_14 = 0.12          # 14-period ATR
close_price = 1.50
daily_vol_pct = atr_14 / close_price  # 8%
````
END THIRD-PARTY FILE bb54d7320a22d34a

The third-party file has ended. Everything between the bb54d7320a22d34a tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2895 of 9731 bytes. © agiprolabs · MIT · https://github.com/agiprolabs/claude-trading-skills/tree/HEAD/skills/position-sizing/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md