Communitygithub.com

OneWave-AI/claude-skills

Stelle eine 2-schichtige, parallele Agenten-Hierarchie für große, parallelisierbare Arbeiten bereit – große Refaktorisierungen, dateiübergreifende Migrationen, codebase-weite Audits, Massengenerierung.

Was ist claude-skills?

Dieses Skill ermöglicht es, einen ‚Agenten-Armee‘-Ansatz zu nutzen, um Aufgaben mit vielen unabhängigen Arbeitseinheiten (6+) massiv zu beschleunigen. Es erstellt eine zweischichtige Hierarchie: Ein übergeordneter Commander (Fable oder Opus) orchestriert eine Schwarm von Layer-1-Agenten, die jeweils ihren eigenen, vollen Kontextfenster (z.B. 1M Token) besitzen. Jeder Layer-1-Agent wiederum beaufsichtigt 2+ Layer-2-Subagenten. Der Benutzer wählt eine ‚Power Level‘-Einstellung (Max Power / Heavy / Balanced / Economy), die bestimmt, welches Modell (Opus/Sonnet/Haiku) für die unteren Schichten verwendet wird. Dies maximiert die Parallelverarbeitung und verhindert Engpässe, die durch das Teilen eines einzigen Kontextfensters entstehen – im Gegensatz zu einem ‚Schwarm‘. Das Skill ist für Claude Code, Cursor und andere KI-Assistenten konzipiert und beinhaltet Git-Sicherheitschecks, gestaffelte Größenbestimmung, ein Deployment-Gate sowie Prüfungen auf Phantomerledigungen, bei denen die tatsächlichen Änderungen mit den Agentenberichten verglichen werden.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/OneWave-AI/claude-skills/tree/HEAD/agent-army

In Ihrer bevorzugten KI fragen

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

Dokumentation

Agentenarmee

Ein 2-schichtiges paralleles Ausführungsframework. Der Commander ist das Top-Level-Modell – standardmäßig Fable oder Opus, wenn das das Sitzungsmodell ist – und übernimmt das Denken: Aufklärung, Komposition, Briefing, Verifikation. Er orchestriert Schwärme untergeordneter Modelle, deren Stufe der Benutzer beim Deployment wählt (siehe Power Level). Jeder Layer-1-Agent besitzt seinen eigenen, vollständigen Kontextfenster (kein Ausschnitt). Jeder erzeugt Layer-2-Subagenten unter sich. Das Ergebnis sind viele unabhängige Gehirne, die gleichzeitig arbeiten – nicht ein geteiltes Gehirn.

Commander (Sie – Fable oder Opus, das Sitzungsmodell)
 |
 |-- Layer 1: Team (3 bis 50+, jeder = eigener 1M Kontext, L1-Stufe aus Power Level)
 |    |-- Agent A (1M) -- Sub-Agent A1, A2, ... (L2-Stufe)
 |    |-- Agent B (1M) -- Sub-Agent B1, B2, ... (L2-Stufe)
 |    |-- Agent C (1M) -- Sub-Agent C1, C2, ... (L2-Stufe)
 |    |-- ... (keine Obergrenze)

Schwarm vs. Armee: Ein Schwarm teilt ein Kontextfenster auf mehrere Sub-Agenten auf – ein Gehirn, geteilt. Eine Armee gibt jedem Layer-1-Mitglied sein eigenes Fenster. Dieser Unterschied ist der Kern dieses Skills.

Wann verwenden

  • Große Refaktorisierungen, die viele Dateien umfassen
  • Dateiübergreifende Farb-/Stil-/Namens-/API-Migrationen
  • Breite Codebase-Audits (Sicherheit, Barrierefreiheit, Leistung, toter Code)
  • Massenhafte Inhaltsgenerierung oder -transformation
  • Jede Aufgabe mit 6+ unabhängigen Arbeitseinheiten, die gleichzeitig ausgeführt werden können

