Communitygithub.com

NVlabs/Skill2Env

Verwenden Sie diese Fähigkeit, wenn ein Benutzer ein Aktienportfolio mit Mean-CVaR, Effizienzgrenzen, Szenariengenerierung oder NVIDIA cuOpt aufbauen, optimieren, zurücktesten, rebalancieren oder analysieren möchte.

Was ist Skill2Env?

Der Skill `NVlabs/Skill2Env` ermöglicht es KI-Agenten (wie Claude Code, Cursor oder Codex), quantitative Portfolios unter Verwendung der NVIDIA-beschleunigten Mean-CVaR-Optimierung zu erstellen und zu analysieren. Er wird aktiviert, wenn Anfragen wie „Portfolio optimieren“, „CVaR-Portfolio erstellen“ oder „mit cuOpt lösen“ erkannt werden. Der Skill treibt das installierte `cufolio`-Paket an, das GPU-Solver (cuOpt) und ML-Bibliotheken (cuML) für Aufgaben wie Renditeberechnung, Szenariengenerierung mit Kernel-Dichte-Schätzung (KDE), Portfoliooptimierung unter VaR- und CVaR-Beschränkungen, Erstellung von Effizienzgrenzen, Backtesting gegen Benchmarks und periodisches Rebalancing nutzt. Er unterstützt Standarddatensätze wie den S&P 500 oder benutzerdefinierte CSV-Dateien und stellt sicher, dass alle Berechnungen auf NVIDIA-GPUs ausgeführt werden. CPU-basierte Solver sind nicht erlaubt; der Skill prüft auf die Verfügbarkeit von `cvxpy` mit `cp.CUOPT`, bevor er eine Optimierung durchführt.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/NVlabs/Skill2Env/tree/HEAD/SkillHub/skills/nvidia/cufolio

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

cuFOLIO Fähigkeit

Zweck

Erstellen und analysieren Sie quantitative Portfolios mit NVIDIA-beschleunigter Mean-CVaR-Optimierung. Nutzen Sie cuFOLIO, um Renditen zu berechnen, KDE-Szenarien zu generieren, Allokationen mit dem cuOpt GPU-Solver zu lösen, eine Effizienzgrenze nachzuzeichnen, Portfolios zurückzutesten und Rebalancing-Workflows aus Kursdaten auszuführen.

Wann verwenden

Verwenden Sie diese Fähigkeit, wenn die Aufgabe darin besteht:

  • Ein Mean-CVaR-Portfolio aus Aktienkursen zu erstellen oder zu optimieren.
  • Gewichtungen über Ticker hinweg zu allozieren und dabei das Abwärts-CVaR-Risiko zu kontrollieren.
  • Eine Effizienzgrenze für ein Portfolio-Universum zu zeichnen oder zu inspizieren.
  • Eine Tabelle mit Gewichtungen nach Risikoaversion zu erstellen.
  • Ein optimiertes Portfolio gegen Benchmarks zurückzutesten.
  • Ein Portfolio nach einem Zeitplan oder einem Drift-Trigger neu zu gewichten.
  • Workflows auf einem S&P 500, S&P 100, Dow 30 oder benutzerdefinierten Kursdatensatz auszuführen.

Häufige Auslösephrasen sind „mein Portfolio optimieren“, „ein CVaR-Portfolio erstellen“, „cuFOLIO auf diesen Ticker anwenden“, „mit cuOpt lösen“, „die Effizienzgrenze zeichnen“, „Gewichtungen nach Risikoaversion anzeigen“, „diese Allokation zurücktesten“, „monatlich rebalancieren“, „meine Bestände mit CVaR analysieren“, „Allokationen vergleichen“, „Abwärtsrisiko reduzieren“, „eine Allokation konstruieren“, „Allokationsoptionen bewerten“, „meine Bestände stresstesten“, „Abwärtsrisiko-Exposition bewerten“, „meine Bestände unter Gewichtsobergrenzen überprüfen“, „Benchmark-Portfolios vergleichen“, „CVaR-Szenarien simulieren“, „Portfoliorisiko screenen“, „Bestände unter Nebenbedingungen optimieren“ und „eine risikoärmere Allokation finden“.

Verwenden Sie es nicht für allgemeine Finanzzusammenfassungen, Kursprognosen, neuronale Netzwerktrainings, Fahrzeugrouting oder nicht-portfoliobasierte Optimierung.

