exit-strategies

Files (6)

• SKILL.md
• stop_loss_methods.md · references/
• take_profit_strategies.md · references/
• trailing_stops.md · references/
• exit_simulator.py · scripts/
• stop_loss_calculator.py · scripts/

SKILL.md (first lines)

# Exit Strategies

Entries are easy, exits are everything. A mediocre entry with a disciplined exit will
outperform a perfect entry with no exit plan. This skill covers systematic, rule-based
exit methods for crypto and Solana token trading.

## Why Exits Matter

- **Entries** determine _if_ you participate. **Exits** determine _how much_ you keep.
- Most traders spend 90% of effort on entries and 10% on exits — invert this.
- Without defined exits you rely on emotion, which guarantees inconsistency.
- Every trade should have **three exits defined before entry**: stop loss, take profit,
  and trailing stop.

## Exit Categories

### 1. Stop Loss — Risk Management Exits

Predefined price level where you close the position to cap downside.

| Method | Description | Best For |
|--------|-------------|----------|
| Fixed percentage | Exit at entry − X% | Simple setups, beginners |
| ATR-based | Entry − ATR(14) × multiplier | Volatility-adaptive |
| Support level | Below nearest swing low | Technically defined risk |
| Maximum loss | Absolute SOL/USD cap | Account protection |

**ATR-based stop (recommended default):**

```python
import pandas_ta as ta

atr = df.ta.atr(length=14)
stop_loss = entry_price - (atr.iloc[-1] * 2.0)  # 2x ATR below entry
```

Multiplier guide:
- **1.5×** — Tight. High win rate needed. Good for scalps.
- **2.0×** — Standard. Balances noise filtering with risk.
- **3.0×** — Wide. For swing trades in volatile conditions.

See `references/stop_loss_methods.md` for complete methodology.

### 2. Take Profit — Target Exits

Predefined levels where you lock in gains.

**Fixed risk/reward targets:**

```python
risk = entry_price - stop_loss_price
tp_2r = entry_price + (risk * 2)  # 2:1 R:R
tp_3r = entry_price + (risk * 3)  # 3:1 R:R
tp_5r = entry_price + (risk * 5)  # 5:1 R:R
```

**Scaled exit framework (recommended for meme/PumpFun tokens):**

| Tranche | Size | Target | Action After |
|---------|------|--------|--------------|
| 1 | 25% | 2× risk | Move stop to breakeven |
| 2 | 25% | 3–5× risk | Trail remainder |
| 3 | 25% | 5–10× risk | Tighten trail |
| 4 | 25% | Trailing stop | Moonbag — let it ride |

**Market cap milestone exits:**

For PumpFun and meme tokens where R:R ratios are less meaningful:

```python
milestones = [
    {"mcap": 50_000,  "sell_pct": 0.25, "label": "Cover cost"},
    {"mcap": 100_000, "sell_pct": 0.25, "label": "Lock profit"},
    {"mcap": 500_000, "sell_pct": 0.25, "label": "Major profit"},
    # Hold 25% as moonbag with trailing stop
]
```

See `references/take_profit_strategies.md` for full methodology including Fibonacci
extension targets and volume-based exits.

### 3. Trailing Stop — Trend-Following Exits

Dynamic stops that follow price upward but never move down.

**Percentage trailing:**

```python
def percentage_trailing_stop(
    current_price: float,
    highest_since_entry: float,
    trail_pct: float = 0.10,
) -> tuple[float, bool]:
    """Return (stop_level, triggered)."""
    highest = max(highest_since_entry, current_price)
    stop = highest * (1 - trail_pct)
    return stop, current_price <= stop
```

**ATR trailing (Chandelier Exit):**

```python
def chandelier_exit(
    highs: list[float],
    atr_value: float,
    multiplier: float = 2.5,
    lookback: int = 22,
) -> float:
    """Highest high over lookback minus ATR * multiplier."""
    highest_high = max(highs[-lookback:])
    return highest_high - (atr_value * multiplier)
```

**EMA trailing:**

```python
# Exit when close < EMA for M consecutive bars
ema = df.ta.ema(length=20)
below_ema = df["close"] < ema

From Serennity007/awesome-stock-quant-skills, MIT.

More from Serennity007/awesome-stock-quant-skills