[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M70KB1H4M5MMS8FZYNVY6AWX":3,"skill-same:01M70KB1H4M5MMS8FZYNVY6AWX":64},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":35,"linkOnly":36,"markdownContent":37,"markdownBody":38,"frontMatter":39,"refName":40,"commitSha":41,"skillDirectory":42,"forksCount":43,"repositoryHtmlUrl":44,"repositoryHomepageUrl":45,"ownerHtmlUrl":46,"ownerBlogUrl":47,"ownerDescription":48,"updatedAt":49,"install":50,"resources":63},"01M70KB1H4M5MMS8FZYNVY6AWX","backtesting-frameworks",null,"Build robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developing trading algorithms, validating strategies, or building backtesting infrastructure.","shengdabai\u002FTony-Claude-Code-Skills","shengdabai","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F116417419?v=4","01M70F6D2WY5PQV5A92BKYJQEW","Tony Sheng","01M70F6D3GAAAYZ5H4CC1G8VXM",3,"MIT","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002F_collections\u002Fwshobson-agents\u002Fplugins\u002Fquantitative-trading\u002Fskills\u002Fbacktesting-frameworks\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34],"backtesting","frameworks","backtesting frameworks","for","bias","use","when","with","transaction","strategies","build","systems","look","trading","algorithms","infrastructure","2026-11-10 10:12:30",false,"---\nname: backtesting-frameworks\ndescription: Build robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developing trading algorithms, validating strategies, or building backtesting infrastructure.\n---\n\n# Backtesting Frameworks\n\nBuild robust, production-grade backtesting systems that avoid common pitfalls and produce reliable strategy performance estimates.\n\n## When to Use This Skill\n\n- Developing trading strategy backtests\n- Building backtesting infrastructure\n- Validating strategy performance\n- Avoiding common backtesting biases\n- Implementing walk-forward analysis\n- Comparing strategy alternatives\n\n## Core Concepts\n\n### 1. Backtesting Biases\n\n| Bias | Description | Mitigation |\n|------|-------------|------------|\n| **Look-ahead** | Using future information | Point-in-time data |\n| **Survivorship** | Only testing on survivors | Use delisted securities |\n| **Overfitting** | Curve-fitting to history | Out-of-sample testing |\n| **Selection** | Cherry-picking strategies | Pre-registration |\n| **Transaction** | Ignoring trading costs | Realistic cost models |\n\n### 2. Proper Backtest Structure\n\n```\nHistorical Data\n      │\n      ▼\n┌─────────────────────────────────────────┐\n│              Training Set               │\n│  (Strategy Development & Optimization)  │\n└─────────────────────────────────────────┘\n      │\n      ▼\n┌─────────────────────────────────────────┐\n│             Validation Set              │\n│  (Parameter Selection, No Peeking)      │\n└─────────────────────────────────────────┘\n      │\n      ▼\n┌─────────────────────────────────────────┐\n│               Test Set                  │\n│  (Final Performance Evaluation)         │\n└─────────────────────────────────────────┘\n```\n\n### 3. Walk-Forward Analysis\n\n```\nWindow 1: [Train──────][Test]\nWindow 2:     [Train──────][Test]\nWindow 3:         [Train──────][Test]\nWindow 4:             [Train──────][Test]\n                                     ─────▶ Time\n```\n\n## Implementation Patterns\n\n### Pattern 1: Event-Driven Backtester\n\n```python\nfrom abc import ABC, abstractmethod\nfrom dataclasses import dataclass, field\nfrom datetime import datetime\nfrom decimal import Decimal\nfrom enum import Enum\nfrom typing import Dict, List, Optional\nimport pandas as pd\nimport numpy as np\n\nclass OrderSide(Enum):\n    BUY = \"buy\"\n    SELL = \"sell\"\n\nclass OrderType(Enum):\n    MARKET = \"market\"\n    LIMIT = \"limit\"\n    STOP = \"stop\"\n\n@dataclass\nclass Order:\n    symbol: str\n    side: OrderSide\n    quantity: Decimal\n    order_type: OrderType\n    limit_price: Optional[Decimal] = None\n    stop_price: Optional[Decimal] = None\n    timestamp: Optional[datetime] = None\n\n@dataclass\nclass Fill:\n    order: Order\n    fill_price: Decimal\n    fill_quantity: Decimal\n    commission: Decimal\n    slippage: Decimal\n    timestamp: datetime\n\n@dataclass\nclass Position:\n    symbol: str\n    quantity: Decimal = Decimal(\"0\")\n    avg_cost: Decimal = Decimal(\"0\")\n    realized_pnl: Decimal = Decimal(\"0\")\n\n    def update(self, fill: Fill) -> None:\n        if fill.order.side == OrderSide.BUY:\n            new_quantity = self.quantity + fill.fill_quantity\n            if new_quantity != 0:\n                self.avg_cost = (\n                    (self.quantity * self.avg_cost + fill.fill_quantity * fill.fill_price)\n                    \u002F new_quantity\n                )\n            self.quantity = new_quantity\n        else:\n            self.realized_pnl += fill.fill_quantity * (fill.fill_price - self.avg_cost)\n            self.quantity -= fill.fill_quantity\n\n@dataclass\nclass Portfolio:\n    cash: Decimal\n    positions: Dict[str, Position] = field(default_factory=dict)\n\n    def get_position(self, symbol: str) -> Position:\n        if symbol not in self.positions:\n            self.positions[symbol] = Position(symbol=symbol)\n        return self.positions[symbol]\n\n    def process_fill(self, fill: Fill) -> None:\n        position = self.get_position(fill.order.symbol)\n        position.update(fill)\n\n        if fill.order.side == OrderSide.BUY:\n            self.cash -= fill.fill_price * fill.fill_quantity + fill.commission\n        else:\n            self.cash += fill.fill_price * fill.fill_quantity - fill.commission\n\n    def get_equity(self, prices: Dict[str, Decimal]) -> Decimal:\n        equity = self.cash\n        for symbol, position in self.positions.items():\n            if position.quantity != 0 and symbol in prices:\n                equity += position.quantity * prices[symbol]\n        return equity\n\nclass Strategy(ABC):\n    @abstractmethod\n    def on_bar(self, timestamp: datetime, data: pd.DataFrame) -> List[Order]:\n        pass\n\n    @abstractmethod\n    def on_fill(self, fill: Fill) -> None:\n        pass\n\nclass ExecutionModel(ABC):\n    @abstractmethod\n    def execute(self, order: Order, bar: pd.Series) -> Optional[Fill]:\n        pass\n\nclass SimpleExecutionModel(ExecutionModel):\n    def __init__(self, slippage_bps: float = 10, commission_per_share: float = 0.01):\n        self.slippage_bps = slippage_bps\n        self.commission_per_share = commission_per_share\n\n    def execute(self, order: Order, bar: pd.Series) -> Optional[Fill]:\n        if order.order_type == OrderType.MARKET:\n            base_price = Decimal(str(bar[\"open\"]))\n\n            # Apply slippage\n            slippage_mult = 1 + (self.slippage_bps \u002F 10000)\n            if order.side == OrderSide.BUY:\n                fill_price = base_price * Decimal(str(slippage_mult))\n            else:\n                fill_price = base_price \u002F Decimal(str(slippage_mult))\n\n            commission = order.quantity * Decimal(str(self.commission_per_share))\n            slippage = abs(fill_price - base_price) * order.quantity\n\n            return Fill(\n                order=order,\n                fill_price=fill_price,\n                fill_quantity=order.quantity,\n                commission=commission,\n                slippage=slippage,\n                timestamp=bar.name\n            )\n        return None\n\nclass Backtester:\n    def __init__(\n        self,\n        strategy: Strategy,\n        execution_model: ExecutionModel,\n        initial_capital: Decimal = Decimal(\"100000\")\n    ):\n        self.strategy = strategy\n        self.execution_model = execution_model\n        self.portfolio = Portfolio(cash=initial_capital)\n        self.equity_curve: List[tuple] = []\n        self.trades: List[Fill] = []\n\n    def run(self, data: pd.DataFrame) -> pd.DataFrame:\n        \"\"\"Run backtest on OHLCV data with DatetimeIndex.\"\"\"\n        pending_orders: List[Order] = []\n\n        for timestamp, bar in data.iterrows():\n            # Execute pending orders at today's prices\n            for order in pending_orders:\n                fill = self.execution_model.execute(order, bar)\n                if fill:\n                    self.portfolio.process_fill(fill)\n                    self.strategy.on_fill(fill)\n                    self.trades.append(fill)\n\n            pending_orders.clear()\n\n            # Get current prices for equity calculation\n            prices = {data.index.name or \"default\": Decimal(str(bar[\"close\"]))}\n            equity = self.portfolio.get_equity(prices)\n            self.equity_curve.append((timestamp, float(equity)))\n\n            # Generate new orders for next bar\n            new_orders = self.strategy.on_bar(timestamp, data.loc[:timestamp])\n            pending_orders.extend(new_orders)\n\n        return self._create_results()\n\n    def _create_results(self) -> pd.DataFrame:\n        equity_df = pd.DataFrame(self.equity_curve, columns=[\"timestamp\", \"equity\"])\n        equity_df.set_index(\"timestamp\", inplace=True)\n        equity_df[\"returns\"] = equity_df[\"equity\"].pct_change()\n        return equity_df\n```\n\n### Pattern 2: Vectorized Backtester (Fast)\n\n```python\nimport pandas as pd\nimport numpy as np\nfrom typing import Callable, Dict, Any\n\nclass VectorizedBacktester:\n    \"\"\"Fast vectorized backtester for simple strategies.\"\"\"\n\n    def __init__(\n        self,\n        initial_capital: float = 100000,\n        commission: float = 0.001,  # 0.1%\n        slippage: float = 0.0005   # 0.05%\n    ):\n        self.initial_capital = initial_capital\n        self.commission = commission\n        self.slippage = slippage\n\n    def run(\n        self,\n        prices: pd.DataFrame,\n        signal_func: Callable[[pd.DataFrame], pd.Series]\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Run backtest with signal function.\n\n        Args:\n            prices: DataFrame with 'close' column\n            signal_func: Function that returns position signals (-1, 0, 1)\n\n        Returns:\n            Dictionary with results\n        \"\"\"\n        # Generate signals (shifted to avoid look-ahead)\n        signals = signal_func(prices).shift(1).fillna(0)\n\n        # Calculate returns\n        returns = prices[\"close\"].pct_change()\n\n        # Calculate strategy returns with costs\n        position_changes = signals.diff().abs()\n        trading_costs = position_changes * (self.commission + self.slippage)\n\n        strategy_returns = signals * returns - trading_costs\n\n        # Build equity curve\n        equity = (1 + strategy_returns).cumprod() * self.initial_capital\n\n        # Calculate metrics\n        results = {\n            \"equity\": equity,\n            \"returns\": strategy_returns,\n            \"signals\": signals,\n            \"metrics\": self._calculate_metrics(strategy_returns, equity)\n        }\n\n        return results\n\n    def _calculate_metrics(\n        self,\n        returns: pd.Series,\n        equity: pd.Series\n    ) -> Dict[str, float]:\n        \"\"\"Calculate performance metrics.\"\"\"\n        total_return = (equity.iloc[-1] \u002F self.initial_capital) - 1\n        annual_return = (1 + total_return) ** (252 \u002F len(returns)) - 1\n        annual_vol = returns.std() * np.sqrt(252)\n        sharpe = annual_return \u002F annual_vol if annual_vol > 0 else 0\n\n        # Drawdown\n        rolling_max = equity.cummax()\n        drawdown = (equity - rolling_max) \u002F rolling_max\n        max_drawdown = drawdown.min()\n\n        # Win rate\n        winning_days = (returns > 0).sum()\n        total_days = (returns != 0).sum()\n        win_rate = winning_days \u002F total_days if total_days > 0 else 0\n\n        return {\n            \"total_return\": total_return,\n            \"annual_return\": annual_return,\n            \"annual_volatility\": annual_vol,\n            \"sharpe_ratio\": sharpe,\n            \"max_drawdown\": max_drawdown,\n            \"win_rate\": win_rate,\n            \"num_trades\": int((returns != 0).sum())\n        }\n\n# Example usage\ndef momentum_signal(prices: pd.DataFrame, lookback: int = 20) -> pd.Series:\n    \"\"\"Simple momentum strategy: long when price > SMA, else flat.\"\"\"\n    sma = prices[\"close\"].rolling(lookback).mean()\n    return (prices[\"close\"] > sma).astype(int)\n\n# Run backtest\n# backtester = VectorizedBacktester()\n# results = backtester.run(price_data, lambda p: momentum_signal(p, 50))\n```\n\n### Pattern 3: Walk-Forward Optimization\n\n```python\nfrom typing import Callable, Dict, List, Tuple, Any\nimport pandas as pd\nimport numpy as np\nfrom itertools import product\n\nclass WalkForwardOptimizer:\n    \"\"\"Walk-forward analysis with anchored or rolling windows.\"\"\"\n\n    def __init__(\n        self,\n        train_period: int,\n        test_period: int,\n        anchored: bool = False,\n        n_splits: int = None\n    ):\n        \"\"\"\n        Args:\n            train_period: Number of bars in training window\n            test_period: Number of bars in test window\n            anchored: If True, training always starts from beginning\n            n_splits: Number of train\u002Ftest splits (auto-calculated if None)\n        \"\"\"\n        self.train_period = train_period\n        self.test_period = test_period\n        self.anchored = anchored\n        self.n_splits = n_splits\n\n    def generate_splits(\n        self,\n        data: pd.DataFrame\n    ) -> List[Tuple[pd.DataFrame, pd.DataFrame]]:\n        \"\"\"Generate train\u002Ftest splits.\"\"\"\n        splits = []\n        n = len(data)\n\n        if self.n_splits:\n            step = (n - self.train_period) \u002F\u002F self.n_splits\n        else:\n            step = self.test_period\n\n        start = 0\n        while start + self.train_period + self.test_period \u003C= n:\n            if self.anchored:\n                train_start = 0\n            else:\n                train_start = start\n\n            train_end = start + self.train_period\n            test_end = min(train_end + self.test_period, n)\n\n            train_data = data.iloc[train_start:train_end]\n            test_data = data.iloc[train_end:test_end]\n\n            splits.append((train_data, test_data))\n            start += step\n\n        return splits\n\n    def optimize(\n        self,\n        data: pd.DataFrame,\n        strategy_func: Callable,\n        param_grid: Dict[str, List],\n        metric: str = \"sharpe_ratio\"\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Run walk-forward optimization.\n\n        Args:\n            data: Full dataset\n            strategy_func: Function(data, **params) -> results dict\n            param_grid: Parameter combinations to test\n            metric: Metric to optimize\n\n        Returns:\n            Combined results from all test periods\n        \"\"\"\n        splits = self.generate_splits(data)\n        all_results = []\n        optimal_params_history = []\n\n        for i, (train_data, test_data) in enumerate(splits):\n            # Optimize on training data\n            best_params, best_metric = self._grid_search(\n                train_data, strategy_func, param_grid, metric\n            )\n            optimal_params_history.append(best_params)\n\n            # Test with optimal params\n            test_results = strategy_func(test_data, **best_params)\n            test_results[\"split\"] = i\n            test_results[\"params\"] = best_params\n            all_results.append(test_results)\n\n            print(f\"Split {i+1}\u002F{len(splits)}: \"\n                  f\"Best {metric}={best_metric:.4f}, params={best_params}\")\n\n        return {\n            \"split_results\": all_results,\n            \"param_history\": optimal_params_history,\n            \"combined_equity\": self._combine_equity_curves(all_results)\n        }\n\n    def _grid_search(\n        self,\n        data: pd.DataFrame,\n        strategy_func: Callable,\n        param_grid: Dict[str, List],\n        metric: str\n    ) -> Tuple[Dict, float]:\n        \"\"\"Grid search for best parameters.\"\"\"\n        best_params = None\n        best_metric = -np.inf\n\n        # Generate all parameter combinations\n        param_names = list(param_grid.keys())\n        param_values = list(param_grid.values())\n\n        for values in product(*param_values):\n            params = dict(zip(param_names, values))\n            results = strategy_func(data, **params)\n\n            if results[\"metrics\"][metric] > best_metric:\n                best_metric = results[\"metrics\"][metric]\n                best_params = params\n\n        return best_params, best_metric\n\n    def _combine_equity_curves(\n        self,\n        results: List[Dict]\n    ) -> pd.Series:\n        \"\"\"Combine equity curves from all test periods.\"\"\"\n        combined = pd.concat([r[\"equity\"] for r in results])\n        return combined\n```\n\n### Pattern 4: Monte Carlo Analysis\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom typing import Dict, List\n\nclass MonteCarloAnalyzer:\n    \"\"\"Monte Carlo simulation for strategy robustness.\"\"\"\n\n    def __init__(self, n_simulations: int = 1000, confidence: float = 0.95):\n        self.n_simulations = n_simulations\n        self.confidence = confidence\n\n    def bootstrap_returns(\n        self,\n        returns: pd.Series,\n        n_periods: int = None\n    ) -> np.ndarray:\n        \"\"\"\n        Bootstrap simulation by resampling returns.\n\n        Args:\n            returns: Historical returns series\n            n_periods: Length of each simulation (default: same as input)\n\n        Returns:\n            Array of shape (n_simulations, n_periods)\n        \"\"\"\n        if n_periods is None:\n            n_periods = len(returns)\n\n        simulations = np.zeros((self.n_simulations, n_periods))\n\n        for i in range(self.n_simulations):\n            # Resample with replacement\n            simulated_returns = np.random.choice(\n                returns.values,\n                size=n_periods,\n                replace=True\n            )\n            simulations[i] = simulated_returns\n\n        return simulations\n\n    def analyze_drawdowns(\n        self,\n        returns: pd.Series\n    ) -> Dict[str, float]:\n        \"\"\"Analyze drawdown distribution via simulation.\"\"\"\n        simulations = self.bootstrap_returns(returns)\n\n        max_drawdowns = []\n        for sim_returns in simulations:\n            equity = (1 + sim_returns).cumprod()\n            rolling_max = np.maximum.accumulate(equity)\n            drawdowns = (equity - rolling_max) \u002F rolling_max\n            max_drawdowns.append(drawdowns.min())\n\n        max_drawdowns = np.array(max_drawdowns)\n\n        return {\n            \"expected_max_dd\": np.mean(max_drawdowns),\n            \"median_max_dd\": np.median(max_drawdowns),\n            f\"worst_{int(self.confidence*100)}pct\": np.percentile(\n                max_drawdowns, (1 - self.confidence) * 100\n            ),\n            \"worst_case\": max_drawdowns.min()\n        }\n\n    def probability_of_loss(\n        self,\n        returns: pd.Series,\n        holding_periods: List[int] = [21, 63, 126, 252]\n    ) -> Dict[int, float]:\n        \"\"\"Calculate probability of loss over various holding periods.\"\"\"\n        results = {}\n\n        for period in holding_periods:\n            if period > len(returns):\n                continue\n\n            simulations = self.bootstrap_returns(returns, period)\n            total_returns = (1 + simulations).prod(axis=1) - 1\n            prob_loss = (total_returns \u003C 0).mean()\n            results[period] = prob_loss\n\n        return results\n\n    def confidence_interval(\n        self,\n        returns: pd.Series,\n        periods: int = 252\n    ) -> Dict[str, float]:\n        \"\"\"Calculate confidence interval for future returns.\"\"\"\n        simulations = self.bootstrap_returns(returns, periods)\n        total_returns = (1 + simulations).prod(axis=1) - 1\n\n        lower = (1 - self.confidence) \u002F 2\n        upper = 1 - lower\n\n        return {\n            \"expected\": total_returns.mean(),\n            \"lower_bound\": np.percentile(total_returns, lower * 100),\n            \"upper_bound\": np.percentile(total_returns, upper * 100),\n            \"std\": total_returns.std()\n        }\n```\n\n## Performance Metrics\n\n```python\ndef calculate_metrics(returns: pd.Series, rf_rate: float = 0.02) -> Dict[str, float]:\n    \"\"\"Calculate comprehensive performance metrics.\"\"\"\n    # Annualization factor (assuming daily returns)\n    ann_factor = 252\n\n    # Basic metrics\n    total_return = (1 + returns).prod() - 1\n    annual_return = (1 + total_return) ** (ann_factor \u002F len(returns)) - 1\n    annual_vol = returns.std() * np.sqrt(ann_factor)\n\n    # Risk-adjusted returns\n    sharpe = (annual_return - rf_rate) \u002F annual_vol if annual_vol > 0 else 0\n\n    # Sortino (downside deviation)\n    downside_returns = returns[returns \u003C 0]\n    downside_vol = downside_returns.std() * np.sqrt(ann_factor)\n    sortino = (annual_return - rf_rate) \u002F downside_vol if downside_vol > 0 else 0\n\n    # Calmar ratio\n    equity = (1 + returns).cumprod()\n    rolling_max = equity.cummax()\n    drawdowns = (equity - rolling_max) \u002F rolling_max\n    max_drawdown = drawdowns.min()\n    calmar = annual_return \u002F abs(max_drawdown) if max_drawdown != 0 else 0\n\n    # Win rate and profit factor\n    wins = returns[returns > 0]\n    losses = returns[returns \u003C 0]\n    win_rate = len(wins) \u002F len(returns[returns != 0]) if len(returns[returns != 0]) > 0 else 0\n    profit_factor = wins.sum() \u002F abs(losses.sum()) if losses.sum() != 0 else np.inf\n\n    return {\n        \"total_return\": total_return,\n        \"annual_return\": annual_return,\n        \"annual_volatility\": annual_vol,\n        \"sharpe_ratio\": sharpe,\n        \"sortino_ratio\": sortino,\n        \"calmar_ratio\": calmar,\n        \"max_drawdown\": max_drawdown,\n        \"win_rate\": win_rate,\n        \"profit_factor\": profit_factor,\n        \"num_trades\": int((returns != 0).sum())\n    }\n```\n\n## Best Practices\n\n### Do's\n- **Use point-in-time data** - Avoid look-ahead bias\n- **Include transaction costs** - Realistic estimates\n- **Test out-of-sample** - Always reserve data\n- **Use walk-forward** - Not just train\u002Ftest\n- **Monte Carlo analysis** - Understand uncertainty\n\n### Don'ts\n- **Don't overfit** - Limit parameters\n- **Don't ignore survivorship** - Include delisted\n- **Don't use adjusted data carelessly** - Understand adjustments\n- **Don't optimize on full history** - Reserve test set\n- **Don't ignore capacity** - Market impact matters\n\n## Resources\n\n- [Advances in Financial Machine Learning (Marcos López de Prado)](https:\u002F\u002Fwww.amazon.com\u002FAdvances-Financial-Machine-Learning-Marcos\u002Fdp\u002F1119482089)\n- [Quantitative Trading (Ernest Chan)](https:\u002F\u002Fwww.amazon.com\u002FQuantitative-Trading-Build-Algorithmic-Business\u002Fdp\u002F1119800064)\n- [Backtrader Documentation](https:\u002F\u002Fwww.backtrader.com\u002Fdocu\u002F)\n","# Backtesting Frameworks\n\nBuild robust, production-grade backtesting systems that avoid common pitfalls and produce reliable strategy performance estimates.\n\n## When to Use This Skill\n\n- Developing trading strategy backtests\n- Building backtesting infrastructure\n- Validating strategy performance\n- Avoiding common backtesting biases\n- Implementing walk-forward analysis\n- Comparing strategy alternatives\n\n## Core Concepts\n\n### 1. Backtesting Biases\n\n| Bias | Description | Mitigation |\n|------|-------------|------------|\n| **Look-ahead** | Using future information | Point-in-time data |\n| **Survivorship** | Only testing on survivors | Use delisted securities |\n| **Overfitting** | Curve-fitting to history | Out-of-sample testing |\n| **Selection** | Cherry-picking strategies | Pre-registration |\n| **Transaction** | Ignoring trading costs | Realistic cost models |\n\n### 2. Proper Backtest Structure\n\n```\nHistorical Data\n      │\n      ▼\n┌─────────────────────────────────────────┐\n│              Training Set               │\n│  (Strategy Development & Optimization)  │\n└─────────────────────────────────────────┘\n      │\n      ▼\n┌─────────────────────────────────────────┐\n│             Validation Set              │\n│  (Parameter Selection, No Peeking)      │\n└─────────────────────────────────────────┘\n      │\n      ▼\n┌─────────────────────────────────────────┐\n│               Test Set                  │\n│  (Final Performance Evaluation)         │\n└─────────────────────────────────────────┘\n```\n\n### 3. Walk-Forward Analysis\n\n```\nWindow 1: [Train──────][Test]\nWindow 2:     [Train──────][Test]\nWindow 3:         [Train──────][Test]\nWindow 4:             [Train──────][Test]\n                                     ─────▶ Time\n```\n\n## Implementation Patterns\n\n### Pattern 1: Event-Driven Backtester\n\n```python\nfrom abc import ABC, abstractmethod\nfrom dataclasses import dataclass, field\nfrom datetime import datetime\nfrom decimal import Decimal\nfrom enum import Enum\nfrom typing import Dict, List, Optional\nimport pandas as pd\nimport numpy as np\n\nclass OrderSide(Enum):\n    BUY = \"buy\"\n    SELL = \"sell\"\n\nclass OrderType(Enum):\n    MARKET = \"market\"\n    LIMIT = \"limit\"\n    STOP = \"stop\"\n\n@dataclass\nclass Order:\n    symbol: str\n    side: OrderSide\n    quantity: Decimal\n    order_type: OrderType\n    limit_price: Optional[Decimal] = None\n    stop_price: Optional[Decimal] = None\n    timestamp: Optional[datetime] = None\n\n@dataclass\nclass Fill:\n    order: Order\n    fill_price: Decimal\n    fill_quantity: Decimal\n    commission: Decimal\n    slippage: Decimal\n    timestamp: datetime\n\n@dataclass\nclass Position:\n    symbol: str\n    quantity: Decimal = Decimal(\"0\")\n    avg_cost: Decimal = Decimal(\"0\")\n    realized_pnl: Decimal = Decimal(\"0\")\n\n    def update(self, fill: Fill) -> None:\n        if fill.order.side == OrderSide.BUY:\n            new_quantity = self.quantity + fill.fill_quantity\n            if new_quantity != 0:\n                self.avg_cost = (\n                    (self.quantity * self.avg_cost + fill.fill_quantity * fill.fill_price)\n                    \u002F new_quantity\n                )\n            self.quantity = new_quantity\n        else:\n            self.realized_pnl += fill.fill_quantity * (fill.fill_price - self.avg_cost)\n            self.quantity -= fill.fill_quantity\n\n@dataclass\nclass Portfolio:\n    cash: Decimal\n    positions: Dict[str, Position] = field(default_factory=dict)\n\n    def get_position(self, symbol: str) -> Position:\n        if symbol not in self.positions:\n            self.positions[symbol] = Position(symbol=symbol)\n        return self.positions[symbol]\n\n    def process_fill(self, fill: Fill) -> None:\n        position = self.get_position(fill.order.symbol)\n        position.update(fill)\n\n        if fill.order.side == OrderSide.BUY:\n            self.cash -= fill.fill_price * fill.fill_quantity + fill.commission\n        else:\n            self.cash += fill.fill_price * fill.fill_quantity - fill.commission\n\n    def get_equity(self, prices: Dict[str, Decimal]) -> Decimal:\n        equity = self.cash\n        for symbol, position in self.positions.items():\n            if position.quantity != 0 and symbol in prices:\n                equity += position.quantity * prices[symbol]\n        return equity\n\nclass Strategy(ABC):\n    @abstractmethod\n    def on_bar(self, timestamp: datetime, data: pd.DataFrame) -> List[Order]:\n        pass\n\n    @abstractmethod\n    def on_fill(self, fill: Fill) -> None:\n        pass\n\nclass ExecutionModel(ABC):\n    @abstractmethod\n    def execute(self, order: Order, bar: pd.Series) -> Optional[Fill]:\n        pass\n\nclass SimpleExecutionModel(ExecutionModel):\n    def __init__(self, slippage_bps: float = 10, commission_per_share: float = 0.01):\n        self.slippage_bps = slippage_bps\n        self.commission_per_share = commission_per_share\n\n    def execute(self, order: Order, bar: pd.Series) -> Optional[Fill]:\n        if order.order_type == OrderType.MARKET:\n            base_price = Decimal(str(bar[\"open\"]))\n\n            # Apply slippage\n            slippage_mult = 1 + (self.slippage_bps \u002F 10000)\n            if order.side == OrderSide.BUY:\n                fill_price = base_price * Decimal(str(slippage_mult))\n            else:\n                fill_price = base_price \u002F Decimal(str(slippage_mult))\n\n            commission = order.quantity * Decimal(str(self.commission_per_share))\n            slippage = abs(fill_price - base_price) * order.quantity\n\n            return Fill(\n                order=order,\n                fill_price=fill_price,\n                fill_quantity=order.quantity,\n                commission=commission,\n                slippage=slippage,\n                timestamp=bar.name\n            )\n        return None\n\nclass Backtester:\n    def __init__(\n        self,\n        strategy: Strategy,\n        execution_model: ExecutionModel,\n        initial_capital: Decimal = Decimal(\"100000\")\n    ):\n        self.strategy = strategy\n        self.execution_model = execution_model\n        self.portfolio = Portfolio(cash=initial_capital)\n        self.equity_curve: List[tuple] = []\n        self.trades: List[Fill] = []\n\n    def run(self, data: pd.DataFrame) -> pd.DataFrame:\n        \"\"\"Run backtest on OHLCV data with DatetimeIndex.\"\"\"\n        pending_orders: List[Order] = []\n\n        for timestamp, bar in data.iterrows():\n            # Execute pending orders at today's prices\n            for order in pending_orders:\n                fill = self.execution_model.execute(order, bar)\n                if fill:\n                    self.portfolio.process_fill(fill)\n                    self.strategy.on_fill(fill)\n                    self.trades.append(fill)\n\n            pending_orders.clear()\n\n            # Get current prices for equity calculation\n            prices = {data.index.name or \"default\": Decimal(str(bar[\"close\"]))}\n            equity = self.portfolio.get_equity(prices)\n            self.equity_curve.append((timestamp, float(equity)))\n\n            # Generate new orders for next bar\n            new_orders = self.strategy.on_bar(timestamp, data.loc[:timestamp])\n            pending_orders.extend(new_orders)\n\n        return self._create_results()\n\n    def _create_results(self) -> pd.DataFrame:\n        equity_df = pd.DataFrame(self.equity_curve, columns=[\"timestamp\", \"equity\"])\n        equity_df.set_index(\"timestamp\", inplace=True)\n        equity_df[\"returns\"] = equity_df[\"equity\"].pct_change()\n        return equity_df\n```\n\n### Pattern 2: Vectorized Backtester (Fast)\n\n```python\nimport pandas as pd\nimport numpy as np\nfrom typing import Callable, Dict, Any\n\nclass VectorizedBacktester:\n    \"\"\"Fast vectorized backtester for simple strategies.\"\"\"\n\n    def __init__(\n        self,\n        initial_capital: float = 100000,\n        commission: float = 0.001,  # 0.1%\n        slippage: float = 0.0005   # 0.05%\n    ):\n        self.initial_capital = initial_capital\n        self.commission = commission\n        self.slippage = slippage\n\n    def run(\n        self,\n        prices: pd.DataFrame,\n        signal_func: Callable[[pd.DataFrame], pd.Series]\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Run backtest with signal function.\n\n        Args:\n            prices: DataFrame with 'close' column\n            signal_func: Function that returns position signals (-1, 0, 1)\n\n        Returns:\n            Dictionary with results\n        \"\"\"\n        # Generate signals (shifted to avoid look-ahead)\n        signals = signal_func(prices).shift(1).fillna(0)\n\n        # Calculate returns\n        returns = prices[\"close\"].pct_change()\n\n        # Calculate strategy returns with costs\n        position_changes = signals.diff().abs()\n        trading_costs = position_changes * (self.commission + self.slippage)\n\n        strategy_returns = signals * returns - trading_costs\n\n        # Build equity curve\n        equity = (1 + strategy_returns).cumprod() * self.initial_capital\n\n        # Calculate metrics\n        results = {\n            \"equity\": equity,\n            \"returns\": strategy_returns,\n            \"signals\": signals,\n            \"metrics\": self._calculate_metrics(strategy_returns, equity)\n        }\n\n        return results\n\n    def _calculate_metrics(\n        self,\n        returns: pd.Series,\n        equity: pd.Series\n    ) -> Dict[str, float]:\n        \"\"\"Calculate performance metrics.\"\"\"\n        total_return = (equity.iloc[-1] \u002F self.initial_capital) - 1\n        annual_return = (1 + total_return) ** (252 \u002F len(returns)) - 1\n        annual_vol = returns.std() * np.sqrt(252)\n        sharpe = annual_return \u002F annual_vol if annual_vol > 0 else 0\n\n        # Drawdown\n        rolling_max = equity.cummax()\n        drawdown = (equity - rolling_max) \u002F rolling_max\n        max_drawdown = drawdown.min()\n\n        # Win rate\n        winning_days = (returns > 0).sum()\n        total_days = (returns != 0).sum()\n        win_rate = winning_days \u002F total_days if total_days > 0 else 0\n\n        return {\n            \"total_return\": total_return,\n            \"annual_return\": annual_return,\n            \"annual_volatility\": annual_vol,\n            \"sharpe_ratio\": sharpe,\n            \"max_drawdown\": max_drawdown,\n            \"win_rate\": win_rate,\n            \"num_trades\": int((returns != 0).sum())\n        }\n\n# Example usage\ndef momentum_signal(prices: pd.DataFrame, lookback: int = 20) -> pd.Series:\n    \"\"\"Simple momentum strategy: long when price > SMA, else flat.\"\"\"\n    sma = prices[\"close\"].rolling(lookback).mean()\n    return (prices[\"close\"] > sma).astype(int)\n\n# Run backtest\n# backtester = VectorizedBacktester()\n# results = backtester.run(price_data, lambda p: momentum_signal(p, 50))\n```\n\n### Pattern 3: Walk-Forward Optimization\n\n```python\nfrom typing import Callable, Dict, List, Tuple, Any\nimport pandas as pd\nimport numpy as np\nfrom itertools import product\n\nclass WalkForwardOptimizer:\n    \"\"\"Walk-forward analysis with anchored or rolling windows.\"\"\"\n\n    def __init__(\n        self,\n        train_period: int,\n        test_period: int,\n        anchored: bool = False,\n        n_splits: int = None\n    ):\n        \"\"\"\n        Args:\n            train_period: Number of bars in training window\n            test_period: Number of bars in test window\n            anchored: If True, training always starts from beginning\n            n_splits: Number of train\u002Ftest splits (auto-calculated if None)\n        \"\"\"\n        self.train_period = train_period\n        self.test_period = test_period\n        self.anchored = anchored\n        self.n_splits = n_splits\n\n    def generate_splits(\n        self,\n        data: pd.DataFrame\n    ) -> List[Tuple[pd.DataFrame, pd.DataFrame]]:\n        \"\"\"Generate train\u002Ftest splits.\"\"\"\n        splits = []\n        n = len(data)\n\n        if self.n_splits:\n            step = (n - self.train_period) \u002F\u002F self.n_splits\n        else:\n            step = self.test_period\n\n        start = 0\n        while start + self.train_period + self.test_period \u003C= n:\n            if self.anchored:\n                train_start = 0\n            else:\n                train_start = start\n\n            train_end = start + self.train_period\n            test_end = min(train_end + self.test_period, n)\n\n            train_data = data.iloc[train_start:train_end]\n            test_data = data.iloc[train_end:test_end]\n\n            splits.append((train_data, test_data))\n            start += step\n\n        return splits\n\n    def optimize(\n        self,\n        data: pd.DataFrame,\n        strategy_func: Callable,\n        param_grid: Dict[str, List],\n        metric: str = \"sharpe_ratio\"\n    ) -> Dict[str, Any]:\n        \"\"\"\n        Run walk-forward optimization.\n\n        Args:\n            data: Full dataset\n            strategy_func: Function(data, **params) -> results dict\n            param_grid: Parameter combinations to test\n            metric: Metric to optimize\n\n        Returns:\n            Combined results from all test periods\n        \"\"\"\n        splits = self.generate_splits(data)\n        all_results = []\n        optimal_params_history = []\n\n        for i, (train_data, test_data) in enumerate(splits):\n            # Optimize on training data\n            best_params, best_metric = self._grid_search(\n                train_data, strategy_func, param_grid, metric\n            )\n            optimal_params_history.append(best_params)\n\n            # Test with optimal params\n            test_results = strategy_func(test_data, **best_params)\n            test_results[\"split\"] = i\n            test_results[\"params\"] = best_params\n            all_results.append(test_results)\n\n            print(f\"Split {i+1}\u002F{len(splits)}: \"\n                  f\"Best {metric}={best_metric:.4f}, params={best_params}\")\n\n        return {\n            \"split_results\": all_results,\n            \"param_history\": optimal_params_history,\n            \"combined_equity\": self._combine_equity_curves(all_results)\n        }\n\n    def _grid_search(\n        self,\n        data: pd.DataFrame,\n        strategy_func: Callable,\n        param_grid: Dict[str, List],\n        metric: str\n    ) -> Tuple[Dict, float]:\n        \"\"\"Grid search for best parameters.\"\"\"\n        best_params = None\n        best_metric = -np.inf\n\n        # Generate all parameter combinations\n        param_names = list(param_grid.keys())\n        param_values = list(param_grid.values())\n\n        for values in product(*param_values):\n            params = dict(zip(param_names, values))\n            results = strategy_func(data, **params)\n\n            if results[\"metrics\"][metric] > best_metric:\n                best_metric = results[\"metrics\"][metric]\n                best_params = params\n\n        return best_params, best_metric\n\n    def _combine_equity_curves(\n        self,\n        results: List[Dict]\n    ) -> pd.Series:\n        \"\"\"Combine equity curves from all test periods.\"\"\"\n        combined = pd.concat([r[\"equity\"] for r in results])\n        return combined\n```\n\n### Pattern 4: Monte Carlo Analysis\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom typing import Dict, List\n\nclass MonteCarloAnalyzer:\n    \"\"\"Monte Carlo simulation for strategy robustness.\"\"\"\n\n    def __init__(self, n_simulations: int = 1000, confidence: float = 0.95):\n        self.n_simulations = n_simulations\n        self.confidence = confidence\n\n    def bootstrap_returns(\n        self,\n        returns: pd.Series,\n        n_periods: int = None\n    ) -> np.ndarray:\n        \"\"\"\n        Bootstrap simulation by resampling returns.\n\n        Args:\n            returns: Historical returns series\n            n_periods: Length of each simulation (default: same as input)\n\n        Returns:\n            Array of shape (n_simulations, n_periods)\n        \"\"\"\n        if n_periods is None:\n            n_periods = len(returns)\n\n        simulations = np.zeros((self.n_simulations, n_periods))\n\n        for i in range(self.n_simulations):\n            # Resample with replacement\n            simulated_returns = np.random.choice(\n                returns.values,\n                size=n_periods,\n                replace=True\n            )\n            simulations[i] = simulated_returns\n\n        return simulations\n\n    def analyze_drawdowns(\n        self,\n        returns: pd.Series\n    ) -> Dict[str, float]:\n        \"\"\"Analyze drawdown distribution via simulation.\"\"\"\n        simulations = self.bootstrap_returns(returns)\n\n        max_drawdowns = []\n        for sim_returns in simulations:\n            equity = (1 + sim_returns).cumprod()\n            rolling_max = np.maximum.accumulate(equity)\n            drawdowns = (equity - rolling_max) \u002F rolling_max\n            max_drawdowns.append(drawdowns.min())\n\n        max_drawdowns = np.array(max_drawdowns)\n\n        return {\n            \"expected_max_dd\": np.mean(max_drawdowns),\n            \"median_max_dd\": np.median(max_drawdowns),\n            f\"worst_{int(self.confidence*100)}pct\": np.percentile(\n                max_drawdowns, (1 - self.confidence) * 100\n            ),\n            \"worst_case\": max_drawdowns.min()\n        }\n\n    def probability_of_loss(\n        self,\n        returns: pd.Series,\n        holding_periods: List[int] = [21, 63, 126, 252]\n    ) -> Dict[int, float]:\n        \"\"\"Calculate probability of loss over various holding periods.\"\"\"\n        results = {}\n\n        for period in holding_periods:\n            if period > len(returns):\n                continue\n\n            simulations = self.bootstrap_returns(returns, period)\n            total_returns = (1 + simulations).prod(axis=1) - 1\n            prob_loss = (total_returns \u003C 0).mean()\n            results[period] = prob_loss\n\n        return results\n\n    def confidence_interval(\n        self,\n        returns: pd.Series,\n        periods: int = 252\n    ) -> Dict[str, float]:\n        \"\"\"Calculate confidence interval for future returns.\"\"\"\n        simulations = self.bootstrap_returns(returns, periods)\n        total_returns = (1 + simulations).prod(axis=1) - 1\n\n        lower = (1 - self.confidence) \u002F 2\n        upper = 1 - lower\n\n        return {\n            \"expected\": total_returns.mean(),\n            \"lower_bound\": np.percentile(total_returns, lower * 100),\n            \"upper_bound\": np.percentile(total_returns, upper * 100),\n            \"std\": total_returns.std()\n        }\n```\n\n## Performance Metrics\n\n```python\ndef calculate_metrics(returns: pd.Series, rf_rate: float = 0.02) -> Dict[str, float]:\n    \"\"\"Calculate comprehensive performance metrics.\"\"\"\n    # Annualization factor (assuming daily returns)\n    ann_factor = 252\n\n    # Basic metrics\n    total_return = (1 + returns).prod() - 1\n    annual_return = (1 + total_return) ** (ann_factor \u002F len(returns)) - 1\n    annual_vol = returns.std() * np.sqrt(ann_factor)\n\n    # Risk-adjusted returns\n    sharpe = (annual_return - rf_rate) \u002F annual_vol if annual_vol > 0 else 0\n\n    # Sortino (downside deviation)\n    downside_returns = returns[returns \u003C 0]\n    downside_vol = downside_returns.std() * np.sqrt(ann_factor)\n    sortino = (annual_return - rf_rate) \u002F downside_vol if downside_vol > 0 else 0\n\n    # Calmar ratio\n    equity = (1 + returns).cumprod()\n    rolling_max = equity.cummax()\n    drawdowns = (equity - rolling_max) \u002F rolling_max\n    max_drawdown = drawdowns.min()\n    calmar = annual_return \u002F abs(max_drawdown) if max_drawdown != 0 else 0\n\n    # Win rate and profit factor\n    wins = returns[returns > 0]\n    losses = returns[returns \u003C 0]\n    win_rate = len(wins) \u002F len(returns[returns != 0]) if len(returns[returns != 0]) > 0 else 0\n    profit_factor = wins.sum() \u002F abs(losses.sum()) if losses.sum() != 0 else np.inf\n\n    return {\n        \"total_return\": total_return,\n        \"annual_return\": annual_return,\n        \"annual_volatility\": annual_vol,\n        \"sharpe_ratio\": sharpe,\n        \"sortino_ratio\": sortino,\n        \"calmar_ratio\": calmar,\n        \"max_drawdown\": max_drawdown,\n        \"win_rate\": win_rate,\n        \"profit_factor\": profit_factor,\n        \"num_trades\": int((returns != 0).sum())\n    }\n```\n\n## Best Practices\n\n### Do's\n- **Use point-in-time data** - Avoid look-ahead bias\n- **Include transaction costs** - Realistic estimates\n- **Test out-of-sample** - Always reserve data\n- **Use walk-forward** - Not just train\u002Ftest\n- **Monte Carlo analysis** - Understand uncertainty\n\n### Don'ts\n- **Don't overfit** - Limit parameters\n- **Don't ignore survivorship** - Include delisted\n- **Don't use adjusted data carelessly** - Understand adjustments\n- **Don't optimize on full history** - Reserve test set\n- **Don't ignore capacity** - Market impact matters\n\n## Resources\n\n- [Advances in Financial Machine Learning (Marcos López de Prado)](https:\u002F\u002Fwww.amazon.com\u002FAdvances-Financial-Machine-Learning-Marcos\u002Fdp\u002F1119482089)\n- [Quantitative Trading (Ernest Chan)](https:\u002F\u002Fwww.amazon.com\u002FQuantitative-Trading-Build-Algorithmic-Business\u002Fdp\u002F1119800064)\n- [Backtrader Documentation](https:\u002F\u002Fwww.backtrader.com\u002Fdocu\u002F)\n",{"name":5,"description":7},"main","7850740bd837adb32f0a109ab2af82482196c6f2","skills\u002F_collections\u002Fwshobson-agents\u002Fplugins\u002Fquantitative-trading\u002Fskills\u002Fbacktesting-frameworks",1,"https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills","https:\u002F\u002Fzturnsgo.com","https:\u002F\u002Fgithub.com\u002Fshengdabai","https:\u002F\u002Fzturnsgo.com\u002F","AI × education creator — producer, not consumer. Taught 6,000+ learners; shipping learning tools & daily essays with Claude Code, practicing @xiaolai's way 🥋","2026-11-01 21:28:23",{"source":8,"skillName":5,"commands":51,"prompt":61,"zipAvailable":62},[52,55,58],{"tool":53,"command":54},"npx","npx skills add shengdabai\u002FTony-Claude-Code-Skills --skill backtesting-frameworks",{"tool":56,"command":57},"bunx","bunx skills add shengdabai\u002FTony-Claude-Code-Skills --skill backtesting-frameworks",{"tool":59,"command":60},"pnpm","pnpm dlx skills add shengdabai\u002FTony-Claude-Code-Skills --skill backtesting-frameworks","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002F_collections\u002Fwshobson-agents\u002Fplugins\u002Fquantitative-trading\u002Fskills\u002Fbacktesting-frameworks\u002FSKILL.md",true,[],[65,74,82,90,98,106],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":69,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":73},"01M73H7XKBHE1ETQDZT94MF9HH","seedance-prompt-en","Write effective prompts for Jimeng Seedance 2.0 multimodal AI video generation. Use when users want to create video prompts using text, images, videos, and audio inputs with the @ reference system. Covers camera movements, effects replication, video extension, editing, music beat-matching, e-commerce ads, short dramas, and educational content.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fseedance-prompt-en\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fseedance-prompt-en\u002FSKILL.md",[],[],"2026-11-11 15:11:14",{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":78,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":73},"01M73GRE9998Q1DZWC71N41JWG","onepage-pdf","Convert an HTML page into a single continuous-page PDF (one tall page, no pagination breaks), preserving desktop layout, backgrounds and selectable text. Use when the user asks to turn an HTML file\u002Freport\u002Fproposal into a \"single-page PDF\", \"long PDF\", \"不分页 PDF\", \"单页 PDF\", \"长图式 PDF\", or complains that an HTML-to-PDF export breaks into pages or cuts content. Supports optional string redaction with leak verification.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fonepage-pdf\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fonepage-pdf\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":86,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":73},"01M73GQG1KZDADVPV3MHAT1J5A","native-feel-cross-platform-desktop","Use when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a native app to its users — fast launch, native windowing, native input handling, native materials. Trigger words include \"cross-platform desktop\", \"Electron alternative\", \"Tauri vs native\", \"WebView wrapper\", \"near-native performance\", \"Raycast architecture\", \"WebKit\u002FWebView2 quirks\", \"WKWebView\", \"system tray app\", \"global hotkey app\", \"launcher app\". Do NOT trigger this skill for pure web apps, pure mobile apps, or for greenfield projects that have no native-feel requirement.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fnative-feel-cross-platform-desktop\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fnative-feel-cross-platform-desktop\u002FSKILL.md",[],[],{"skillNo":91,"name":92,"nameZh":6,"description":93,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":94,"sourceHtmlUrl":95,"categories":96,"keywords":97,"publishedAt":73},"01M73G87PDNSMKG2FHWCYER6N8","gstack","Router for the gstack skill suite. (gstack)","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fgstack\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fgstack\u002FSKILL.md",[],[],{"skillNo":99,"name":100,"nameZh":6,"description":101,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":102,"sourceHtmlUrl":103,"categories":104,"keywords":105,"publishedAt":73},"01M73G3EAQWKCM8DB8D0N0QSVG","fireworks-tech-graph","Use when the user wants to create any technical diagram - architecture, data flow, flowchart, sequence, agent\u002Fmemory, or concept map - and export as SVG+PNG. Trigger on: \"画图\" \"帮我画\" \"生成图\" \"做个图\" \"架构图\" \"流程图\" \"可视化一下\" \"出图\" \"generate diagram\" \"draw diagram\" \"visualize\" or any system\u002Fflow description the user wants illustrated.","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Ffireworks-tech-graph\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Ffireworks-tech-graph\u002FSKILL.md",[],[],{"skillNo":107,"name":108,"nameZh":6,"description":109,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":110,"categories":111,"keywords":112,"publishedAt":73},"01M73G086AXAH9DW1H5G5N3CPB","dbs-video-extract","接收抖音、小红书、微信视频号等短视频链接或分享文案，查询作品／账号数据并提取语音文字稿，按作者和标题归档为 Markdown。用户希望完整解析短视频、取得数据或文字稿时使用；运行前检查 TikHub 与轻抖使用凭证，缺少时用新手能理解的方式引导购买和安全配置。","https:\u002F\u002Fgithub.com\u002Fshengdabai\u002FTony-Claude-Code-Skills\u002Fblob\u002Fmain\u002Fskills\u002Fdbs-video-extract\u002FSKILL.md",[],[]]