Voraussetzungen

  • Python-Umgebung mit installiertem cufolio-Paket.
  • NVIDIA GPU-Laufzeit mit installiertem cuOpt und cuML.
  • CUDA-Extra passend zum Host, z. B. uv sync --extra cuda12 oder uv sync --extra cuda13.
  • cvxpy, das cp.CUOPT bereitstellt.
  • Netzwerkzugriff beim ersten Start, wenn die Standard-Kurs-CSV heruntergeladen werden muss.

Einrichtung

Diese Fähigkeit verwendet das installierte cufolio-Paket. Eine fertige Umgebung kann vom Brev-Launchable oder von NVIDIA-AI-Blueprints/cuFOLIO nach Installation des passenden CUDA-Extra bezogen werden.

In gepackten Agent-/Eval-Sandboxes ist cufolio möglicherweise über PYTHONPATH verfügbar, anstatt als separat veröffentlichtes Wheel. Überprüfen Sie das lokale Paket mit python -c "import cufolio", bevor Sie es als fehlend deklarieren. Führen Sie nicht pip install cufolio aus, implementieren Sie cuFOLIO-Workflows nicht von Grund auf neu und ersetzen Sie die Paket-APIs nicht durch generischen pandas/scipy/cvxpy-Portfolio-Code.

Konkrete Implementierungsdetails finden Sie in references/workflows/agent_recipes.md, das als Quelle der Wahrheit dient. Es enthält exakte funktionierende Vorlagen zum Laden von Kursen, Vorbereiten von Renditen, Lösen mit cuOpt, Erstellen einer 25-Punkte-Effizienzgrenze, Zurücktesten gegen gleiche Gewichtung und Aufrufen des Rebalancers.

Der Standarddatensatz ist data/stock_data/sp500.csv. Er wird von git ignoriert. Vor dem ersten Herunterladen informieren Sie den Benutzer, dass dies öffentliche Marktdaten über den cuFOLIO/yfinance-Daten-Helper abruft, und bitten Sie um Bestätigung:

import cvxpy as cp
from cufolio.cvar_parameters import CvarParameters
from cufolio.utils import download_data

download_data("data/stock_data", datasets=["sp500"])
SOLVER_SETTINGS = {"solver": cp.CUOPT, "verbose": False, "solver_method": "PDLP"}
cvar_params = CvarParameters(
    w_min=0.0, w_max=1.0,
    c_min=0.0, c_max=0.0,
    risk_aversion=1.0, confidence=0.95,
)

Anweisungen

