Communitygithub.com

bg-szy/TOP-SKILLS

Construit des fuzzers personnalisés avec LibAFL, la bibliothèque de fuzzing modulaire en Rust. Couvre la composition d'observateurs, de feedbacks, de mutateurs, de planificateurs et d'exécuteurs pour créer un fuzzer adapté à des cibles que les outils standard ne prennent pas en charge.

Qu'est-ce que TOP-SKILLS ?

Cette compétence vous guide dans la construction de fuzzers sur mesure avec LibAFL, une bibliothèque de fuzzing modulaire en Rust qui implémente les fonctionnalités des fuzzers basés sur AFL comme AFL++. Contrairement aux fuzzers traditionnels, LibAFL offre toutes ses fonctionnalités de manière modulaire et personnalisable en tant que bibliothèque Rust. Elle peut être utilisée comme un remplacement direct de libFuzzer (pour une configuration rapide) ou comme bibliothèque pour construire des fuzzers avancés à partir de zéro, ce qui est idéal pour les cibles non standard, les stratégies de mutation personnalisées ou la recherche en fuzzing. La compétence détaille les deux modes d'utilisation, la configuration de l'environnement Clang/LLVM et Rust, la création de harnais de test (harness), l'assemblage des composants d'un fuzzer (observateurs, feedbacks, mutateurs, planificateurs, exécuteurs), la compilation avec ou sans wrapper, le lancement de campagnes (y compris multi-cœurs), le déduplication de crashs, le fuzzing par dictionnaire, le réglage des performances, et fournit des exemples concrets comme le fuzzing de la bibliothèque libpng ou l'intégration avec CMake.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/bg-szy/TOP-SKILLS/tree/HEAD/skills/skills/libafl

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

LibAFL

LibAFL est une bibliothèque de fuzzing modulaire qui implémente les fonctionnalités des fuzzers basés sur AFL comme AFL++. Contrairement aux fuzzers traditionnels, LibAFL fournit toutes ses fonctionnalités de manière modulaire et personnalisable sous forme de bibliothèque Rust. Il peut être utilisé comme un remplacement direct de libFuzzer ou comme une bibliothèque pour construire des fuzzers personnalisés à partir de zéro.

Quand l'utiliser

FuzzerMeilleur pourComplexité
libFuzzerConfiguration rapide, monothreadFaible
AFL++Multi-cœur, usage généralMoyenne
LibAFLFuzzers personnalisés, fonctionnalités avancées, rechercheÉlevée

Choisissez LibAFL quand :

  • Vous avez besoin de stratégies de mutation ou de mécanismes de feedback personnalisés
  • Les fuzzers standard ne prennent pas en charge l'architecture de votre cible
  • Vous souhaitez implémenter des techniques de fuzzing innovantes
  • Vous avez besoin d'un contrôle fin sur les composants du fuzzer
  • Vous menez des recherches en fuzzing

Démarrage rapide

LibAFL peut être utilisé comme remplacement direct de libFuzzer avec une configuration minimale :

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    // Appelez votre code avec les données fournies par le fuzzer
    my_function(data, size);
    return 0;
}

Construisez la couche de compatibilité libFuzzer de LibAFL :

git clone https://github.com/AFLplusplus/LibAFL
cd LibAFL/libafl_libfuzzer_runtime
./build.sh

Compilez et exécutez :

clang++ -DNO_MAIN -g -O2 -fsanitize=fuzzer-no-link libFuzzer.a harness.cc main.cc -o fuzz
./fuzz corpus/

Installation

Prérequis

  • Clang/LLVM 15-18
  • Rust (via rustup)
  • Dépendances système supplémentaires

Linux/macOS

Installez Clang :

apt install clang

Ou installez une version spécifique via apt.llvm.org :

wget https://apt.llvm.org/llvm.sh
chmod +x llvm.sh
sudo ./llvm.sh 15

Configurez l'environnement pour Rust :

export RUSTFLAGS="-C linker=/usr/bin/clang-15"
export CC="clang-15"
export CXX="clang++-15"

Installez Rust :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Installez les dépendances supplémentaires :

apt install libssl-dev pkg-config