Wann NICHT verwenden

  • Weniger als 6 unabhängige Arbeitseinheiten – führen Sie es direkt aus
  • Starke sequenzielle Abhängigkeiten, bei denen jeder Schritt die Ausgabe des vorherigen benötigt
  • Einzeldateiänderungen
  • Aufgaben, die eine einzige, zusammenhängende Autorenstimme über alle Ausgaben hinweg benötigen (parallele Agenten driften auseinander)

Wenn die Aufgabe nicht klar passt, sagen Sie dies und schlagen Sie vor, sie inline statt einer Armee zu erledigen.

  1. JEDER Layer-1-Agent MUSS 2+ Sub-Agenten erzeugen. Keine Ausnahmen. Wenn Sie im Begriff sind, einen L1-Agenten ohne Sub-Agenten bereitzustellen, HALTEN Sie an und strukturieren Sie um.
  2. Verkleinern Sie die Armee NIEMALS stillschweigend. Halten Sie die vom Benutzer gewählte Stufe ein. Wenn Sie abweichen müssen, sagen Sie dies laut und erklären Sie, warum. 2b. Downgraden Sie Modelle NIEMALS stillschweigend. Übergeben Sie model: explizit bei jedem Agent-Aufruf mit der vom Benutzer gewählten Power Level. Das Weglassen erbt das Sitzungsmodell – das ist eine stille Max-Power-Abrechnung.
  3. Sub-Agenten-Bereitstellungsanweisungen gehen INS L1-Briefing. Fehlen sie, werden die Sub-Agenten nie erstellt.
  4. Melden Sie, sobald Agenten fertig sind: [Agent N/M complete] name: X Dateien geändert, Y Flags.
  5. Zeigen Sie den Armeeplan an und durchlaufen Sie das Deployment-Gate vor dem Bereitstellen (Full Mode). Quick Mode erstellt den Plan intern, durchläuft aber trotzdem das Gate.
  6. Nach jeder Welle: Führen Sie den Build UND die Phantomerledigungs-Prüfung durch (siehe Verify). Ein grüner Bericht eines Agenten ist eine Behauptung, kein Beweis.
  7. „Weitermachen“/„nicht anhalten“ = kontinuierlicher Modus: Starten Sie einen neuen Agenten, sobald einer fertig ist. Warten Sie nicht, fragen Sie nicht erneut.

Armeegröße

Bestätigen Sie eine Stufe vor dem Start. Zeigen Sie diese Tabelle an:

| Stufe          | L1-Agenten | Gesamt mit Sub-Agenten | Geschätzte Token |
|----------------|------------|------------------------|------------------|
| Konservativ    | 3          | ~9                     | ~200-500K        |
| Standard       | 5-10       | ~15-30                 | ~500K-1.5M       |
| Aggressiv      | 10-20      | ~30-60                 | ~1.5-4M          |
| Maximal        | 20-50+     | ~60-100+               | ~4M+             |
| Benutzerdefiniert | Sie wählen | Sie wählen             | variiert         |

Standardmäßig Standard auf „mach es einfach.“ Nach der Aufklärung (Schritt 3) empfehlen Sie eine spezifische Anzahl basierend auf dem, was Sie gefunden haben – z.B. „35 Dateien in 6 Bereichen → Aggressiv: 8 L1-Agenten, 2-3 Sub-Agenten pro Agent (~22 insgesamt, ~2M Token). Anpassen?“ Token-Schätzungen sind grob und skalieren mit der Aufgabenkomplexität.

Power Level

Größe bestimmt, wie viele Agenten; Power bestimmt, welche Modelle. Fragen Sie beides in einer Frage (AskUserQuestion funktioniert gut – Größe und Power als zwei Fragen in einem Aufruf). Überspringen Sie die Frage, wenn der Benutzer bereits eine Power Level oder explizite Modelle genannt hat.