Geben Sie kurz die Standardeinstellungen an, die vor der Ausführung angewendet werden, und verwenden Sie dann diese Leitplanken:

  1. Laden Sie data/stock_data/sp500.csv; falls es fehlt, fragen Sie vor dem Herunterladen von sp500 mit cufolio.utils.download_data. Verwenden Sie keine Platzhalter, ersetzen Sie keine Daten und fabrizieren Sie keine Kursdaten.
  2. Validieren Sie Benutzer-CSVs vor dem Lösen: Erfordern Sie einen datumsähnlichen Index oder eine erste Datumsspalte, numerische Tickerspalten, mindestens 60 Zeilen nach der Datumsfilterung und mindestens einen angeforderten Ticker. Wenn der Benutzer Start-/Enddaten angibt, schneiden Sie den Kurs-DataFrame vor der Renditeberechnung zu und geben Sie den beibehaltenen Datumsbereich an. Filtern Sie Ticker im Kurs-DataFrame, bevor Renditen berechnet werden. regime_dict hat kein Ticker-Feld.
  3. Berechnen Sie LOG-Renditen mit utils.calculate_returns(...).
  4. Generieren Sie Szenarien mit cvar_utils.generate_cvar_data(...), KDE und KDESettings(device="GPU").
  5. Definieren Sie CvarParameters mit explizitem w_min und w_max. Setzen Sie für gewöhnliche „optimales Portfolio erstellen“-Anfragen c_min=0.0 und c_max=0.0, sodass das Ergebnis vollständig investiert ist statt 100 % Bargeld.
  6. Erstellen Sie cvar_optimizer.CVaR(returns_dict, cvar_params) direkt aus diesem Rendite-Wörterbuch; behalten Sie Ticker, Szenario-Arrays, Mittelwerte und Kovarianzen in den von cuFOLIO-Helfern zurückgegebenen Formen bei.
  7. Lösen Sie nur mit NVIDIA cuOpt. Überprüfen Sie vor dem Lösen hasattr(cp, "CUOPT") und str(cp.CUOPT) in {str(s) for s in cp.installed_solvers()}. Übergeben Sie SOLVER_SETTINGS an jede einzelne Optimierung oder Schleifen-Effizienzgrenzen-Lösung. Fallen Sie niemals auf CLARABEL, SCS, ECOS oder einen anderen CPU-Solver zurück. Wenn cuOpt fehlt, schließen Sie die Validierung/Einrichtung ab und melden Sie, dass die GPU/cuOpt-Laufzeit fehlt, anstatt ein CPU-Ergebnis zu fabrizieren.
  8. Für benutzerdefinierte Nebenbedingungen: Ordnen Sie Benutzeranfragen den CvarParameters zu: Gewichtsobergrenzen zu w_min/w_max, Risikoappetit zu risk_aversion, Konfidenzniveau zu confidence, Bargeldzulage zu c_max, und Kardinalität nur, wenn das Paket eine explizite Asset-Anzahl-Beschränkung für den Workflow bereitstellt. Wenn Nebenbedingungen in Konflikt stehen (z. B. eine maximale Gewichtung, die zu niedrig ist, um über die angeforderte Tickeranzahl zu investieren), erklären Sie den Konflikt und bitten Sie darum, die Nebenbedingung zu lockern, anstatt zu raten.
  9. Wenn der Benutzer einen Benchmark für den Backtest weglässt, verwenden Sie ein gleichgewichtetes Portfolio über denselben Ticker. Wenn der Benutzer eine Nebenbedingung weglässt, behalten Sie die Standardtabellenwerte bei und wiederholen Sie kurz die folgenreichen Annahmen vor dem Lösen.
  10. Geben Sie Gewichtungen sortiert nach Allokation, Bargeldgewichtung, erwarteter Rendite, CVaR, Solver-Label (cuOpt GPU) sowie alle angeforderten Effizienzgrenzen-Figuren, Gewichtungstabellen, Backtest-Metriken oder Rebalancing-Pläne aus. Fügen Sie für Tabellen Ticker als Spalten oder Zeilen mit Dezimalgewichtungen und Prozenten ein; bewahren Sie für Diagramme die zurückgegebene cuFOLIO-Figur, anstatt sie von Grund auf neu zu zeichnen.
  11. Fügen Sie für berichtsreife Antworten einen Nachweis hinzu, dass der angeforderte Workflow tatsächlich ausgeführt wurde. Geben Sie für eine Effizienzgrenze len(results_df) und die angeforderte ra_num (25, sofern der Benutzer nichts anderes angibt) an. Erweitern Sie für eine Gewichtungstabelle results_df["weights"] in Tickerspalten und fügen Sie cash plus risk_aversion hinzu. Fügen Sie für einen Backtest mean portfolio return, sharpe, sortino und max drawdown sowohl für optimierte als auch für Benchmark-Portfolios hinzu. Fügen Sie für Rebalancing results_dataframe, re_optimize_dates und das Ende von cumulative_portfolio_value hinzu.

Kanonischer Workflow-Rahmen

Starten Sie positive cuFOLIO-Aufgaben mit dieser Form und passen Sie nur die gewünschte Ausgabe an. Für vollständig kopierbare Funktionen lesen Sie references/workflows/agent_recipes.md, bevor Sie eigenen Code schreiben.

import cvxpy as cp
import pandas as pd

from cufolio import backtest, cvar_optimizer, cvar_utils, rebalance, utils
from cufolio.cvar_parameters import CvarParameters
from cufolio.portfolio import Portfolio
from cufolio.settings import KDESettings, ReturnsComputeSettings, ScenarioGenerationSettings

if not hasattr(cp, "CUOPT") or str(cp.CUOPT) not in {str(s) for s in cp.installed_solvers()}:
    raise RuntimeError("cuOpt GPU-Solver ist erforderlich; keinen CPU-Solver verwenden.")

SOLVER_SETTINGS = {"solver": cp.CUOPT, "verbose": False, "solver_method": "PDLP"}

prices = utils.get_input_data("data/stock_data/sp500.csv")
returns_dict = utils.calculate_returns(
    prices,
    regime_dict=None,
    returns_compute_settings=ReturnsComputeSettings(return_type="LOG"),
)
returns_dict = cvar_utils.generate_cvar_data(
    returns_dict,
    ScenarioGenerationSettings(
        fit_type="kde",
        kde_settings=KDESettings(device="GPU"),
    ),
)
cvar_params = CvarParameters(
    w_min=0.0,
    w_max=1.0,
    c_min=0.0,
    c_max=0.0,
    risk_aversion=1.0,
    confidence=0.95,
)
optimizer = cvar_optimizer.CVaR(returns_dict, cvar_params)
result, optimal_portfolio = optimizer.solve_optimization_problem(
    solver_settings=SOLVER_SETTINGS,
    print_results=False,
)