Pour le mode de compatibilité libFuzzer, installez la version nightly de Rust :

rustup toolchain install nightly --component llvm-tools

Vérification

Construisez LibAFL pour vérifier l'installation :

cd LibAFL/libafl_libfuzzer_runtime
./build.sh
# Devrait produire libFuzzer.a

Écrire un harnais (Harness)

Les harnais LibAFL suivent le même modèle que libFuzzer lorsqu'on utilise le mode de remplacement direct :

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    // Votre code cible de fuzzing ici
    return 0;
}

Lors de la construction de fuzzers personnalisés avec LibAFL en tant que bibliothèque Rust, la logique du harnais est intégrée directement dans le fuzzer. Voir la section « Écrire un fuzzer personnalisé » ci-dessous pour le modèle complet.

Voir aussi : Pour des techniques détaillées d'écriture de harnais, consultez la compétence technique harness-writing.

Modes d'utilisation

LibAFL prend en charge deux modes d'utilisation principaux :

1. Remplacement direct de libFuzzer

Utilisez LibAFL comme remplacement de libFuzzer avec des harnais existants.

Compilation :

clang++ -DNO_MAIN -g -O2 -fsanitize=fuzzer-no-link libFuzzer.a harness.cc main.cc -o fuzz

Exécution :

./fuzz corpus/

Recommandé pour les longues campagnes :

./fuzz -fork=1 -ignore_crashes=1 corpus/

2. Fuzzer personnalisé en tant que bibliothèque Rust

Construisez un fuzzer entièrement personnalisé en utilisant les composants LibAFL.

Créez un projet :

cargo init --lib my_fuzzer
cd my_fuzzer
cargo add [email protected] [email protected] [email protected] [email protected] \
  --features "[email protected]/libfuzzer,[email protected]/sancov_pcguard_hitcounts"

Configurez Cargo.toml :

[lib]
crate-type = ["staticlib"]

Écrire un fuzzer personnalisé

Voir aussi : Pour des techniques détaillées d'écriture de harnais, des modèles de gestion d'entrées complexes et des stratégies avancées, consultez la compétence technique fuzz-harness-writing.

Composants du fuzzer

Un fuzzer LibAFL se compose de composants modulaires :

  1. Observateurs - Collectent les retours d'exécution (couverture, timing)
  2. Feedback - Détermine si les entrées sont intéressantes
  3. Objectif - Définit les buts du fuzzing (plantages, timeouts)
  4. État - Maintient le corpus et les métadonnées
  5. Mutateurs - Génèrent de nouvelles entrées
  6. Planificateur - Sélectionne les entrées à muter
  7. Exécuteur - Exécute la cible avec les entrées

Structure de base du fuzzer

use libafl::prelude::*;
use libafl_bolts::prelude::*;
use libafl_targets::{libfuzzer_test_one_input, std_edges_map_observer};

#[no_mangle]
pub extern "C" fn libafl_main() {
    let mut run_client = |state: Option<_>, mut restarting_mgr, _core_id| {
        // 1. Configurer les observateurs
        let edges_observer = HitcountsMapObserver::new(
            unsafe { std_edges_map_observer("edges") }
        ).track_indices();
        let time_observer = TimeObserver::new("time");

        // 2. Définir le feedback
        let mut feedback = feedback_or!(
            MaxMapFeedback::new(&edges_observer),
            TimeFeedback::new(&time_observer)
        );

        // 3. Définir l'objectif
        let mut objective = feedback_or_fast!(
            CrashFeedback::new(),
            TimeoutFeedback::new()
        );

        // 4. Créer ou restaurer l'état
        let mut state = state.unwrap_or_else(|| {
            StdState::new(
                StdRand::new(),
                InMemoryCorpus::new(),
                OnDiskCorpus::new(&output_dir).unwrap(),
                &mut feedback,
                &mut objective,
            ).unwrap()
        });

        // 5. Configurer le mutateur
        let mutator = StdScheduledMutator::new(havoc_mutations());
        let mut stages = tuple_list!(StdMutationalStage::new(mutator));

        // 6. Configurer le planificateur
        let scheduler = IndexesLenTimeMinimizerScheduler::new(
            &edges_observer,
            QueueScheduler::new()
        );

        // 7. Créer le fuzzer
        let mut fuzzer = StdFuzzer::new(scheduler, feedback, objective);

        // 8. Définir le harnais
        let mut harness = |input: &BytesInput| {
            let buf = input.target_bytes().as_slice();
            libfuzzer_test_one_input(buf);
            ExitKind::Ok
        };

        // 9. Configurer l'exécuteur
        let mut executor = InProcessExecutor::with_timeout(
            &mut harness,
            tuple_list!(edges_observer, time_observer),
            &mut fuzzer,
            &mut state,
            &mut restarting_mgr,
            timeout,
        )?;

        // 10. Charger les entrées initiales
        if state.must_load_initial_inputs() {
            state.load_initial_inputs(
                &mut fuzzer,
                &mut executor,
                &mut restarting_mgr,
                &input_dir
            )?;
        }

        // 11. Démarrer le fuzzing
        fuzzer.fuzz_loop(&mut stages, &mut executor, &mut state, &mut restarting_mgr)?;
        Ok(())
    };

    // Lancer le fuzzer
    Launcher::builder()
        .run_client(&mut run_client)
        .cores(&cores)
        .build()
        .launch()
        .unwrap();
}