| Power Level         | Commander              | Layer 1 | Layer 2 | Am besten geeignet für                          |
|---------------------|------------------------|---------|---------|-------------------------------------------------|
| Max Power           | Fable/Opus (Sitzung)   | Opus    | Opus    | Knifflige Refaktorisierungen, korrektheitskritische Migrationen|
| Heavy (empfohlen)   | Fable/Opus (Sitzung)   | Opus    | Sonnet  | Die meisten großen Aufgaben – intelligente Orchestrierung, schnelle Ausführung|
| Balanced            | Fable/Opus (Sitzung)   | Sonnet  | Sonnet  | Mechanische Migrationen mit klaren Mustern       |
| Economy             | Fable/Opus (Sitzung)   | Sonnet  | Haiku   | Massenhafte, einfache Suchen/Ersetzen            |

Regeln:

  • Der Commander ist immer das Sitzungsmodell – Fable oder Opus, die Wahl des Benutzers – und wird nie delegiert. Wenn die Sitzung Sonnet oder Haiku ausführt, sagen Sie dem Benutzer, er soll wechseln (/model oder claude --model fable), bevor er bereitstellt: Die Commander-Qualität ist die Obergrenze für die Armeequalität.
  • Übergeben Sie das Modell explizit bei jedem Agent-Aufruf: model: "<L1-Stufe>" für Teammitglieder; L1-Briefings instruieren model: "<L2-Stufe>" für Sub-Agenten.
  • Hochstufung pro Agent ist auf jeder Power Level erlaubt: Eine schwere oder verworrene Datei (1000+ Zeilen, komplexe Logik) kann diesen einen Sub-Agenten um eine Stufe höher stufen. Notieren Sie Hochstufungen im Armeeplan.
  • Audit-Wellen laufen auf Opus, unabhängig von der Power Level – frische, stärkere Augen auf die Arbeit der Ausführenden. Benachrichtigungswellen können auf Haiku abfallen.

Protokoll

Modus: Wenn der Umfang bereits konkret ist (Dateipfade, genaue Änderungen, Stufe), fahren Sie mit Schritt 3 fort (Quick Mode). Andernfalls beginnen Sie mit Schritt 1 (Full Mode).

Schritt 1: Erfassung (Full Mode)

Bestätigen Sie in einer Zeile, ob der Benutzer bereits Kontext gegeben hat: „Ziel: [X]. Umfang: [Y]. Stufe: [Z]. Power: [P]. Starte.“ Andernfalls fragen Sie nach: Ziel (ein Satz), Umfang (Dateien/Verzeichnisse/"alles"), Einschränkungen (X nicht anfassen, Y entsprechen), Stufe und Power Level.

Schritt 2: Git-Checkpoint

  1. git status – warnen Sie vor nicht committeten Änderungen, bieten Sie an, zu stashen/committen.
  2. git checkout -b agent-army/checkpoint-{timestamp}, dann zurückwechseln. Dies ist der Rollback-Punkt.
  3. Kein Git-Repo? Warnen Sie, dass es kein Sicherheitsnetz gibt, und holen Sie eine explizite Bestätigung ein.

Schritt 3: Aufklärung

  1. Grep / Glob / Read, um jede betroffene Datei zu finden.
  2. Zählen Sie die Arbeitseinheiten.
  3. wc -l für jede Datei. Markieren Sie Dateien mit 500+ Zeilen als schwer → weisen Sie einzeln zu.
  4. Klassifizieren Sie in Bereiche (nach Verzeichnis, Importgraph, Dateityp, Benennungsmuster).
  5. Identifizieren Sie gemeinsame Abhängigkeiten – Grundlagendateien, die bereichsübergreifend importiert werden. Bearbeiten Sie diese zuerst (Schritt 5).
  6. Identifizieren Sie den Build-Befehl (package.json, Makefile, etc.).

Ausgabe: Dateien: N | Schwer: [Liste] | Bereiche: [Liste] | Gemeinsame Abhängigkeiten: [Liste] | Build-Befehl: [Befehl]