Rufen Sie für eine Effizienzgrenze oder eine Gewichtungstabelle Folgendes auf:

results_df, fig, ax = cvar_utils.create_efficient_frontier(
    returns_dict,
    cvar_params,
    SOLVER_SETTINGS,
    ra_num=25,
    show_plot=False,
    show_discretized_portfolios=False,
    benchmark_portfolios=False,
    print_portfolio_results=False,
)
weights_table = pd.DataFrame(results_df["weights"].tolist(), index=results_df.index)

Für einen Benchmark-Backtest: Wickeln Sie die gelöste Allokation in Portfolio(name="cuOpt Optimal", tickers=returns_dict["tickers"], weights=optimal_portfolio.weights, cash=optimal_portfolio.cash), erstellen Sie ein gleichgewichtetes Portfolio über dieselben returns_dict["tickers"], und verwenden Sie dann backtest.portfolio_backtester(..., test_method="historical").backtest_against_benchmarks(...). Der Backtester gibt (backtest_results, ax) zurück.

Für monatliches Rebalancing: Schreiben Sie zuerst den Kurs-DataFrame in einen CSV-Pfad. Instantiieren Sie rebalance.rebalance_portfolio(dataset_directory=<csv_path>, ...) mit re_optimize_criteria={"type": "drift_from_optimal", "threshold": 0, "norm": 1} und rufen Sie re_optimize(transaction_cost_factor=..., plot_title="Monatliches Rebalancing") auf. Der Rebalancer gibt (results_dataframe, re_optimize_dates, cumulative_portfolio_value) zurück.

Daten und Standardwerte

EinstellungStandardwert
Datensatzdata/stock_data/sp500.csv
DatumsbereichVollständig verfügbarer Bereich
PortfoliotypNur Long
MaximalgewichtKeines, sofern nicht angegeben
Risikoaversion1.0
Konfidenz0.95
SzenarienmethodeKDE auf GPU
SolvercuOpt GPU mit PDLP
RebalancingKeines, sofern nicht angefordert

Die Standard-S&P-500-Datei ist ein historischer Schnappschuss und kann aktuelle Bestandteile auslassen. Vom Benutzer bereitgestellte CSVs sollten datumsindizierte Kurstabellen mit Tickerspalten sein, kompatibel mit utils.get_input_data. Wenn angeforderte Ticker fehlen, entfernen Sie sie, melden Sie die Auslassungen und fahren Sie mit verfügbaren Spalten fort, es sei denn, der Benutzer bittet explizit darum, andere Daten abzurufen.

Wichtige APIs

Verwenden Sie die Paket-APIs, anstatt Portfolio-Mathematik oder Simulationsschleifen neu zu implementieren. cuFOLIO-Helfer geben flache Objekte zurück: returns_dict hat Schlüssel wie returns, mean, covariance und tickers; indizieren Sie es nicht als returns_dict["regime_1"]. solve_optimization_problem(...) gibt (result_row, portfolio) zurück, kein verschachteltes Ergebniswörterbuch.

  • Renditen: utils.calculate_returns(input_dataset, regime_dict, returns_compute_settings).
  • Regimefilter: regime_dict ist None oder {"name": "...", "range": ("YYYY-MM-DD", "YYYY-MM-DD")}; es ist nicht nach Regimenamen indiziert und enthält keine Ticker.
  • Szenarien: cvar_utils.generate_cvar_data(returns_dict, scenario_generation_settings).
  • Optimierer: cvar_optimizer.CVaR(returns_dict, cvar_params).
  • Lösen: result_row, portfolio = cvar_problem.solve_optimization_problem(solver_settings=SOLVER_SETTINGS, print_results=False).
  • Effizienzgrenze: cvar_utils.create_efficient_frontier(returns_dict, cvar_params, solver_settings=SOLVER_SETTINGS, ra_num=25). Der zurückgegebene results_df enthält Metriken, eine weights-Wörterbuchspalte und cash.
  • Portfolio: Portfolio(name="", tickers=None, weights=None, cash=0.0, time_range=None); übergeben Sie Ticker und ein flaches array-ähnliches weights, das mit diesen Tickern ausgerichtet ist.
  • Backtest: Erstellen Sie portfolio.Portfolio-Objekte für die optimierte Allokation und jeden Benchmark; verwenden Sie für einen gleichgewichteten Benchmark Gewichtungen von 1 / len(tickers) und cash=0.0, und rufen Sie dann backtest.portfolio_backtester(test_portfolio, returns_dict, risk_free_rate=0.0, test_method="historical", benchmark_portfolios=[...]).backtest_against_benchmarks(...) auf.
  • Rebalancing: rebalance.rebalance_portfolio(...) erfordert, dass dataset_directory ein CSV-Pfad und kein DataFrame ist. Rufen Sie re_optimize(...) auf; es gibt (results_dataframe, re_optimize_dates, cumulative_portfolio_value) zurück.
  • Einstellungsmodelle: ReturnsComputeSettings, ScenarioGenerationSettings, KDESettings, ApiSettings und CvarParameters.