Compilation

Mode verbeux

Spécifiez manuellement tous les drapeaux d'instrumentation :

clang++-15 -DNO_MAIN -g -O2 \
  -fsanitize-coverage=trace-pc-guard \
  -fsanitize=address \
  -Wl,--whole-archive target/release/libmy_fuzzer.a -Wl,--no-whole-archive \
  main.cc harness.cc -o fuzz

Wrapper de compilation (Recommandé)

Créez un wrapper de compilation LibAFL pour gérer l'instrumentation automatiquement.

Créez src/bin/libafl_cc.rs :

use libafl_cc::{ClangWrapper, CompilerWrapper, Configuration, ToolWrapper};

pub fn main() {
    let args: Vec<String> = env::args().collect();
    let mut cc = ClangWrapper::new();
    cc.cpp(is_cpp)
      .parse_args(&args)
      .link_staticlib(&dir, "my_fuzzer")
      .add_args(&Configuration::GenerateCoverageMap.to_flags().unwrap())
      .add_args(&Configuration::AddressSanitizer.to_flags().unwrap())
      .run()
      .unwrap();
}

Compilez et utilisez :

cargo build --release
target/release/libafl_cxx -DNO_MAIN -g -O2 main.cc harness.cc -o fuzz

Voir aussi : Pour une configuration détaillée des sanitizers, les problèmes courants et les drapeaux avancés, consultez les compétences techniques address-sanitizer et undefined-behavior-sanitizer.

Exécuter des campagnes

Exécution de base

./fuzz --cores 0 --input corpus/

Fuzzing multi-cœur

./fuzz --cores 0,8-15 --input corpus/

Cela lance 9 clients : un sur le cœur 0, et 8 sur les cœurs 8-15.

Avec options

./fuzz --cores 0-7 --input corpus/ --output crashes/ --timeout 1000

Interface utilisateur textuelle (TUI)

Activez la vue graphique des statistiques :

./fuzz -tui=1 corpus/

Interprétation des résultats

SortieSignification
corpus: NNombre de cas de test intéressants trouvés
objectives: NNombre de plantages/timeouts trouvés
executions: NNombre total d'invocations de la cible
exec/sec: NDébit d'exécution actuel
edges: X%Pourcentage de couverture de code
clients: NNombre de processus de fuzzing parallèles

Le fuzzer émet deux principaux types d'événements :

  • UserStats - Pulsation régulière avec les statistiques actuelles
  • Testcase - Nouvelle entrée intéressante découverte

Utilisation avancée

Astuces et conseils

AstucePourquoi c'est utile
Utilisez -fork=1 -ignore_crashes=1Continuer le fuzzing après le premier plantage
Utilisez InMemoryOnDiskCorpusPersister le corpus entre les redémarrages
Activez TUI avec -tui=1Meilleure visualisation de la progression
Utilisez une version spécifique de LLVMÉvitez les problèmes de compatibilité
Définissez RUSTFLAGS correctementÉvitez les erreurs de linkage