Schritt 4: Zusammensetzen

  1. Basis-Agent für gemeinsame Abhängigkeiten – läuft vor der parallelen Welle, damit Abhängige nicht in Konflikt geraten.
  2. Layer 1: ein Agent pro Bereich; teilen Sie große Bereiche auf mehrere Agenten auf.
  3. Layer 2: 2+ Sub-Agenten pro L1-Agent, zugewiesen nach gewichteter Dateilast, nicht nach Dateianzahl:
    • Klein (<200 Zeilen): 2-3 pro Sub-Agent
    • Mittel (200-500): 1-2 pro Sub-Agent
    • Schwer (500+): 1 pro Sub-Agent, einzeln
  4. Benennen Sie jeden Agenten. Weisen Sie jede Datei genau einem Sub-Agenten zu – keine Überlappungen, keine Lücken.

Geben Sie den Armeeplan aus. Full Mode: Pause für „Fortfahren?“ Quick Mode: Einzeiler-Zusammenfassung, dann bereitstellen.

Deployment-Gate

Geben Sie diese Checkliste in Ihrer Antwort vor dem Bereitstellen aus. Prüfen Sie sie nicht mental – schreiben Sie sie aus.

DEPLOYMENT GATE:
[ ] Jedes L1-Briefing enthält "Sie MÜSSEN N Sub-Agenten erzeugen"
[ ] Jeder Sub-Agent ist benannt und hat spezifische Dateien zugewiesen
[ ] Jede Datei gehört genau einem Sub-Agenten (keine Überlappung, keine Lücke)
[ ] L1-Briefings enthalten vollständige Sub-Agenten-Bereitstellungsanweisungen
[ ] Stufe stimmt mit der Auswahl des Benutzers überein
[ ] Power Level gesetzt: `model: "<L1-Stufe>"` bei jedem L1-Aufruf; L2-Stufe + Hochstufungen in jedem Briefing

Alle müssen BESTANDEN sein. Jedes NICHT BESTANDEN → Plan vor dem Bereitstellen reparieren.

Schritt 5: Bereitstellen

  1. Basis-Agent zuerst (falls vorhanden), auf L1-Stufe. Warten Sie auf Abschluss.
  2. Starten Sie ALLE Layer-1-Agenten parallel – run_in_background: true und model: "<L1-Stufe>" bei jedem Aufruf, in einer einzigen Nachricht.
  3. Jeder L1-Agent erzeugt seine L2-Sub-Agenten parallel (gemäß seinem Briefing).
  4. Melden Sie jeden Abschluss: [Agent N/M abgeschlossen] Name: Ergebnisse.

Schritt 6: Überprüfen

  1. Erneutes Scannen – führen Sie erneut die Suchen aus Schritt 3 nach verbleibenden Verstößen durch.
  2. Phantomerledigungs-Prüfung – führen Sie git diff --stat aus und gleichen Sie es mit den Agentenberichten ab. Jeder Agent, der "ABGESCHLOSSEN, N Dateien geändert" gemeldet hat, ohne passenden Diff, hat gelogen oder nichts gemacht – setzen Sie ihn erneut ein. Vertrauen Sie dem Diff, nicht dem Bericht.
  3. Build – führen Sie den Build-Befehl aus. Notieren Sie BESTANDEN/NICHT BESTANDEN.
  4. Lösen Sie teamübergreifende Flags aus den Berichten auf.
  5. Geben Sie den Armeebericht aus:
Agenten: N | Geänderte Dateien: N (diff-bestätigt) | Übersprungen: N | Build: BESTANDEN/NICHT BESTANDEN
Flags: [Liste] | Phantomerledigungen erwischt: N | Rollback: git checkout agent-army/checkpoint-{timestamp}

Wellen

Jede Welle ist eine neue, kleinere, anders spezialisierte Armee. Pausieren Sie vor jeder für die Zustimmung des Benutzers. Maximal 4 Wellen.

WelleNameAuslöserZweck
1AusführenimmerÄnderungen vornehmen
2AuditBuild fehlgeschlagen, verbleibende Verstöße, 20+ Dateien oder Flags > 0Neue Agenten überprüfen Welle 1 auf Korrektheit/Grenzfälle
3PropagierenÄnderungen betreffen APIs/Typen/Schnittstellen; Tests oder Dokumente referenzieren alte MusterTests, Dokumentation, Konfigurationen, nachgelagerte Aufrufer aktualisieren
4BenachrichtigenBenutzer stimmt zuPR-Beschreibung, Changelog, Slack-Zusammenfassung entwerfen

