# Send vibetrading-ai-trading-code-generator to your agent Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually. ## Fast path - Download the package from Yavira. - Extract it into a folder your agent can access. - Paste one of the prompts below and point your agent at the extracted folder. ## Suggested prompts ### New install ```text I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Then review README.md for any prerequisites, environment setup, or post-install checks. Tell me what you changed and call out any manual steps you could not complete. ``` ### Upgrade existing ```text I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Then review README.md for any prerequisites, environment setup, or post-install checks. Summarize what changed and any follow-up checks I should run. ``` ## Machine-readable fields ```json { "schemaVersion": "1.0", "item": { "slug": "vibetrading-code-gen", "name": "vibetrading-ai-trading-code-generator", "source": "tencent", "type": "skill", "category": "开发工具", "sourceUrl": "https://clawhub.ai/liuhaonan00/vibetrading-code-gen", "canonicalUrl": "https://clawhub.ai/liuhaonan00/vibetrading-code-gen", "targetPlatform": "OpenClaw" }, "install": { "downloadUrl": "/downloads/vibetrading-code-gen", "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=vibetrading-code-gen", "sourcePlatform": "tencent", "targetPlatform": "OpenClaw", "packageFormat": "ZIP package", "primaryDoc": "SKILL.md", "includedAssets": [ "README.md", "SKILL.md", "templates/grid_trading.py", "scripts/code_validator.py", "scripts/code_formatter.py", "scripts/template_manager.py" ], "downloadMode": "redirect", "sourceHealth": { "source": "tencent", "status": "healthy", "reason": "direct_download_ok", "recommendedAction": "download", "checkedAt": "2026-05-07T17:22:31.273Z", "expiresAt": "2026-05-14T17:22:31.273Z", "httpStatus": 200, "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=afrexai-annual-report", "contentType": "application/zip", "probeMethod": "head", "details": { "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=afrexai-annual-report", "contentDisposition": "attachment; filename=\"afrexai-annual-report-1.0.0.zip\"", "redirectLocation": null, "bodySnippet": null }, "scope": "source", "summary": "Source download looks usable.", "detail": "Yavira can redirect you to the upstream package for this source.", "primaryActionLabel": "Download for OpenClaw", "primaryActionHref": "/downloads/vibetrading-code-gen" }, "validation": { "installChecklist": [ "Use the Yavira download entry.", "Review SKILL.md after the package is downloaded.", "Confirm the extracted package contains the expected setup assets." ], "postInstallChecks": [ "Confirm the extracted package includes the expected docs or setup files.", "Validate the skill or prompts are available in your target agent workspace.", "Capture any manual follow-up steps the agent could not complete." ] } }, "links": { "detailUrl": "https://openagent3.xyz/skills/vibetrading-code-gen", "downloadUrl": "https://openagent3.xyz/downloads/vibetrading-code-gen", "agentUrl": "https://openagent3.xyz/skills/vibetrading-code-gen/agent", "manifestUrl": "https://openagent3.xyz/skills/vibetrading-code-gen/agent.json", "briefUrl": "https://openagent3.xyz/skills/vibetrading-code-gen/agent.md" } } ``` ## Documentation ### VibeTrading Code Generator Generate executable Hyperliquid trading strategy code from natural language prompts. This skill transforms trading ideas into ready-to-run Python code using actual Hyperliquid API implementations. Generated code includes complete API integration, error handling, logging, and configuration management. ### Basic Usage # Generate a simple RSI strategy python scripts/strategy_generator.py "Generate a BTC RSI strategy, buy below 30, sell above 70" # Generate a grid trading strategy python scripts/strategy_generator.py "BTC grid trading 50000-60000 10 grids 0.01 BTC per grid" # Generate a signal-following strategy python scripts/strategy_generator.py "ETH trading strategy based on VibeTrading signals, buy on bullish signals, sell on bearish signals" ### Output Structure The generator creates: Strategy Python file - Complete trading strategy class Configuration file - Strategy parameters and settings Usage instructions - How to run and monitor the strategy Requirements file - Python dependencies ### Automatic Code Validation All generated code is automatically validated and fixed using the built-in validation system: # Validate generated code python scripts/code_validator.py generated_strategy.py # Validate and fix automatically python scripts/code_validator.py generated_strategy.py --fix # Validate entire directory python scripts/code_validator.py strategy_directory/ ### Validation Steps The validation system performs these checks: Syntax Validation - Python syntax checking Import Validation - Module import verification Compatibility Checks - Python 3.5+ compatibility Common Issue Detection - Missing imports, encoding issues, etc. ### Automatic Fixes When validation fails, the system automatically fixes common issues: Add missing imports - Add typing imports if type annotations are used Fix encoding declaration - Add # -*- coding: utf-8 -*- if missing Remove incompatible syntax - Remove f-strings and type annotations for Python 3.5 compatibility Fix import paths - Add sys.path modifications for API wrappers Fix logger initialization order - Ensure logger is initialized before API client Remove pathlib usage - Replace with os.path for Python 3.4 compatibility Fix string formatting - Convert f-strings to .format() method ### Validation Configuration The validation system can be configured via command-line arguments: # Basic validation python scripts/code_validator.py strategy.py # Validate and fix automatically python scripts/code_validator.py strategy.py --fix # Use specific Python executable python scripts/code_validator.py strategy.py --python python3.6 # Validate directory with all files python scripts/code_validator.py strategies/ --fix # Maximum 5 fix iterations python scripts/code_validator.py strategy.py --fix --max-iterations 5 ### Validation Rules The system enforces these rules for generated code: Python 3.5+ Compatibility No f-strings (use .format() or % formatting) No type annotations (remove or use comments) No pathlib (use os.path instead) No typing module imports Code Quality Proper encoding declaration (# -*- coding: utf-8 -*-) Logger initialized before API client All imports are resolvable No syntax errors Security API keys loaded from environment variables No hardcoded credentials Proper error handling for API calls Performance Reasonable check intervals (not too frequent) Efficient data fetching Proper resource cleanup ### Validation Workflow User Prompt → Code Generation → Validation → Fixes → Final Code ↓ If validation fails ↓ Apply automatic fixes ↓ Re-validate until success ↓ Deliver validated code ### Validation Failure Handling When validation fails, the system automatically updates the code with these steps: Error Analysis - Identify the specific validation errors Fix Application - Apply appropriate fixes based on error type Re-validation - Validate again after fixes Iterative Repair - Repeat until code is valid (max 3 iterations) Fallback Strategy - If automatic fixes fail, provide detailed error report and manual fix instructions ### Automatic Fix Examples Fix 1: Missing Imports # Before (error: NameError: name 'List' is not defined) def calculate_prices(prices: List[float]) -> List[float]: # After (automatic fix) from typing import List, Dict, Optional def calculate_prices(prices): Fix 2: Encoding Issues # Before (error: SyntaxError: Non-ASCII character) # Strategy description: Grid trading # After (automatic fix) # -*- coding: utf-8 -*- # Strategy description: Grid trading Fix 3: Python 3.5 Incompatibility # Before (error: SyntaxError in Python 3.5) price = f"Current price: {current_price}" # After (automatic fix) price = "Current price: {}".format(current_price) Fix 4: Import Path Issues # Before (error: ImportError: No module named 'hyperliquid_api') from hyperliquid_api import HyperliquidClient # After (automatic fix) import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "api_wrappers")) from hyperliquid_api import HyperliquidClient ### 1. Technical Indicator Strategies RSI-based: Oversold/overbought trading MACD-based: Trend following with MACD crossovers Moving Average: SMA/EMA cross strategies Bollinger Bands: Mean reversion strategies ### 2. Advanced Trading Strategies Grid Trading: Price range trading with multiple orders Mean Reversion: Statistical arbitrage strategies Trend Following: Momentum-based strategies Arbitrage: Spot-perp or cross-exchange arbitrage ### 3. Signal-Driven Strategies VibeTrading Integration: Follow AI-generated trading signals News-based: React to market news and sentiment Whale Activity: Track large wallet movements Funding Rate: Funding rate arbitrage strategies ### Step 1: Prompt Analysis The generator analyzes your natural language prompt to identify: Trading symbol (BTC, ETH, SOL, etc.) Strategy type (grid, RSI, signal-based, etc.) Key parameters (price ranges, grid counts, indicator values) Risk management preferences ### Step 2: Template Selection Based on the analysis, the system selects the most appropriate template from: templates/grid_trading.py - Grid trading strategy template ### Step 3: Code Generation The generator: Fills template parameters with your values Adds proper error handling and logging Includes configuration management Generates complete runnable code ### Step 4: Code Validation The generated code is automatically validated and fixed: Syntax checking - Ensure valid Python syntax Import verification - Check all imports are resolvable Compatibility testing - Verify Python 3.5+ compatibility Automatic fixes - Apply fixes for common issues Re-validation - Validate again after fixes Error reporting - If fixes fail, provide detailed error report ### Validation Failure Handling If validation fails after automatic fixes: Error Analysis Report - Detailed breakdown of remaining issues Manual Fix Instructions - Step-by-step guidance for manual fixes Fallback Template - Option to use a simpler, validated template Support Contact - Instructions for getting help ### Step 5: Output Delivery You receive validated, runnable code including: Validated Python strategy file - Fully tested and fixed Configuration template - Strategy parameters and settings Validation report - Summary of validation results and fixes applied Usage instructions - How to run and monitor the strategy Troubleshooting guide - Common issues and solutions Risk warnings - Important safety information ### API Integration The generated code uses mature Hyperliquid API implementations that support: ### Trading Operations Spot trading (buy/sell with limit/market orders) Perpetual contracts (long/short with leverage) Order management (cancel, modify, query) Position management (reduce, hedge) ### Market Data Real-time prices and OHLCV data Funding rates and open interest Order book depth Historical data access ### Account Management Balance queries (spot and futures) Position tracking PNL calculation Risk metrics ### Template Structure Each template includes: Strategy class with initialization and main logic Configuration section for easy parameter tuning Error handling with comprehensive logging Risk management features Monitoring loop for continuous operation ### Available Templates Grid Trading Template grid_trading.py - Grid trading within price ranges (Python 3.5+ compatible) No f-strings No type annotations Proper encoding declaration Logger initialized before API client ### Strategy Configuration Generated strategies include configurable parameters: STRATEGY_CONFIG = { "symbol": "BTC", "timeframe": "1h", "parameters": { "rsi_period": 14, "oversold": 30, "overbought": 70 }, "risk_management": { "position_size": 0.01, "stop_loss": 0.05, "take_profit": 0.10, "max_drawdown": 0.20 } } ### Environment Setup # Required environment variables export HYPERLIQUID_API_KEY="your_api_key_here" export HYPERLIQUID_ACCOUNT_ADDRESS="your_address_here" export TELEGRAM_BOT_TOKEN="optional_for_alerts" ### Risk Management Features All generated strategies include: ### 1. Position Sizing Fixed percentage of portfolio Dynamic position sizing based on volatility Maximum position limits ### 2. Stop Loss Mechanisms Percentage-based stop loss Trailing stops Time-based exits ### 3. Risk Controls Maximum daily loss limits Drawdown protection Correlation checks Market condition filters ### 4. Monitoring & Alerts Real-time position tracking Telegram/Slack notifications Performance reporting Error alerts and recovery ### Integration with VibeTrading Signals Generated strategies can integrate with VibeTrading Global Signals: from vibetrading import get_latest_signals # Get AI-generated signals signals = get_latest_signals("BTC,ETH") # Use signals in trading logic if signals["BTC"]["sentiment"] == "BULLISH": strategy.execute_buy("BTC", amount=0.01) ### Example 1: Simple RSI Strategy Prompt: "Generate a BTC RSI strategy, buy 0.01 BTC when RSI below 30, sell when above 70" Generated Code Features: RSI calculation with 14-period default Configurable oversold/overbought thresholds Proper error handling for API calls Logging for all trading actions 1-hour check interval ### Example 2: Grid Trading Strategy Prompt: "ETH grid trading strategy, price range 3000-4000, 20 grids, 0.1 ETH per grid" Generated Code Features: Automatic grid price calculation Order placement and management Grid rebalancing logic Price monitoring and adjustment Comprehensive logging ### Example 3: Signal-Based Strategy Prompt: "SOL trading strategy based on VibeTrading signals, buy on bullish signals, sell on bearish signals, 10 SOL per trade" Generated Code Features: VibeTrading API integration Signal polling and parsing Trade execution based on sentiment Position management Performance tracking ### 1. Start with Paper Trading Always test strategies in simulation mode first Use small position sizes initially Monitor performance for at least 1-2 weeks ### 2. Risk Management Never risk more than 1-2% per trade Use stop losses on all positions Diversify across multiple strategies Monitor correlation between strategies ### 3. Monitoring & Maintenance Regularly review strategy performance Adjust parameters based on market conditions Keep logs for audit and analysis Set up alerts for critical events ### 4. Security Store API keys securely (environment variables) Use separate accounts for different strategies Regularly rotate API keys Monitor for unauthorized access ### Common Issues 1. API Connection Errors # Check API key and account address echo $HYPERLIQUID_API_KEY echo $HYPERLIQUID_ACCOUNT_ADDRESS # Test API connection python scripts/test_connection.py 2. Strategy Not Executing Trades Check balance and available funds Verify symbol is correctly specified Check order size meets minimum requirements Review logs for error messages 3. Performance Issues Adjust check intervals (too frequent may cause rate limiting) Optimize data fetching (cache where possible) Review market conditions (low liquidity periods) 4. Integration Issues with VibeTrading Verify VibeTrading API is accessible Check signal availability for your symbols Review signal parsing logic 5. Validation Errors # Common validation errors and solutions: # Error: "SyntaxError: invalid syntax" # Solution: Check for f-strings or type annotations python scripts/code_validator.py strategy.py --fix # Error: "ImportError: No module named 'typing'" # Solution: Remove typing imports (Python 3.4 compatibility) sed -i '' 's/from typing import.*//g' strategy.py # Error: "SyntaxError: Non-ASCII character" # Solution: Add encoding declaration echo -e '# -*- coding: utf-8 -*-\\n' | cat - strategy.py > temp && mv temp strategy.py # Error: "NameError: name 'List' is not defined" # Solution: Remove type annotations or add typing import sed -i '' 's/: List//g; s/: Dict//g; s/: Optional//g' strategy.py # Manual validation check python -m py_compile strategy.py 6. Code Generation Failures Check prompt clarity (be specific about parameters) Ensure template exists for requested strategy type Verify Python version compatibility (3.5+ recommended) Check available disk space for output files ### Custom Template Creation You can create custom templates in templates/custom/: Create a new template file Define template variables with {{variable_name}} Add to template registry in scripts/template_registry.py Test with the generator ### Strategy Backtesting While this generator focuses on live trading, you can: Export generated code to backtesting frameworks Use historical data for strategy validation Add performance metrics and analysis ### Multi-Strategy Management For running multiple strategies: Generate separate strategy files Use different configuration files Monitor overall portfolio risk Implement strategy allocation logic ### Getting Help Review generated code comments Check example strategies in examples/ Consult Hyperliquid API documentation Review VibeTrading signal documentation ### Updates This skill will be updated with: New strategy templates Improved prompt understanding Additional risk management features Integration with more data sources ### Backtest Evaluation Feature After generating a strategy, you can now evaluate its performance using our integrated backtesting system: # Generate a strategy python scripts/strategy_generator.py "BTC grid trading 50000-60000 10 grids 0.01 BTC per grid" # Run backtest on the generated strategy python scripts/backtest_runner.py generated_strategies/btc_grid_trading_strategy.py # Run backtest with custom parameters python scripts/backtest_runner.py generated_strategies/btc_grid_trading_strategy.py \\ --start-date 2025-01-01 \\ --end-date 2025-03-01 \\ --initial-balance 10000 \\ --interval 1h ### Backtest Features The backtesting system provides: Historical Data Simulation - Uses historical price data for realistic testing Performance Metrics - Calculates key metrics: Total Return (%) Maximum Drawdown (%) Sharpe Ratio Win Rate (%) Total Trades Average Trade Duration Risk Analysis - Evaluates strategy risk characteristics Visual Reports - Generates charts and performance reports Comparative Analysis - Compares strategy performance against benchmarks ### Backtest Configuration You can configure backtests with these parameters: BACKTEST_CONFIG = { "start_date": "2025-01-01", "end_date": "2025-03-01", "initial_balance": 10000, # USDC "interval": "1h", # 1m, 5m, 15m, 30m, 1h, 4h, 1d "symbols": ["BTC", "ETH"], # Trading symbols "commission_rate": 0.001, # 0.1% trading commission "slippage": 0.001, # 0.1% slippage } ### Backtest Results Example 📊 Backtest Results for BTC Grid Trading Strategy ================================================ 📅 Period: 2025-01-01 to 2025-03-01 (60 days) 💰 Initial Balance: $10,000.00 💰 Final Balance: $11,234.56 📈 Performance Metrics: • Total Return: +12.35% • Max Drawdown: -5.67% • Sharpe Ratio: 1.45 • Win Rate: 58.3% • Total Trades: 120 • Avg Trade Duration: 12.5 hours 📋 Trade Analysis: • Winning Trades: 70 • Losing Trades: 50 • Largest Win: +$245.67 • Largest Loss: -$123.45 • Avg Win: +$89.12 • Avg Loss: -$56.78 ⚠️ Risk Assessment: • Risk-Adjusted Return: Good • Drawdown Control: Acceptable • Consistency: Moderate ### Backtest Integration in Generated Code Generated strategies now include backtest compatibility: # Generated strategy includes backtest method strategy = GridTradingStrategy(api_key, account_address, config) # Run backtest backtest_results = strategy.run_backtest( start_date="2025-01-01", end_date="2025-03-01", initial_balance=10000 ) # Generate backtest report strategy.generate_backtest_report(backtest_results) ### Backtest Data Sources The backtesting system uses: Historical price data from Hyperliquid API Realistic order execution with configurable slippage Accurate commission modeling based on exchange fees Market impact simulation for large orders ### Backtest Limitations Important Notes: Past performance ≠ future results - Historical success doesn't guarantee future profits Data quality - Results depend on historical data accuracy Market conditions - Past market conditions may differ from future Execution assumptions - Assumes perfect order execution (configurable slippage) Liquidity assumptions - Assumes sufficient market liquidity Best Practices: Always backtest with multiple time periods Test different market conditions (bull, bear, sideways) Use realistic commission and slippage settings Start with small position sizes in live trading Monitor strategy performance and adjust as needed ### Code Validation Disclaimer Validation Limitations: While the code validation system automatically fixes common issues, it cannot guarantee: Trading logic correctness - Validation checks syntax, not trading logic Financial performance - No guarantee of profitability API compatibility - Hyperliquid API changes may break generated code Security vulnerabilities - Manual security review is recommended Edge case handling - All possible error conditions may not be covered Validation Success Criteria: Code is considered "valid" when: No syntax errors All imports are resolvable Python 3.6+ compatible Basic structure is correct Not Validated: Trading logic accuracy Risk management effectiveness Financial calculations Market condition handling Performance optimization ### Python Version Requirements # Check Python version python scripts/check_python_version.py # Minimum: Python 3.6+ (for f-string support) ### Basic Usage # Generate strategy python scripts/strategy_generator.py "BTC grid trading 50000-60000 10 grids" # Run backtest python scripts/backtest_runner.py generated_strategies/btc_grid_trading_strategy.py ### Key Features Python 3.6+ Compatibility - Modern Python features including f-strings Automatic Backtest Integration - Evaluate strategies before live trading Comprehensive Validation - Syntax and compatibility checking Risk Management - Built-in risk controls in all strategies ### Trading Disclaimer Important: Trading cryptocurrencies involves significant risk. Generated strategies should be thoroughly tested before use with real funds. Past performance is not indicative of future results. Always use proper risk management and never trade with money you cannot afford to lose. The code generator provides tools for strategy creation, but ultimate responsibility for trading decisions and risk management lies with the user. Validation is not a substitute for: Thorough testing - Always test in simulation first Code review - Have experienced developers review generated code Security audit - Check for vulnerabilities before deployment Performance testing - Test under various market conditions Risk assessment - Evaluate strategy risks independently Backtesting Limitations: Historical data quality - Results depend on data accuracy Market condition changes - Past conditions may differ from future Execution assumptions - Assumes perfect order execution Liquidity assumptions - Assumes sufficient market liquidity No guarantee of future performance - Past success ≠ future profits ## Trust - Source: tencent - Verification: Indexed source record - Publisher: liuhaonan00 - Version: 1.0.0 ## Source health - Status: healthy - Source download looks usable. - Yavira can redirect you to the upstream package for this source. - Health scope: source - Reason: direct_download_ok - Checked at: 2026-05-07T17:22:31.273Z - Expires at: 2026-05-14T17:22:31.273Z - Recommended action: Download for OpenClaw ## Links - [Detail page](https://openagent3.xyz/skills/vibetrading-code-gen) - [Send to Agent page](https://openagent3.xyz/skills/vibetrading-code-gen/agent) - [JSON manifest](https://openagent3.xyz/skills/vibetrading-code-gen/agent.json) - [Markdown brief](https://openagent3.xyz/skills/vibetrading-code-gen/agent.md) - [Download page](https://openagent3.xyz/downloads/vibetrading-code-gen)