Déduplication des plantages

Évitez de stocker des plantages en double provenant du même bogue :

Ajoutez un observateur de backtrace :

let backtrace_observer = BacktraceObserver::owned(
    "BacktraceObserver",
    libafl::observers::HarnessType::InProcess
);

Mettez à jour l'exécuteur :

let mut executor = InProcessExecutor::with_timeout(
    &mut harness,
    tuple_list!(edges_observer, time_observer, backtrace_observer),
    &mut fuzzer,
    &mut state,
    &mut restarting_mgr,
    timeout,
)?;

Mettez à jour l'objectif avec le feedback de hachage :

let mut objective = feedback_and!(
    feedback_or_fast!(CrashFeedback::new(), TimeoutFeedback::new()),
    NewHashFeedback::new(&backtrace_observer)
);

Cela garantit que seuls les plantages avec des backtraces uniques sont sauvegardés.

Fuzzing par dictionnaire

Utilisez des dictionnaires pour guider le fuzzing vers des jetons spécifiques :

Ajoutez des jetons depuis un fichier :

let mut tokens = Tokens::new();
if let Some(tokenfile) = &tokenfile {
    tokens.add_from_file(tokenfile)?;
}
state.add_metadata(tokens);

Mettez à jour le mutateur :

let mutator = StdScheduledMutator::new(
    havoc_mutations().merge(tokens_mutations())
);

Exemple de jetons codés en dur (PNG) :

state.add_metadata(Tokens::from([
    vec![137, 80, 78, 71, 13, 10, 26, 10], // En-tête PNG
    "IHDR".as_bytes().to_vec(),
    "IDAT".as_bytes().to_vec(),
    "PLTE".as_bytes().to_vec(),
    "IEND".as_bytes().to_vec(),
]));

Voir aussi : Pour des stratégies détaillées de création de dictionnaires et des dictionnaires spécifiques aux formats, consultez la compétence technique fuzzing-dictionaries.

Jetons automatiques

Extrayez automatiquement les valeurs magiques et les sommes de contrôle du programme :

Activez dans le wrapper de compilation :

cc.add_pass(LLVMPasses::AutoTokens)

Chargez les jetons automatiques dans le fuzzer :

tokens += libafl_targets::autotokens()?;

Vérifiez la section des jetons :

echo "p (uint8_t *)__token_start" | gdb fuzz

Réglage des performances

ParamètreImpact
Fuzzing multi-cœurAccélération linéaire avec le nombre de cœurs
InMemoryCorpusPlus rapide mais non persistant
InMemoryOnDiskCorpusVitesse et persistance équilibrées
SanitizersRalentissement de 2 à 5 fois, essentiel pour les bogues
Niveau d'optimisation -O2Équilibre entre vitesse et couverture

Déboguer le fuzzer

Exécutez le fuzzer en mode mono-processus pour un débogage plus facile :

// Remplacez le lanceur par un appel direct
run_client(None, SimpleEventManager::new(monitor), 0).unwrap();

// Commentez :
// Launcher::builder()
//     .run_client(&mut run_client)
//     ...
//     .launch()

Ensuite, déboguez avec GDB :

gdb --args ./fuzz --cores 0 --input corpus/

Exemples concrets

Exemple : libpng

Fuzzing de libpng avec LibAFL :

1. Obtenez le code source :

curl -L -O https://downloads.sourceforge.net/project/libpng/libpng16/1.6.37/libpng-1.6.37.tar.xz
tar xf libpng-1.6.37.tar.xz
cd libpng-1.6.37/
apt install zlib1g-dev

2. Définissez le wrapper de compilation :

export FUZZER_CARGO_DIR="/path/to/libafl/project"
export CC=$FUZZER_CARGO_DIR/target/release/libafl_cc
export CXX=$FUZZER_CARGO_DIR/target/release/libafl_cxx

3. Construisez la bibliothèque statique :

./configure --enable-shared=no
make

4. Obtenez le harnais :

curl -O https://raw.githubusercontent.com/glennrp/libpng/f8e5fa92b0e37ab597616f554bee254157998227/contrib/oss-fuzz/libpng_read_fuzzer.cc