Der Bericht jeder Welle ist die Aufklärung für die nächste Welle. Führen Sie nach jeder die Überprüfung erneut durch; stoppen Sie, wenn der erneute Scan sauber ist und der Build bestanden wird, oder nach 4 Wellen.

Fortsetzung / Notizblock

Für mehrwellige oder unterbrechbare Läufe schreiben Sie .army-state.md nach Welle 1: geänderte Dateien (diff-bestätigt), offene Flags, ungelöste Probleme, Entscheidungen. Wenn ein Lauf abgebrochen wird, liest der nächste Aufruf diese Datei und setzt ab der letzten sauberen Welle fort, anstatt neu zu starten. Überspringen Sie dies für Einwellenaufgaben.

Layer-1-Befehlsvorlage

Dies ist, was erzeugte Agenten tatsächlich sehen – der wichtigste Abschnitt des Skills.

Sie sind [AGENT_NAME], Spezialist für [BEREICH].

Ziel: [ein Satz]
Zugelassene Muster: [genaue Werte – Hexcodes, Klassennamen, API-Formen]
Verbotene Muster: [was entfernt/vermieden werden soll]
Ihre Dateien: [absolute Pfade mit Zeilenanzahlen]
Regeln: [Einschränkungen]. Überspringen Sie Dateien, die bereits zugelassene Muster verwenden (Idempotenz).
Markieren Sie Probleme außerhalb Ihrer Dateien in "Flags für Commander" – beheben Sie sie NICHT.

KRITISCH: Sie MÜSSEN das Agent-Tool verwenden, um die unten aufgeführten Sub-Agenten zu erzeugen. Tun
Sie die Arbeit NICHT selbst. Überspringen Sie die Erzeugung NICHT. Setzen Sie ALLE Sub-Agenten in einer einzigen
Nachricht mit mehreren Agent-Tool-Aufrufen ein, wobei Sie model: "[L2_STUFE]" bei jedem Aufruf übergeben
[notieren Sie Hochstufungen: außer "NAME", der model: "[höhere Stufe]" erhält].

Sub-Agenten:
- "[NAME]": [Dateien mit Zeilenanzahlen]
- "[NAME]": [Dateien mit Zeilenanzahlen]

Übergeben Sie jedem Sub-Agenten: Ziel, ihre Dateien, zugelassene/verbotene Muster, Regeln,
Berichtsformat. Nachdem alle abgeschlossen sind, fassen Sie ihre Berichte zusammen und verifizieren Sie (durch erneutes Lesen
oder Greppen), dass keine verbotenen Muster mehr in Ihrem Bereich vorhanden sind, bevor Sie Bericht erstatten.

Layer-2-Befehlsvorlage

Sie sind [SUB_AGENT_NAME], arbeiten unter [TEAM_MITGLIED_NAME].

Ziel: [ein Satz]
Dateien, die Sie besitzen: [absolute Pfade mit Zeilenanzahlen – berühren Sie nur diese]
Zugelassene / Verbotene Muster: [genaue zu verwendende und zu entfernende Werte]
Regeln: [Einschränkungen]. Überspringen Sie Dateien, die bereits korrekt sind. Markieren Sie Probleme außerhalb Ihrer Dateien –
beheben Sie sie NICHT.

Prozess: Lesen Sie jede Datei vollständig → prüfen Sie Idempotenz → wenden Sie zugelassene an, entfernen Sie verbotene
→ lesen Sie erneut, um sicherzustellen, dass keine verbotenen Muster mehr vorhanden sind.

Bericht: Geänderte Dateien (Datei: N Ersetzungen), Übersprungene Dateien (bereits korrekt),
Flags für Commander, Probleme, Status (ABGESCHLOSSEN/TEILWEISE/FEHLGESCHLAGEN).