Beispiele

  • „Optimales Portfolio aus dem S&P 500 erstellen“: Kurse laden, LOG-Renditen berechnen, GPU-KDE-Szenarien generieren, langfristige, voll investierte CvarParameters setzen, mit cuOpt lösen und diversifizierte Gewichtungen plus Rendite/CVaR melden.
  • „Effizienzgrenze zeichnen“: create_efficient_frontier(...) aufrufen, results_df zurückgeben und die Abbildung wie gewünscht anzeigen oder speichern.
  • „Gewichtungen nach Risikoaversion anzeigen“: results_df["weights"] in eine Tabelle pro Asset erweitern.
  • „Gegen gleichgewichtetes Portfolio zurücktesten“: Die optimierten und gleichgewichteten Portfolio-Objekte erstellen, dann den cuFOLIO-Backtester verwenden und Sharpe, Sortino und maximalen Drawdown melden.
  • „Monatliches Rebalancing zurücktesten“: rebalance_portfolio mit dem obigen Drift-Trigger konfigurieren und re_optimize(transaction_cost_factor=...) ausführen.

Einschränkungen

  • Erfordert eine NVIDIA GPU mit cuOpt und cuML; CPU-Solver sind nicht erlaubt.
  • CPU-basierte Eval-Container können trotzdem das Routing, die Datenverarbeitung und das Berichtsverhalten validieren, aber sie können keine gültige cuOpt-Lösung erzeugen. In diesem Fall melden Sie explizit die fehlende GPU/cuOpt-Laufzeit.
  • Standard-Kursdaten sind ein historischer Schnappschuss und können aktuelle Bestandteile auslassen.
  • Der Datensatz-Download beim ersten Start hängt vom Netzwerkzugriff ab, es sei denn, der Benutzer stellt eine CSV bereit.