5. Liez le fuzzer :

$CXX libpng_read_fuzzer.cc .libs/libpng16.a -lz -o fuzz

6. Préparez les graines :

mkdir seeds/
curl -o seeds/input.png https://raw.githubusercontent.com/glennrp/libpng/acfd50ae0ba3198ad734e5d4dec2b05341e50924/contrib/pngsuite/iftp1n3p08.png

7. Obtenez le dictionnaire (optionnel) :

curl -O https://raw.githubusercontent.com/glennrp/libpng/2fff013a6935967960a5ae626fc21432807933dd/contrib/oss-fuzz/png.dict

8. Commencez le fuzzing :

./fuzz --input seeds/ --cores 0 -x png.dict

Exemple : Projet CMake

Intégrez LibAFL avec le système de build CMake :

CMakeLists.txt :

project(BuggyProgram)
cmake_minimum_required(VERSION 3.0)

add_executable(buggy_program main.cc)

add_executable(fuzz main.cc harness.cc)
target_compile_definitions(fuzz PRIVATE NO_MAIN=1)
target_compile_options(fuzz PRIVATE -g -O2)

Construisez le binaire non instrumenté :

cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ .
cmake --build . --target buggy_program

Construisez le fuzzer :

export FUZZER_CARGO_DIR="/..."

Individual skills in this repo

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

bg-szy/TOP-SKILLS

Brand-first landing page designer — runs a brand-identity interview (colors, typography, shape language), then generates and iterates on a polished landing page via Stitch with deployment-ready HTML. Use when the user asks to create, design, or build a landing page, homepage, or marketing page and has no established visual direction. Skip when they have a design mockup, need a dashboard or app UI, are working at component level, building a multi-page app, or restyling with known design tokens — use frontend-design instead.

bg-szy/TOP-SKILLS

Fill out Microsoft Azure Landing Zone (ALZ) Accelerator checklists by interviewing the user, mapping their Azure subscriptions, integrating IP addressing documentation, and applying Microsoft Cloud Adoption Framework best practices. Produces a completed Excel checklist (.xlsx) ready for ALZ deployment. Use this skill whenever the user mentions Azure Landing Zone, ALZ checklist, landing zone accelerator, platform landing zone configuration, ALZ bootstrap, hub-and-spoke setup, Azure network topology planning, or wants to fill out any ALZ-related checklist or configuration file. Also trigger when the user uploads an Excel file that contains tabs like "Accelerator - Bootstrap", "Accelerator - Bicep", or "Accelerator - Terraform".

bg-szy/TOP-SKILLS

Compose a premium, animated landing page section by section in Next.js + Tailwind + Motion (Framer Motion) — built on a real design system, with editorial copy and motion that feels human-crafted, not template-generated. Use when building or rebuilding a landing page, marketing site, or hero/feature/pricing/CTA sections that need to look production-ready and bespoke from day one.

bg-szy/TOP-SKILLS

Write high-converting landing page copy using proven frameworks like PAS (Problem-Agitate-Solution), AIDA, and StoryBrand. Creates headlines, value propositions, CTAs, and full page sections optimized for conversion. Use when users need landing page copy, sales page content, or marketing website text.

bg-szy/TOP-SKILLS

Optimize landing pages for conversions, performance, and SEO. Use when improving landing pages, increasing conversions, or optimizing page performance.

bg-szy/TOP-SKILLS

Review investment portfolios for risk, diversification, fees. Asset allocation recommendations, tax-loss harvesting, rebalancing.

bg-szy/TOP-SKILLS

Beads Viewer - Graph-aware triage engine for Beads projects. Computes PageRank, betweenness, critical path, and cycles. Use --robot-* flags for AI agents.

bg-szy/TOP-SKILLS

CI red? Call us. Pipeline fire brigade deploys. Use when user mentions CI failures, build errors, test failures, or pipeline issues. Do NOT load for: local builds, standard implementation work, reviews, or setup.

bg-szy/TOP-SKILLS

CASS Memory System - procedural memory for AI coding agents. Three-layer cognitive architecture with confidence decay, anti-pattern learning, cross-agent knowledge transfer, trauma guard safety system. Bun/TypeScript CLI.

