Stock Deep Analysis Workflow
wbh604/UZI-Skill
Runs a staged deep analysis of a single stock on China A-share, Hong Kong and US markets, ending in an HTML report with valuation models and investor-panel scores.
Explains portfolio theory and the built-in optimizers: mean-variance (MPT), Black-Litterman, risk budgeting and all-weather allocation, plus rebalancing rules and config output.
$ npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install HKUDS/Vibe-Trading asset-allocation --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/HKUDS/Vibe-Trading.git skills-src && mkdir -p .claude/skills && cp -r skills-src/agent/src/skills/asset-allocation .claude/skills/asset-allocation && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "asset-allocation" agent skill from https://github.com/HKUDS/Vibe-Trading/tree/main/agent/src/skills/asset-allocation into .claude/skills/asset-allocation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "asset-allocation", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/HKUDS/Vibe-Trading/tree/main/agent/src/skills/asset-allocationType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install HKUDS/Vibe-Trading asset-allocation --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/HKUDS/Vibe-Trading.git skills-src && mkdir -p .agents/skills && cp -r skills-src/agent/src/skills/asset-allocation .agents/skills/asset-allocation && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "asset-allocation" agent skill from https://github.com/HKUDS/Vibe-Trading/tree/main/agent/src/skills/asset-allocation into .agents/skills/asset-allocation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "asset-allocation", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install HKUDS/Vibe-Trading asset-allocation --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/HKUDS/Vibe-Trading.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/agent/src/skills/asset-allocation .cursor/skills/asset-allocation && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "asset-allocation" agent skill from https://github.com/HKUDS/Vibe-Trading/tree/main/agent/src/skills/asset-allocation into .cursor/skills/asset-allocation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "asset-allocation", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/HKUDS/Vibe-Trading.git --path agent/src/skills/asset-allocation--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install HKUDS/Vibe-Trading asset-allocation --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/HKUDS/Vibe-Trading.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/agent/src/skills/asset-allocation .gemini/skills/asset-allocation && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "asset-allocation" agent skill from https://github.com/HKUDS/Vibe-Trading/tree/main/agent/src/skills/asset-allocation into .gemini/skills/asset-allocation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "asset-allocation", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install HKUDS/Vibe-Trading asset-allocationInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/HKUDS/Vibe-Trading.git skills-src && mkdir -p .github/skills && cp -r skills-src/agent/src/skills/asset-allocation .github/skills/asset-allocation && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "asset-allocation" agent skill from https://github.com/HKUDS/Vibe-Trading/tree/main/agent/src/skills/asset-allocation into .github/skills/asset-allocation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "asset-allocation", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install HKUDS/Vibe-Trading asset-allocation --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/HKUDS/Vibe-Trading.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/agent/src/skills/asset-allocation .opencode/skills/asset-allocation && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "asset-allocation" agent skill from https://github.com/HKUDS/Vibe-Trading/tree/main/agent/src/skills/asset-allocation into .opencode/skills/asset-allocation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "asset-allocation", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
asset-allocationExplains portfolio theory and the built-in optimizers: mean-variance (MPT), Black-Litterman, risk budgeting and all-weather allocation, plus rebalancing rules and config output.
This skill walks through four allocation frameworks and how to use the optimizers that implement them, with the result written straight into config.json. For modern portfolio theory it states the minimum-variance problem, lists pros and cons and advises against raw use in favor of bounds, sector limits or a regularized version.
Black-Litterman is presented as a start from market equilibrium returns plus view matrices, with examples of absolute and relative views and guidance for the tau and omega parameters. Risk budgeting allocates by risk contribution, with equal-risk, equity-tilted and dynamic variants, and the all-weather approach spreads risk across economic environments. Rebalancing rules are covered as well.
9 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 14cabaf. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are json, python and markdown).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Asset Allocation and Optimizers loads about 2.9k tokens when it runs. Until then it costs about 46 tokens; SKILL.md has 902 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from HKUDS/Vibe-Trading at commit 14cabaf, republished under its MIT licence (© HKUDS). 902 words, ~2,926 tokens.
.claude/skills/asset-allocation/SKILL.md (or your agent's skills folder).From asset allocation theory to practical implementation, this skill covers classical frameworks (MPT, BL, risk budgeting, all-weather) and the usage of the four optimizers built into this system. The output can be written directly into config.json.
Core idea: maximize expected return for a given level of risk (the efficient frontier).
Optimization problem:
min w'Σw (portfolio variance)
s.t. w'μ = target_return
Σw = 1
w ≥ 0 (no shorting)| Advantages | Disadvantages |
|---|---|
| Mathematically rigorous | Extremely sensitive to inputs (garbage in, garbage out) |
| Efficient frontier is visualizable | Concentrated-allocation problem (often produces extreme weights) |
| Foundational framework | Assumes normality and ignores fat tails |
Practical advice: do not use raw MPT directly. Add constraints (upper/lower bounds, sector limits) or use a regularized version.
Core idea: start from market equilibrium and incorporate investor views.
Steps:
1. Reverse-imply market equilibrium returns: π = δΣw_mkt
2. Build the view matrices: P (selection matrix), Q (view returns), Ω (view uncertainty)
3. Blend the posterior: μ_BL = [(τΣ)^-1 + P'Ω^-1 P]^-1 [(τΣ)^-1 π + P'Ω^-1 Q]
4. Run Markowitz optimization using posterior μ_BLExample views:
P=[1,0,0], Q=[0.10]P=[1,-1,0], Q=[0.05]Parameter guidance:
τ (uncertainty scaling): 0.025-0.05Ω: set according to view confidence, where higher confidence = smaller varianceCore idea: allocate by risk contribution rather than by capital share.
Risk contribution: RC_i = w_i × (Σw)_i / σ_p
Target: RC_i / σ_p = budget_i (for all i)| Strategy | Risk Budget | Best Use Case |
|---|---|---|
| Equal risk contribution | Each asset 1/N | When you do not know which asset is best |
| Equity-tilted risk budget | Stocks 60%, bonds 30%, commodities 10% | When you want equities to contribute more risk |
| Dynamic risk budget | Adjust dynamically by signal strength | When you have market-timing ability |
Bridgewater framework: allocate risk equally across economic environments.
Economic environment Asset allocation
───────── ─────────
Growth rising Equities + commodities + corporate bonds
Growth falling Government bonds + inflation-protected bonds
Inflation rising Commodities + inflation-protected bonds + EM debt
Inflation falling Equities + government bonds
Simplified allocation example for China-focused portfolios:
- 30% CSI 300 / CSI 500
- 40% government bonds / credit bonds
- 15% gold
- 15% commodities / REITsConfigure them in config.json through optimizer and optimizer_params:
| optimizer | Display Name | Core Idea | Best Use Case |
|---|---|---|---|
equal_volatility | Equal Volatility | Allocate weights by inverse volatility | Simple and effective baseline |
risk_parity | Risk Parity | Equalize risk contribution while accounting for correlation | Long-term robust allocation |
mean_variance | Mean-Variance | Maximize Sharpe ratio or minimize variance | When return forecasts are available |
max_diversification | Maximum Diversification | Maximize the diversification ratio | When pursuing a low-correlation portfolio |
turnover_aware | Turnover-Aware | Mean-variance utility with an L1 penalty on weight changes vs the previous rebalance | When trading costs matter; tune turnover_penalty to your data frequency |
equal_volatility{
"optimizer": "equal_volatility",
"optimizer_params": {
"lookback": 60
}
}Principle: w_i = (1/σ_i) / Σ(1/σ_j)
| Parameter | Default | Description |
|---|---|---|
| lookback | 60 | Volatility calculation window (trading days) |
Advantages: simple and fast, no return forecast required, no correlation matrix required.
Disadvantages: ignores cross-asset correlation.
risk_parity{
"optimizer": "risk_parity",
"optimizer_params": {
"lookback": 60
}
}Principle: solve for weights such that each asset contributes the same amount of risk.
| Parameter | Default | Description |
|---|---|---|
| lookback | 60 | Covariance-matrix estimation window |
Advantages: accounts for correlation, spreads risk more evenly, and is robust over long horizons.
Disadvantages: requires iterative solving and is sensitive to covariance estimates.
mean_variance{
"optimizer": "mean_variance",
"optimizer_params": {
"lookback": 60,
"risk_free": 0.0
}
}Principle: Markowitz optimization that maximizes the Sharpe ratio.
| Parameter | Default | Description |
|---|---|---|
| lookback | 60 | Window for estimating means and covariances |
| risk_free | 0.0 | Risk-free rate (annualized) |
Advantages: theoretically optimal (if inputs are accurate).
Disadvantages: extremely sensitive to inputs, prone to extreme weights, and often performs poorly out of sample.
Recommendation: do not make lookback too short (<30 easily overfits), and add upper/lower weight constraints.
max_diversification{
"optimizer": "max_diversification",
"optimizer_params": {
"lookback": 60
}
}Principle: maximize DR = (w'σ) / σ_p (the diversification ratio).
| Parameter | Default | Description |
|---|---|---|
| lookback | 60 | Calculation window |
Advantages: does not require return forecasts and seeks true diversification.
Disadvantages: effectiveness is limited in highly correlated environments.
turnover_aware{
"optimizer": "turnover_aware",
"optimizer_params": {
"lookback": 60,
"risk_aversion": 1.0,
"turnover_penalty": 0.5
}
}Principle: minimize -w'μ + λ·w'Σw + γ·||w - w_prev||₁ subject to long-only, fully-invested weights — mean-variance utility with an L1 penalty on weight changes versus the previous rebalance, so the optimizer only trades when the expected improvement outweighs the (implicit) cost.
| Parameter | Default | Description |
|---|---|---|
| lookback | 60 | Calculation window |
| risk_aversion | 1.0 | Weight on the variance term (λ) |
| turnover_penalty | 0.0 | Weight on the L1 turnover term (γ); 0 reduces to the mean-variance baseline |
Advantages: dampens rebalancing churn, which usually dominates realized costs; the first rebalance is unpenalized so the cold start is undistorted.
Disadvantages: turnover_penalty is scale-sensitive to the return frequency of the input window — for daily returns even γ ≈ 0.5 strongly prefers holding still, so tune it per data frequency.
Do you have return forecasts?
├── Yes → Do trading costs / churn matter?
│ ├── Yes → turnover_aware (tune turnover_penalty to data frequency)
│ └── No → mean_variance (remember to add constraints)
└── No → Do you need to account for correlation?
├── Yes → risk_parity (recommended default)
└── No → Are volatility differences across assets large?
├── Yes → equal_volatility
└── No → max_diversification| Method | Trigger Condition | Advantages | Disadvantages |
|---|---|---|---|
| Periodic rebalancing | Fixed monthly / quarterly date | Simple, predictable trading cost | May miss or delay adjustments |
| Threshold trigger | Deviation from target weight > X% | Trades only when needed | Frequent trading in high-volatility markets |
| Volatility trigger | VIX / volatility breaks a threshold | Adapts to market regime | Parameter selection is difficult |
| Asset Class | Suggested Frequency | Threshold |
|---|---|---|
| Equity portfolio | Monthly | ±5% |
| Stock-bond mix | Quarterly | ±10% |
| Global macro | Quarterly / semiannual | ±10% |
| Cryptocurrency | Weekly / biweekly | ±15% (high volatility) |
Implement rebalancing logic in signal_engine.py:
# Periodic rebalancing example (every 20 trading days)
if bar_count % rebalance_freq == 0:
# Recompute weights
new_weights = calculate_target_weights(data_map)
for code, weight in new_weights.items():
signals[code].iloc[i] = weight| CSI 300 | CSI 500 | Government Bonds | Gold | BTC | |
|---|---|---|---|---|---|
| CSI 300 | 1.00 | 0.85 | -0.15 | 0.05 | 0.10 |
| CSI 500 | 0.85 | 1.00 | -0.10 | 0.03 | 0.12 |
| Government Bonds | -0.15 | -0.10 | 1.00 | 0.20 | -0.05 |
| Gold | 0.05 | 0.03 | 0.20 | 1.00 | 0.15 |
| BTC | 0.10 | 0.12 | -0.05 | 0.15 | 1.00 |
Key patterns:
0.85), so diversification benefits are limited## Asset Allocation Recommendation
### Allocation Plan
| Asset | Weight | Risk Contribution | Expected Return (Annualized) |
|------|------|---------|--------------|
| CSI 300 | 30% | 45% | 8% |
| Government Bond ETF | 40% | 15% | 3% |
| Gold | 15% | 20% | 5% |
| BTC | 15% | 20% | 15% |
### Optimizer Configuration
```json
{
"optimizer": "risk_parity",
"optimizer_params": {"lookback": 60}
}| Metric | Value |
|---|---|
| Expected annualized return | 7.2% |
| Expected annualized volatility | 8.5% |
| Expected Sharpe | 0.85 |
| Expected maximum drawdown | -12% |
## Notes
1. **The optimizer needs enough instruments**: at least 3 instruments are needed for meaningful optimization; with 2 instruments, `equal_volatility` is usually enough
2. **`lookback` window**: too short (`<20`) is noisy, too long (`>120`) reacts slowly, and 60 is a reasonable default
3. **`mean_variance` trap**: it is the easiest to overfit, and out-of-sample Sharpe is often cut by half or more
4. **Rebalancing cost**: frequent rebalancing eats into returns; for China A-share portfolios, stamp duty of 0.05% plus commissions is material
5. **Cross-market allocation**: use `"source": "auto"` in `config.json`, and let `codes` mix instruments from different markets
6. **Leverage constraint**: the sum of weights must be ≤ 1.0, and leverage is not allowed unless explicitly specified
7. **Survivorship bias**: historical correlations may be distorted by delistings and new listings© HKUDS, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in agent/src/skills/asset-allocation of HKUDS/Vibe-Trading.
Open the folder on GitHubat commit 14cabaf
Asset Allocation and Optimizers next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Asset Allocation and Optimizers this skillHKUDS/Vibe-Trading | 35k | — | ~2.9k | Automated safety check: Pass | MIT | |
| Stock Deep Analysis Workflowwbh604/UZI-Skill | 7.1k | — | ~9.1k | Automated safety check: Notes | MIT | |
| Three-Statement Model Builderginlix-ai/LangAlpha | 1.8k | — | ~5.4k | Automated safety check: Pass | Apache-2.0 | |
| Money Financeiamzifei/show-me-the-money | 1k | — | ~2.2k | Automated safety check: Pass | Custom licence | |
| Financial Model Checkerginlix-ai/LangAlpha | 1.8k | — | ~4.2k | Automated safety check: Pass | Apache-2.0 | |
| DCF Model Builderginlix-ai/LangAlpha | 1.8k | — | ~7.7k | Automated safety check: Pass | Apache-2.0 |
wbh604/UZI-Skill
Runs a staged deep analysis of a single stock on China A-share, Hong Kong and US markets, ending in an HTML report with valuation models and investor-panel scores.
ginlix-ai/LangAlpha
Builds or repairs an integrated income statement, balance sheet and cash flow model in Excel with live formulas, supporting schedules, scenarios and a Checks sheet.
iamzifei/show-me-the-money
Financial tracking, revenue analytics, expense management, and pricing optimization.
ginlix-ai/LangAlpha
Audits an existing Excel financial model without editing it, checking structure, formulas, integrity identities and source tie-out, and ends in a prioritized issue log.
ginlix-ai/LangAlpha
Builds a live Excel DCF valuation workbook with free cash flow projections, WACC, terminal value, three scenarios, sensitivity grids and a reverse DCF.
helsome/folio
Financial statements, business segments, dividends, valuation multiples (PE/PB/PS), industry comparison, operating data, corporate actions, company and executive profiles, cross-stock comparison…
HKUDS/Vibe-Trading
Index of Eastmoney's free, no-token market data interfaces for China A-shares and Hong Kong stocks: fund flows, dragon-tiger lists, margin trading, reports and news.
HKUDS/Vibe-Trading
Retrieves public OKX cryptocurrency market data such as spot prices, candlesticks, funding rates and open interest through the OKX V5 REST API, with no authentication.
HKUDS/Vibe-Trading
Fetches U.S. SEC EDGAR data: resolves tickers to CIK numbers, lists recent 10-K, 10-Q and 8-K filings with document URLs, and pulls XBRL financial series.
HKUDS/Vibe-Trading
Predicts whether a mainland China A-share company risks an ST or *ST warning after its next annual report, using financial thresholds and Sina penalty records.
HKUDS/Vibe-Trading
Breaks a structural trend such as AI infrastructure into its physical supply chain and ranks lesser-known listed companies sitting on each bottleneck.
HKUDS/Vibe-Trading
Plans and drafts an eight-part, roughly 120k-word investigative series on one company, built around a strict fact-check pass rather than fast drafting.
Categories
Explains portfolio theory and the built-in optimizers: mean-variance (MPT), Black-Litterman, risk budgeting and all-weather allocation, plus rebalancing rules and config output. json. For modern portfolio theory it states the minimum-variance problem, lists pros and cons and advises against raw use in favor of bounds, sector limits or a regularized version.
Asset Allocation and Optimizers fits situations like: choosing between mean-variance, Black-Litterman and risk budgeting for a portfolio; turning investor views into Black-Litterman inputs; setting up an equal risk contribution portfolio; deciding on rebalancing rules for a multi-asset allocation.
Run `npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a claude-code`. Or copy the skill folder (agent/src/skills/asset-allocation in HKUDS/Vibe-Trading) into .claude/skills/asset-allocation in your project. Claude Code loads it when a task matches its description.
Run `npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a codex`. Or copy the skill folder (agent/src/skills/asset-allocation in HKUDS/Vibe-Trading) into .agents/skills/asset-allocation in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add HKUDS/Vibe-Trading --skill asset-allocation -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/asset-allocation, .gemini/skills/asset-allocation, .github/skills/asset-allocation and .opencode/skills/asset-allocation in your project.
SKILL.md names no scripts, command-line tools or credentials: Asset Allocation and Optimizers is instructions for the agent only. Our summary lists: The optimizers built into the Vibe-Trading project.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Asset Allocation and Optimizers is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 2.9k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Asset Allocation and Optimizers: Stock Deep Analysis Workflow (wbh604/UZI-Skill, 7.1k stars), Three-Statement Model Builder (ginlix-ai/LangAlpha, 1.8k stars), Money Finance (iamzifei/show-me-the-money, 1k stars) and Financial Model Checker (ginlix-ai/LangAlpha, 1.8k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
HKUDS (a GitHub organization) maintains it in HKUDS/Vibe-Trading, which has 34,949 GitHub stars. The repository holds 89 skills in this directory. The repository was last updated on October 8, 2026.
Source: HKUDS/Vibe-Trading on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.