Fehlerbehebung

  • Fehlende Standard-CSV oder FileNotFoundError: Erklären Sie, dass cuFOLIO öffentliche Marktdaten mit download_data("data/stock_data", datasets=["sp500"]) abruft; führen Sie es nur nach Bestätigung des Benutzers aus.
  • SolverError oder fehlendes cp.CUOPT: Installieren Sie das zum Host passende CUDA-Extra und überprüfen Sie es mit python -c "import cvxpy as cp; print(hasattr(cp, 'CUOPT'), cp.installed_solvers())".
  • `Im

…

[abgeschnitten für Übersetzung]

Individual skills in this repo

This repo contains 13 individual skills — each has its own dedicated page.

NVlabs/Skill2Env

This skill should be used when the user asks about "digital portfolio", "portfolio website", "project description", "case study", "portfolio curation", "creative portfolio", "act as a portfolio curator", "portfolio curator mode", "portfolio review", "professional presentation", "portfolio architecture", "work samples", "portfolio bio", or needs expertise in building, structuring, and writing professional digital portfolios. Part of the AlterLab FC Skills collection (New Media & Communication department).

NVlabs/Skill2Env

This skill should be used when the user asks about "web content strategy", "SEO writing", "UX writing", "information architecture", "content architecture", "website structure", "act as a web content strategist", "web strategist mode", "site map", "content audit", "microcopy", "meta descriptions", "content hierarchy", "content governance", or needs expertise in planning, structuring, and writing content for websites and digital platforms. Part of the AlterLab FC Skills collection (New Media & Communication department).

NVlabs/Skill2Env

When the user wants to create, generate, or produce video content using AI tools or programmatic frameworks. Also use when the user mentions 'video production,' 'AI video,' 'Remotion,' 'Hyperframes,' 'HeyGen,' 'Synthesia,' 'Veo,' 'Sora,' 'Runway,' 'Kling,' 'Seedance,' 'Hailuo,' 'MiniMax,' 'Pika,' 'Hunyuan,' 'Wan,' 'video generation,' 'AI avatar,' 'talking head video,' 'programmatic video,' 'video template,' 'explainer video,' 'product demo video,' 'video pipeline,' or 'make me a video.' Use this for video creation, generation, and production workflows. For video content strategy and what to post, see social. For paid video ad creative, see ad-creative.

NVlabs/Skill2Env

Balance visual design with ATS compatibility for creative roles

NVlabs/Skill2Env

Build immersive, cinematic 2.5D interactive websites using scroll storytelling, parallax depth, text animations, and premium scroll effects — no WebGL required. Use this skill for any web design task: landing pages, product sites, hero sections, scroll animations, parallax, sticky sections, section overlaps, floating products between sections, clip-path reveals, text that flies in from sides, words that light up on scroll, curtain drops, iris opens, card stacks, bleed typography, and any site that should feel cinematic or premium. Trigger on phrases like "make it feel alive", "Apple-style animation", "sections that overlap", "product rises between sections", "immersive", "scrollytelling", or any scroll-driven visual effect. Covers 45+ techniques across 8 categories. Always inspects, judges, and plans assets before coding. Use aggressively for ANY web design task.

NVlabs/Skill2Env

Read-only queue dashboard for workspace-aware ship. (gstack)

NVlabs/Skill2Env

Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.

NVlabs/Skill2Env

Audits any landing or service page across 48 checks in 10 categories for LLM/AI discoverability, GEO readiness, content clarity, schema markup, internal linking, freshness signals, and technical crawlability. Produces an overall score out of 100, a per-category score out of 100, pass/warn/fail/ manual counts, and a prioritised fix list — all rendered as a standalone HTML report saved to disk. Use when a user provides a URL and asks to audit it, score it, check its GEO readiness, test its AI discoverability, run a landing page audit, or evaluate it for LLM citation potential. Also trigger on phrases like "audit this page", "score this URL", "check GEO for", "is this page AI-ready", "run a GEO audit", "LLM page check", "how would AI read this page", or "landing page score".

NVlabs/Skill2Env

Generates a premium single-page HTML landing page with 3D CSS animations, GSAP scroll effects, and mouse-parallax depth. Forcing intake (product + elevator pitch, audience register, brand overrides, tone) locks down positioning before any copy or markup is written, so the page reflects the actual product rather than generic boilerplate. Use whenever the user says 'landing for X', 'create a landing page', 'build a landing page', 'make a landing page for X', 'I need a web page for Y', or provides product/service details and wants a polished website. Also triggers on 'promotional page', 'product page', 'one-pager', 'web presence', 'sales page'. Outputs a single self-contained HTML file (Claude Code) or HTML artifact (Claude.ai). Supports configurable brand colors via CSS custom property overrides.

NVlabs/Skill2Env

Transform resume bullets into detailed portfolio case studies

NVlabs/Skill2Env

Generates high-converting landing pages as complete Next.js/React (TSX) components with Tailwind CSS. Creates hero sections, feature grids, pricing tables, FAQ accordions, testimonial blocks, and CTA sections using proven copy frameworks (PAS, AIDA, BAB). Outputs SEO meta tags, structured data, and performance-optimised code targeting Core Web Vitals (LCP < 1s, CLS < 0.1). Use when the user asks to create a landing page, marketing page, homepage, single-page site, lead capture page, campaign page, promo page, or conversion-optimised web page — or when they want to A/B test landing page variants or replace a static page with one designed to convert.

NVlabs/Skill2Env

> Visual design direction framework organized by emotional intent (Warm/Cold x Active/Calm). The first design reference system that categorizes sites by what they make you FEEL, not how they look. Includes 48 annotated public website references.

NVlabs/Skill2Env

Run a structured 5-pass finishing audit on any website before launch — scoring visual polish, technical foundation, UX completeness, content quality, and cross-device readiness on 100 points. Use when: **Pre-launch** - Final validation before going live; **Post-redesign** - Verify nothing broke during the overhaul; **Client handoff** - Structured proof that the site is ready; **Quarterly review** - Catch accumulated debt; **Single-pass focus** - Run just Pass 2 after a perf sprint

Verwandte Skills