bg-szy/TOP-SKILLS

Mandatory entry point: read this first for any request to make, create, edit, animate, or render a video, animation, or motion graphic, including a promo, explainer, captioned clip, title card, overlay, slideshow or interactive deck, Remotion port, or any HyperFrames HTML composition. Also use it to inspect, diagnose, validate, preview, publish, or batch-render an existing HyperFrames project. Inputs may be a website URL, GitHub PR, Figma design or URL, text or brief, existing footage, or music. It resumes project state, captures intent when applicable, selects and installs the owning workflow, and routes domain capabilities. HyperFrames is the default output framework unless the user explicitly chooses another framework for the deliverable or asks only to record a browser session.

bg-szy/TOP-SKILLS

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

bg-szy/TOP-SKILLS

Use when the user asks to "pre-launch check the landing page", "run a Quality-Score preflight", or "verify ad-to-page message match before launch"; produces an ad↔page continuity report — message-match gaps, above-the-fold check, page-speed read, form-friction count, mobile-render flags — as a pass/fix punch list. Not for redesigning or rewriting the page — use landing-optimizer; not for scoring the account or the RQS — use ad-account-auditor. 落地页体验预检/广告落地页一致性检查

bg-szy/TOP-SKILLS

Use when the user asks to "optimize our landing page for influencer traffic", "fix our promo-code landing page", or "improve conversion from a creator campaign"; produces a message-match audit, page-structure and social-proof recommendations, a promo-code/CTA conversion plan, and an A/B test roadmap. Not for measuring campaign results after launch — use performance-analyzer.

bg-szy/TOP-SKILLS

Audit a landing page, sales page or checkout page for conversion leaks and return a fix list ordered by expected revenue impact. Use when asked to review, critique or improve a landing page, sales page, opt-in page, product page or checkout flow, when conversion rate is low, when paid traffic is not converting, or when someone asks "why isn't this page converting" or wants a CRO / landing page review.

bg-szy/TOP-SKILLS

Landing page conversion optimization with layout rules, hero section design, and CTA psychology. Covers above-the-fold formula, social proof placement, mobile design, and F-pattern reading. Use for: startup landing pages, product pages, SaaS marketing, conversion optimization. Triggers: landing page, hero section, above the fold, conversion optimization, landing page design, cta button, hero image, landing page layout, saas landing page, product page design, conversion rate, landing page best practices

bg-szy/TOP-SKILLS

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

bg-szy/TOP-SKILLS

Landing page conversion optimization with layout rules, hero section design, and CTA psychology. Covers above-the-fold formula, social proof placement, mobile design, and F-pattern reading. Use for: startup landing pages, product pages, SaaS marketing, conversion optimization. Triggers: landing page, hero section, above the fold, conversion optimization, landing page design, cta button, hero image, landing page layout, saas landing page, product page design, conversion rate, landing page best practices

bg-szy/TOP-SKILLS

Account assets, equity and fund positions, P&L, cash flow records, account statements, margin ratios, buy-power estimates, order management, and DCA recurring investments via Longbridge (most require Trade permission). Frameworks: portfolio diagnosis, rebalancing, asset allocation, risk analysis (VaR/CVaR), performance attribution, and tax-loss harvesting. Triggers: "持仓", "账户", "盈亏", "资产", "对账单", "下单", "买入", "卖出", "撤单", "定投", "组合诊断", "再平衡", "资产配置", "风险分析", "绩效归因", "税损收割", "持倉", "賬戶", "盈虧", "對賬單", "下單", "買入", "賣出", "組合診斷", "再平衡", "稅損收割", "positions", "portfolio", "P&L", "order", "buy", "sell", "DCA", "statement", "risk analysis", "rebalancing", "tax harvesting", "我的风险", "持仓风险", "风险敞口", "資產", "資產配置", "風險分析", "績效歸因", "撤單

bg-szy/TOP-SKILLS

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

bg-szy/TOP-SKILLS

Process video files with audio extraction, format conversion (mp4, webm), and Whisper transcription. Use when user mentions video conversion, audio extraction, transcription, mp4, webm, ffmpeg, or whisper transcription.

Skills associés