Berichtsformat

Jeder Agent gibt zurück:

## Bericht: [Name]
Geänderte Dateien:   [Datei: N Ersetzungen]
Übersprungene Dateien:    [Datei: Grund]
Flags für Commander: [Problem oder "Keine"]
Probleme:           [Problem oder "Keine"]
Status:           ABGESCHLOSSEN / TEILWEISE / FEHLGESCHLAGEN

Anti-Patterns

Dies sind die Fehlermodi, die dieses Skill verhindern soll. Wenn Sie sich dabei ertappen, einen zu begehen, halten Sie an und korrigieren Sie.

  • Phantom-Fan-Out – Ein L1-Agent erledigt die Arbeit selbst, anstatt Sub-Agenten zu erzeugen. Der gesamte Geschwindigkeitsvorteil ist weg. Durchgesetzt durch Pflichtregel 1 + das Gate.
  • Phantom-Erledigung – Ein Agent meldet ABGESCHLOSSEN, ohne etwas bearbeitet zu haben. Wird durch den git diff --stat-Abgleich erkannt, nicht durch Vertrauen auf den Bericht.
  • Stille Verkleinerung – Stiller Betrieb von 3 Agenten, wenn der Benutzer Aggressiv gewählt hat. Weichen Sie immer sichtbar ab.
  • Modell-Drift – Weglassen von model: bei Agent-Aufrufen, so dass jeder Sub-Agent stillschweigend das Commander-Modell erbt. Der Benutzer hat Economy gewählt und bekam Max Power berechnet. Durchgesetzt durch Pflichtregel 2b + das Gate.
  • Überlappende Zuständigkeit – Zwei Sub-Agenten bearbeiten dieselbe Datei → Konflikte und verlorene Änderungen. Durchgesetzt durch den genau-ein-Besitzer im Gate.
  • Überspringen der Basis – Abhängige berühren, bevor gemeinsame Dateien aktualisiert werden → Kaskade kaputter Importe. Basis-Agent läuft zuerst.
  • Armee für eine kleine Aufgabe – 9 Agenten für 4 Dateien ist langsamer (Orchestrierungs-Overhead) und verbrennt Token. Siehe „Wann NICHT verwenden".

Fehlerbehandlung

  • Sub-Agent schlägt fehl → L1-Agent wiederholt seine Dateien oder erzeugt einen Ersatz.
  • L1-Agent schlägt fehl → Commander erzeugt einen Ersatz mit dem gleichen Briefing.
  • Build-Fehler → Diff gegen den Checkpoint-Branch, um den Bruch zu isolieren, dann eine Fix-Welle ausführen.
  • Phantom-Erledigung → Die Dateien dieses Agenten an einen neuen Agenten weiterleiten.
  • Idempotenz bei erneuter Ausführung → Agenten prüfen zuerst auf bereits angewendete Muster, sodass eine zweimalige Ausführung der Armee nie doppelt angewendet wird.

Arbeitsbeispiel

Benutzer

…

[gekürzt für Übersetzung]

Individual skills in this repo

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

OneWave-AI/claude-skills

Generate animated videos and motion graphics from natural language descriptions. Creates a standalone Vite + React project with Framer Motion scenes that auto-play in the browser. Use when the user wants to create animations, motion graphics, video intros, animated presentations, or product demos.

OneWave-AI/claude-skills

Use before starting a product, feature, MVP, agent, automation, or integration build to identify the main pre-build risk and choose the smallest validation step. Trigger when the user asks whether to build, scope, validate, prioritize, or sanity-check an idea before implementation.

OneWave-AI/claude-skills

Post-mortem analysis when a client churns. Takes client history, engagement data, support tickets, usage logs, and exit feedback to produce a comprehensive churn autopsy with root cause classification, timeline of decline, and preventive measures.

OneWave-AI/claude-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.

OneWave-AI/claude-skills

Assemble 2-3 complementary experts to collaboratively analyze anything. Experts work together to explore topics from multiple expert angles.

