[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6HRGD9KN0D9QQCFKP83EBK7":3,"skill-same:01M6HRGD9KN0D9QQCFKP83EBK7":60},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":34,"linkOnly":35,"markdownContent":36,"markdownBody":37,"frontMatter":38,"refName":39,"commitSha":40,"skillDirectory":41,"forksCount":42,"repositoryHtmlUrl":43,"repositoryHomepageUrl":6,"ownerHtmlUrl":44,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":45,"install":46,"resources":59},"01M6HRGD9KN0D9QQCFKP83EBK7","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.","welflau\u002Fai-dev-system","welflau","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F7010385?v=4","01M6HPTDGF18RFY07M229P8CTM","01M6HPTDMRMZCJPYBFEA9XVVYT",3,"MIT","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fquantitative-trading\u002Fskills\u002Fbacktesting-frameworks\u002FSKILL.md",[],[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33],"backtesting frameworks","frameworks","backtesting","infrastructure","use","look","trading","build","algorithms","transaction","strategies","bias","systems","with","for","when","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","18d0e63d1313ca87098f614aa7c1e2dcf6de79c7","backend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fquantitative-trading\u002Fskills\u002Fbacktesting-frameworks",1,"https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system","https:\u002F\u002Fgithub.com\u002Fwelflau","2026-11-12 14:55:20",{"source":8,"skillName":5,"commands":47,"prompt":57,"zipAvailable":58},[48,51,54],{"tool":49,"command":50},"npx","npx skills add welflau\u002Fai-dev-system --skill backtesting-frameworks",{"tool":52,"command":53},"bunx","bunx skills add welflau\u002Fai-dev-system --skill backtesting-frameworks",{"tool":55,"command":56},"pnpm","pnpm dlx skills add welflau\u002Fai-dev-system --skill backtesting-frameworks","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fquantitative-trading\u002Fskills\u002Fbacktesting-frameworks\u002FSKILL.md",true,[],[61,94,124,148,174,198],{"skillNo":62,"name":63,"nameZh":6,"description":64,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":65,"licenseFileUrl":66,"sourceHtmlUrl":67,"categories":68,"keywords":74,"publishedAt":34},"01M6HSTDP4M3JFXEBK91VFB4PA","web-artifacts-builder","Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn\u002Fui). Use for complex artifacts requiring state management, routing, or shadcn\u002Fui components - not for simple single-file HTML\u002FJSX artifacts.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Fweb-artifacts-builder\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Fweb-artifacts-builder\u002FSKILL.md",[69],{"categoryNo":70,"categoryName":71,"taxonomyType":72,"taxonomyTypeDesc":73},"01JBSEEDCAT000000000000009","前端开发","SCENARIO","使用场景",[75,76,77,78,79,80,81,82,83,84,85,86,87,88,22,89,90,91,92,32,93],"web artifacts builder","web","artifacts","artifacts builder","builder","frontend","css","components","react","routing","state management","state","file","Tailwind","single-file","simple","ui components","multi","single",{"skillNo":95,"name":96,"nameZh":6,"description":97,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":65,"licenseFileUrl":98,"sourceHtmlUrl":99,"categories":100,"keywords":110,"publishedAt":34},"01M6HSDXH0JSP8R3QTNY9XZ8HN","frontend-design","Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML\u002FCSS layouts, or when styling\u002Fbeautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Ffrontend-design\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Ffrontend-design\u002FSKILL.md",[101,102,105],{"categoryNo":70,"categoryName":71,"taxonomyType":72,"taxonomyTypeDesc":73},{"categoryNo":103,"categoryName":104,"taxonomyType":72,"taxonomyTypeDesc":73},"01JBSEEDCAT000000000000015","视觉设计",{"categoryNo":106,"categoryName":107,"taxonomyType":108,"taxonomyTypeDesc":109},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[80,111,112,81,76,82,83,113,114,115,77,116,117,118,22,119,120,121,122,31,123,33],"design","frontend design","react components","create","code","examples","applications","landing","ui design","pages","aesthetics","web ui","generic",{"skillNo":125,"name":126,"nameZh":6,"description":127,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":65,"licenseFileUrl":128,"sourceHtmlUrl":129,"categories":130,"keywords":132,"publishedAt":34},"01M6HSA77QYVP7A72HREGTDN2C","algorithmic-art","Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Falgorithmic-art\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fplugins\u002Falgorithmic-art\u002FSKILL.md",[131],{"categoryNo":103,"categoryName":104,"taxonomyType":72,"taxonomyTypeDesc":73},[133,134,135,114,115,136,137,138,139,22,140,141,30,142,31,143,144,145,146,147,33],"algorithmic art","Art","algorithmic","flow","js","work","interactive","generative art","exploration","users","Existing","request","generative","copyright","fields",{"skillNo":149,"name":150,"nameZh":6,"description":151,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":65,"licenseFileUrl":152,"sourceHtmlUrl":153,"categories":154,"keywords":156,"publishedAt":34},"01M6HS9HE0X390Y6RQKTY1YNGJ","theme-factory","Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors\u002Ffonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Ftheme-factory\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Ftheme-factory\u002FSKILL.md",[155],{"categoryNo":103,"categoryName":104,"taxonomyType":72,"taxonomyTypeDesc":73},[157,158,159,160,161,162,77,163,164,165,118,166,167,120,168,31,169,170,171,32,172,173],"theme factory","factory","theme","docs","toolkit","generate","SET","fly","slides","styling","artifact","themes","you","fonts","can","apply","new",{"skillNo":175,"name":176,"nameZh":6,"description":177,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":178,"categories":179,"keywords":183,"publishedAt":34},"01M6HS74GASM6FJ77F83EY679E","browsing","Use when you need direct browser control - teaches Chrome DevTools Protocol for controlling existing browser sessions, multi-tab management, form automation, and content extraction via use_browser MCP tool","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fsuperpowers-chrome\u002Fskills\u002Fbrowsing\u002FSKILL.md",[180],{"categoryNo":181,"categoryName":182,"taxonomyType":72,"taxonomyTypeDesc":73},"01JBSEEDCAT000000000000023","Skill与智能体开发",[176,184,185,186,187,188,189,190,191,192,193,22,194,195,196,197,92,169,32,143],"MCP","automation","chrome","sessions","protocol","browser","devtools","chrome devtools","tool","direct","browser control","control","via","form",{"skillNo":199,"name":200,"nameZh":6,"description":201,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":65,"licenseFileUrl":202,"sourceHtmlUrl":203,"categories":204,"keywords":211,"publishedAt":34},"01M6HS6BZT2CKDNQ6YF20DXN4T","slack-gif-creator","Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like \"make me a GIF of X doing Y for Slack.\"","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fslack-gif-creator\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fwelflau\u002Fai-dev-system\u002Fblob\u002Fmain\u002Fbackend\u002Fskills\u002Fmarketplace\u002Fcodebuddy-plugins-official\u002Fexternal_plugins\u002Fslack-gif-creator\u002FSKILL.md",[205,208],{"categoryNo":206,"categoryName":207,"taxonomyType":72,"taxonomyTypeDesc":73},"01JBSEEDCAT000000000000005","邮件与沟通",{"categoryNo":209,"categoryName":210,"taxonomyType":72,"taxonomyTypeDesc":73},"01JBSEEDCAT000000000000016","图像与多媒体",[212,213,214,215,216,217,218,219,220,22,221,142,222,223,224,32,144,33],"slack gif creator","slack","gif","creator","validation","Tools","constraints","Animation","knowledge","me","make","Utilities","concepts"]