OneWave-AI/claude-skills

Convert any topic into playable browser games. Types: trivia, matching, word puzzles, adventure games. Uses Phaser.js or Kaboom.js.

OneWave-AI/claude-skills

Turn a marketing brief or product offer into a finished short-form video ad built in HyperFrames — hook, script, shot-by-shot storyboard, scene-by-scene HTML composition, captions, and voiceover. Outputs platform cuts (vertical 9:16, square, 16:9). Use when you need a launch ad, product promo, social video, or paid-creative concept ready to render.

OneWave-AI/claude-skills

Turn a website URL, product docs, or a founder's rambling description into a tight 60-90 second explainer video built in HyperFrames -- problem/solution narrative, animated product walkthrough scenes, captions, and voiceover, ready for the homepage hero, sales emails, and onboarding.

OneWave-AI/claude-skills

Build promo videos for local businesses in HyperFrames -- the new-menu drop, the seasonal offer, the event announcement, the "we're hiring" post, the Google Business Profile clip. Restaurant, salon, gym, trades: 15-30 seconds, brand-clean, captioned, sized for Instagram, Facebook, and the profile.

OneWave-AI/claude-skills

Build a personalized product-demo or sales-walkthrough video in HyperFrames for a specific prospect or account — narrated screen-by-screen, branded to them, ending in a clear next step. Turns a generic demo into a "this was made for me" asset for outbound, follow-up, or deal acceleration. Use when you want to send a tailored video instead of booking another live call.

OneWave-AI/claude-skills

Turn real customer reviews, quotes, and case-study results into polished social-proof videos built in HyperFrames -- single-testimonial spotlights, review-wall montages, and stat-driven proof reels with captions and voiceover, cut for vertical, square, and wide. The highest-converting content most businesses never make.

OneWave-AI/claude-skills

Audit a codebase for LLM calls that are really classifications in disguise, then produce a costed swap plan for a System One model. Use when asked to cut AI inference cost or latency, when scoping a performance engagement for a client, when reviewing an agent loop that feels slow, or when asked "where could we use Jev here". Produces a ranked table of candidates with measured latency and dollar deltas.

OneWave-AI/claude-skills

Build and run a labelled eval set for a System One model (Jev, Von, or any typed-decision config), then sweep criteria wordings and thresholds against it. Use when a Jev/Von classification is wrong or unreliable, when choosing between the hosted API and a local open model, when tuning noul thresholds, or before shipping any typed-decision feature. Produces an accuracy-by-wording matrix and a calibrated threshold.

OneWave-AI/claude-skills

Wire a System One model (Jev, or an open reproduction like Von) into a product feature — routing, guardrails, scoring, classification. Use when replacing an LLM call that returns a label rather than prose, when adding a typed decision to an agent loop, or when deciding between the hosted Jev API and a local open model. Covers question design, the eval-set-first workflow, threshold calibration, confidence gates, and the traps measured on real data.

OneWave-AI/claude-skills

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

OneWave-AI/claude-skills

TAM/SAM/SOM calculator with deep market research. Produces comprehensive market-sizing.md with top-down and bottom-up estimates, methodology, data sources, assumptions, sensitivity ranges, growth projections, competitive landscape, and Mermaid visualizations. Use when user needs market size estimates, addressable market analysis, go-to-market sizing, investor-ready market analysis, or business plan market validation.

OneWave-AI/claude-skills

Generate unique personalized first lines for hundreds of prospects using company news, LinkedIn activity, and mutual connections. Saves 10+ hours of manual research per campaign. Use when you need personalized outreach at volume.

OneWave-AI/claude-skills

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

OneWave-AI/claude-skills

Create multiple choice, true/false, fill-in-blank, matching quizzes. Auto-generate plausible distractors. Instant grading with explanations.

OneWave-AI/claude-skills

Enhanced skill navigator that maps conversation history, recommends multi-skill chains, identifies patterns from past usage, and learns from session outcomes. Goes beyond basic scout with deep context analysis and workflow orchestration.

Verwandte Skills