Communitygithub.com

majiayu000/claude-skill-registry-data

Multi-Projekt-Portfolio-Analyse-Dashboard. Aggregiert KPIs über mehrere Projekte hinweg, verfolgt die Portfoliogesundheit, vergleicht die Leistung und unterstützt die strategische Entscheidungsfindung.

Was ist claude-skill-registry-data?

Diese Fähigkeit bietet ein umfassendes Multi-Projekt-Portfolio-Analyse-Dashboard, mit dem Projektmanager und Führungskräfte Kennzahlen aus mehreren Bauprojekten aggregieren und analysieren können. Sie verfolgt wichtige Leistungsindikatoren (KPIs) zu Kosten, Zeitplan, Sicherheit, Qualität und Risiken auf Portfolioebene und ermöglicht so einen ganzheitlichen Überblick. Die Lösung unterstützt die Bewertung der Portfoliogesundheit durch farblich gekennzeichnete Status (Grün, Gelb, Rot, Grau), den Vergleich von Projektleistungen, die Identifizierung von Risikoprojekten und die Prognose zukünftiger Cash-Bedarfe. Entwickelt als Python-Klasse (`PortfolioDashboard`) mit Dataclasses für strukturierte Daten, lässt sie sich in bestehende Systeme integrieren oder als Referenz für die Implementierung anpassungsfähiger Dashboard-Lösungen nutzen.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry-data/tree/HEAD/analysis/portfolio-dashboard

In Ihrer bevorzugten KI fragen

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

Dokumentation

Portfolio-Dashboard

Übersicht

Daten aus mehreren Bauprojekten aggregieren und analysieren, um Transparenz auf Portfolioebene zu schaffen. Verfolgen Sie KPIs, identifizieren Sie Trends, vergleichen Sie die Projektleistung und unterstützen Sie strategische Ressourcenallokationsentscheidungen.

Portfolio-Analyse-Framework

┌─────────────────────────────────────────────────────────────────┐
│                  PORTFOLIO-DASHBOARD                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  PROJEKT A    PROJEKT B    PROJEKT C    PROJEKT D               │
│     ↓             ↓            ↓            ↓                   │
│  ┌─────────────────────────────────────────────┐                │
│  │           DATENAGGREGATION                   │                │
│  │  Kosten | Zeitplan | Sicherheit | Qualität | Risiko │                │
│  └─────────────────────────────────────────────┘                │
│                         ↓                                        │
│  ┌─────────────────────────────────────────────┐                │
│  │          PORTFOLIO-KPIs                      │                │
│  │  📊 Gesamtwert    📈 Termintreue %           │                │
│  │  💰 Budgettreue %  🛡️ Sicherheitsrate        │                │
│  │  ⚠️ Risikoscore   📋 Ressourcenauslastung   │                │
│  └─────────────────────────────────────────────┘                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Technische Implementierung

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta
from enum import Enum
import statistics

class ProjektStatus(Enum):
    PLANUNG = "planning"
    AKTIV = "active"
    PAUSIERT = "on_hold"
    ABGESCHLOSSEN = "complete"
    STORNIERT = "cancelled"

class Gesundheitsstatus(Enum):
    GRUEN = "green"       # Im Plan
    GELB = "yellow"     # Gefährdet
    ROT = "red"           # Kritisch
    GRAU = "grey"         # Nicht gestartet/pausiert

@dataclass
class Projektkennzahlen:
    projekt_id: str
    projekt_name: str
    status: ProjektStatus
    vertragswert: float
    prozent_abgeschlossen: float

    # Zeitplan
    geplanter_start: datetime
    geplantes_ende: datetime
    tatsaechlicher_start: Optional[datetime]
    prognose_ende: datetime
    terminabweichung_tage: int = 0

    # Kosten
    budget: float
    tatsaechliche_kosten: float
    prognosekosten: float
    kostenabweichung: float = 0.0
    cpi: float = 1.0
    spi: float = 1.0

    # Sicherheit
    meldepflichtige_vorfaelle: int = 0
    gesamtstunden: float = 0
    trir: float = 0.0

    # Qualität
    offene_maengel: int = 0
    nacharbeitskosten: float = 0.0

    # Risiko
    risikoscore: float = 0.0
    kritische_risiken: int = 0

    @property
    def gesundheit(self) -> Gesundheitsstatus:
        """Bestimmt den Gesamtgesundheitsstatus des Projekts."""
        if self.status in [ProjektStatus.PAUSIERT, ProjektStatus.STORNIERT]:
            return Gesundheitsstatus.GRAU

        # Kritisch, wenn deutlich über Budget/Zeitplan
        if self.cpi < 0.85 or self.spi < 0.85 or self.kritische_risiken > 3:
            return Gesundheitsstatus.ROT

        # Gefährdet, wenn mäßig vom Plan abweicht
        if self.cpi < 0.95 or self.spi < 0.95 or self.kritische_risiken > 0:
            return Gesundheitsstatus.GELB

        return Gesundheitsstatus.GRUEN

@dataclass
class Portfoliozusammenfassung:
    berichtsdatum: datetime
    gesamte_projekte: int
    aktive_projekte: int
    gesamter_vertragswert: float
    gesamtbudget: float
    gesamte_tatsaechliche_kosten: float
    gesamte_prognosekosten: float

    # Leistung
    durchschnittlicher_cpi: float
    durchschnittlicher_spi: float
    budgettreue_prozent: float
    termintreue_prozent: float

    # Sicherheit
    portfolio_trir: float
    gesamte_vorfaelle: int

    # Gesundheitsverteilung
    gruene_anzahl: int
    gelbe_anzahl: int
    rote_anzahl: int

    # Trends
    kostentrend: str
    termintrend: str

@dataclass
class Projektvergleich:
    kennzahl: str
    projekte: Dict[str, float]
    durchschnitt: float
    bestes: Tuple[str, float]
    schlechtestes: Tuple[str, float]

class PortfolioDashboard:
    """Multi-Projekt-Portfolio-Analyse."""

    # Gesundheitsschwellenwerte
    SCHWELLENWERTE = {
        "cpi_warnung": 0.95,
        "cpi_kritisch": 0.85,
        "spi_warnung": 0.95,
        "spi_kritisch": 0.85,
        "trir_warnung": 2.0,
        "risikoscore_warnung": 7.0
    }

    def __init__(self, portfolio_name: str):
        self.portfolio_name = portfolio_name
        self.projekte: Dict[str, Projektkennzahlen] = {}
        self.momentaufnahmen: List[Dict] = []  # Historische Daten

    def projekt_hinzufuegen(self, kennzahlen: Projektkennzahlen):
        """Projekt zum Portfolio hinzufügen oder aktualisieren."""
        self.projekte[kennzahlen.projekt_id] = kennzahlen

    def projekte_importieren(self, projektdaten: List[Dict]) -> int:
        """Mehrere Projekte aus Daten importieren."""
        anzahl = 0
        for p in projektdaten:
            kennzahlen = Projektkennzahlen(
                projekt_id=p['id'],
                projekt_name=p['name'],
                status=ProjektStatus(p.get('status', 'active')),
                vertragswert=p['contract_value'],
                prozent_abgeschlossen=p.get('percent_complete', 0),
                geplanter_start=p['planned_start'],
                geplantes_ende=p['planned_end'],
                tatsaechlicher_start=p.get('actual_start'),
                prognose_ende=p.get('forecast_end', p['planned_end']),
                budget=p['budget'],
                tatsaechliche_kosten=p.get('actual_cost', 0),
                prognosekosten=p.get('forecast_cost', p['budget']),
                cpi=p.get('cpi', 1.0),
                spi=p.get('spi', 1.0),
                meldepflichtige_vorfaelle=p.get('incidents', 0),
                gesamtstunden=p.get('total_hours', 0),
                risikoscore=p.get('risk_score', 0),
                kritische_risiken=p.get('critical_risks', 0)
            )

            # Abgeleitete Kennzahlen berechnen
            kennzahlen.kostenabweichung = kennzahlen.budget - kennzahlen.tatsaechliche_kosten
            kennzahlen.terminabweichung_tage = (kennzahlen.geplantes_ende - kennzahlen.prognose_ende).days

            if kennzahlen.gesamtstunden > 0:
                kennzahlen.trir = (kennzahlen.meldepflichtige_vorfaelle * 200000) / kennzahlen.gesamtstunden

            self.projekt_hinzufuegen(kennzahlen)
            anzahl += 1

        return anzahl

    def aktive_projekte_abrufen(self) -> List[Projektkennzahlen]:
        """Liste aktiver Projekte abrufen."""
        return [p for p in self.projekte.values()
                if p.status == ProjektStatus.AKTIV]

    def portfoliozusammenfassung_berechnen(self) -> Portfoliozusammenfassung:
        """Portfolioübergreifende Zusammenfassungskennzahlen berechnen."""
        aktiv = self.aktive_projekte_abrufen()
        alle_projekte = list(self.projekte.values())

        if not alle_projekte:
            return None

        # Summen
        gesamter_vertragswert = sum(p.vertragswert for p in alle_projekte)
        gesamtbudget = sum(p.budget for p in alle_projekte)
        gesamte_tatsaechliche_kosten = sum(p.tatsaechliche_kosten for p in alle_projekte)
        gesamte_prognosekosten = sum(p.prognosekosten for p in alle_projekte)

        # Durchschnittliche Leistung (gewichtet nach Budget)
        if gesamtbudget > 0:
            durchschnittlicher_cpi = sum(p.cpi * p.budget for p in aktiv) / sum(p.budget for p in aktiv) if aktiv else 1.0
            durchschnittlicher_spi = sum(p.spi * p.budget for p in aktiv) / sum(p.budget for p in aktiv) if aktiv else 1.0
        else:
            durchschnittlicher_cpi = durchschnittlicher_spi = 1.0

        # Budget-/Termintreue in Prozent
        budgettreu = len([p for p in aktiv if p.cpi >= 0.95])
        termintreu = len([p for p in aktiv if p.spi >= 0.95])

        budgettreue_prozent = (budgettreu / len(aktiv) * 100) if aktiv else 100
        termintreue_prozent = (termintreu / len(aktiv) * 100) if aktiv else 100

        # Sicherheitskennzahlen
        gesamte_vorfaelle = sum(p.meldepflichtige_vorfaelle for p in alle_projekte)
        gesamtstunden = sum(p.gesamtstunden for p in alle_projekte)
        portfolio_trir = (gesamte_vorfaelle * 200000 / gesamtstunden) if gesamtstunden > 0 else 0

        # Gesundheitsverteilung
        gruen = len([p for p in aktiv if p.gesundheit == Gesundheitsstatus.GRUEN])
        gelb = len([p for p in aktiv if p.gesundheit == Gesundheitsstatus.GELB])
        rot = len([p for p in aktiv if p.gesundheit == Gesundheitsstatus.ROT])

        # Trends (mit vorheriger Momentaufnahme vergleichen falls vorhanden)
        kostentrend = "stabil"
        termintrend = "stabil"

        if self.momentaufnahmen:
            vorherige = self.momentaufnahmen[-1]
            if durchschnittlicher_cpi > vorherige.get('avg_cpi', 1.0):
                kostentrend = "verbessernd"
            elif durchschnittlicher_cpi < vorherige.get('avg_cpi', 1.0):
                kostentrend = "verschlechternd"

            if durchschnittlicher_spi > vorherige.get('avg_spi', 1.0):
                termintrend = "verbessernd"
            elif durchschnittlicher_spi < vorherige.get('avg_spi', 1.0):
                termintrend = "verschlechternd"

        return Portfoliozusammenfassung(
            berichtsdatum=datetime.now(),
            gesamte_projekte=len(alle_projekte),
            aktive_projekte=len(aktiv),
            gesamter_vertragswert=gesamter_vertragswert,
            gesamtbudget=gesamtbudget,
            gesamte_tatsaechliche_kosten=gesamte_tatsaechliche_kosten,
            gesamte_prognosekosten=gesamte_prognosekosten,
            durchschnittlicher_cpi=durchschnittlicher_cpi,
            durchschnittlicher_spi=durchschnittlicher_spi,
            budgettreue_prozent=budgettreue_prozent,
            termintreue_prozent=termintreue_prozent,
            portfolio_trir=portfolio_trir,
            gesamte_vorfaelle=gesamte_vorfaelle,
            gruene_anzahl=gruen,
            gelbe_anzahl=gelb,
            rote_anzahl=rot,
            kostentrend=kostentrend,
            termintrend=termintrend
        )

    def projekte_vergleichen(self, kennzahl: str) -> Projektvergleich:
        """Projekte nach einer bestimmten Kennzahl vergleichen."""
        aktiv = self.aktive_projekte_abrufen()

        if nicht aktiv:
            return None

        kennzahl_map = {
            "cpi": lambda p: p.cpi,
            "spi": lambda p: p.spi,
            "prozent_abgeschlossen": lambda p: p.prozent_abgeschlossen,
            "kostenabweichung": lambda p: p.kostenabweichung,
            "trir": lambda p: p.trir,
            "risikoscore": lambda p: p.risikoscore
        }

        if kennzahl not in kennzahl_map:
            raise ValueError(f"Unbekannte Kennzahl: {kennzahl}")

        getter = kennzahl_map[kennzahl]
        werte = {p.projekt_name: getter(p) for p in aktiv}

        durchschnitt = statistics.mean(werte.values())

        # Bestes/Schlechtestes hängt von der Kennzahl ab (höherer CPI gut, niedrigerer TRIR gut)
        if kennzahl in ["trir", "risikoscore"]:
            bestes = min(werte.items(), key=lambda x: x[1])
            schlechtestes = max(werte.items(), key=lambda x: x[1])
        else:
            bestes = max(werte.items(), key=lambda x: x[1])
            schlechtestes = min(werte.items(), key=lambda x: x[1])

        return Projektvergleich(
            kennzahl=kennzahl,
            projekte=werte,
            durchschnitt=durchschnitt,
            bestes=bestes,
            schlechtestes=schlechtestes
        )

    def gefaehrdete_projekte_abrufen(self) -> List[Projektkennzahlen]:
        """Projekte abrufen, die Aufmerksamkeit benötigen."""
        return [p for p in self.aktive_projekte_abrufen()
                if p.gesundheit in [Gesundheitsstatus.GELB, Gesundheitsstatus.ROT]]

    def top_risiken_abrufen(self, limit: int = 10) -> List[Dict]:
        """Top-Risiken im gesamten Portfolio abrufen."""
        risiken = []

        for p in self.aktive_projekte_abrufen():
            if p.risikoscore > 0:
                risiken.append({
                    "projekt": p.projekt_name,
                    "risikoscore": p.risikoscore,
                    "kritische_risiken": p.kritische_risiken,
                    "cpi": p.cpi,
                    "spi": p.spi
                })

        return sorted(risiken, key=lambda x: -x['risikoscore'])[:limit]

    def liquiditaetsbedarf_prognostizieren(self, monate: int = 6) -> List[Dict]:
        """Liquiditätsbedarf im gesamten Portfolio prognostizieren."""
        prognosen = []

        for monat in range(1, monate + 1):
            monats_datum = datetime.now() + timedelta(days=monat * 30)

            monatsausgaben = 0
            for p in self.aktive_projekte_abrufen():
                # Einfache lineare Projektion basierend auf verbleibender Arbeit
                verbleibend = p.prognosekosten - p.tatsaechliche_kosten
                verbleibende_monate = max(1, (p.prognose_ende - datetime.now()).days / 30)
                monatliche_rate = verbleibend / verbleibende_monate
                monatsausgaben += monatliche_rate

            prognosen.append({
                "monat": monats_datum.strftime("%Y-%m"),
                "prognostizierte_ausgaben": monatsausgaben
            })

        return prognosen

    def momentaufnahme_speichern(self):
        """Aktuellen Zustand für Trendanalyse speichern."""
        zusammenfassung = self.portfoliozusammenfassung_berechnen()
        if zusammenfassung:
            self.momentaufnahmen.append({
                "datum": datetime.now(),
                "durchschnittlicher_cpi": zusammenfassung.durchschnittlicher_cpi,
                "durchschnittlicher_spi": zusammenfassung.durchschnittlicher_spi,
                "budgettreue_prozent": zusammenfassung.budgettreue_prozent,
                "termintreue_prozent": zusammenfassung.termintreue_prozent,
                "gesamte_prognosekosten": zusammenfassung.gesamte_prognosekosten
            })

    def bericht_generieren(self) -> str:
        """Portfolio-Dashboard-Bericht generieren."""
        zusammenfassung = self.portfoliozusammenfassung_berechnen()

        if nicht zusammenfassung:
            return "Keine Projekte im Portfolio"

        zeilen = [
            "# Portfolio-Dashboard",
            "",
            f"**Portfolio:** {self.portfolio_name}",
            f"**Berichtsdatum:** {zusammenfassung.berichtsdatum.strftime('%Y-%m-%d')}",
            "",
            "## Zusammenfassung für die Geschäftsleitung",
            "",
            f"| Kennzahl | Wert |",
            f"|--------|-------|",
            f"| Gesamte Projekte | {zusammenfassung.gesamte_projekte} ({zusammenfassung.aktive_projekte} aktiv) |",
            f"| Gesamter Vertragswert | ${zusammenfassung.gesamter_vertragswert:,.0f} |",
            f"| Gesamtbudget | ${zusammenfassung.gesamtbudget:,.0f} |",
            f"| Tatsächliche Kosten bisher | ${zusammenfassung.gesamte_tatsaechliche_kosten:,.0f} |",
            f"| Prognose bei Abschluss | ${zusammenfassung.gesamte_prognosekosten:,.0f} |",
            "",
            "## Leistungskennzahlen",
            "",
            f"| Kennzahl | Wert | Trend |",
            f"|--------|-------|-------|",
            f"| Durchschnittlicher CPI | {zusammenfassung.durchschnittlicher_cpi:.2f} | {zusammenfassung.kostentrend} |",
            f"| Durchschnittlicher SPI | {zusammenfassung.durchschnittlicher_spi:.2f} | {zusammenfassung.termintrend} |",
            f"| Budgettreue (%) | {zusammenfassung.budgettreue_prozent:.1f}% | |",
            f"| Termintreue (%) | {zusammenfassung.termintreue_prozent:.1f}% | |",
            "",
            "## Gesundheit der Projekte",
            "",
            f"- 🟢 Gesund: {zusammenfassung.gruene_anzahl}",
            f"- 🟡 Gefährdet: {zusammenfassung.gelbe_anzahl}",
            f"- 🔴 Kritisch: {zusammenfassung.rote_anzahl}",
            "",
            "## Sicherheitskennzahlen",
            "",
            f"| Kennzahl | Wert |",
            f"|--------|-------|",
            f"| TRIR (Gesamte meldepflichtige Vorfallrate) | {zusammenfassung.portfolio_trir:.2f} |",
            f"| Gesamte meldepflichtige Vorfälle | {zusammenfassung.gesamte_vorfaelle} |",
            "",
            "## Nächste Schritte",
            "",
            "1. Gefährdete und kritische Projekte überprüfen",
            "2. Ressourcenzuweisung bei Bedarf anpassen",
            "3. Ursachen der Kosten- und Terminabweichungen untersuchen",
            "4. Sicherheitsprogramme für Projektstandorte mit hohem TRIR aktualisieren",
            ""
        ]

        return "\n".join(zeilen)

    # Alias-Methoden für Abwärtskompatibilität (optional)
    hinzufuegen_projekt = projekt_hinzufuegen
    importiere_projekte = projekte_importieren
    abrufen_aktive_projekte = aktive_projekte_abrufen
    berechnen_zusammenfassung = portfoliozusammenfassung_berechnen
    vergleiche_projekte = projekte_vergleichen
    abrufen_gefaehrdete_projekte = gefaehrdete_projekte_abrufen
    abrufen_top_risiken = top_risiken_abrufen
    prognostiziere_liquiditaet = liquiditaetsbedarf_prognostizieren
    speichere_momentaufnahme = momentaufnahme_speichern
    generiere_bericht = bericht_generieren

Verwendung

# Dashboard initialisieren
dashboard = PortfolioDashboard("Hochbauabteilung")

# Projekte aus einer Datenquelle importieren
dashboard.importiere_projekte(projekt_daten)

# Portfoliozusammenfassung abrufen
zusammenfassung = dashboard.portfoliozusammenfassung_berechnen()

# Bericht generieren
bericht = dashboard.bericht_generieren()
print(bericht)

# Projekte vergleichen
vergleich = dashboard.projekte_vergleichen("cpi")
print(f"Bester: {vergleich.bestes[0]} ({vergleich.bestes[1]:.2f})")
print(f"Schlechtester: {vergleich.schlechtestes[0]} ({vergleich.schlechtestes[1]:.2f})")

# Gefährdete Projekte identifizieren
ergebnisse = dashboard.gefaehrdete_projekte_abrufen()
for projekt in ergebnisse:
    print(f"{projekt.projekt_name}: {projekt.gesundheit.value}")

# Cashflow prognostizieren
cashflow = dashboard.liquiditaetsbedarf_prognostizieren(monate=12)

# Trendverfolgung durch regelmäßige Momentaufnahmen
dashboard.momentaufnahme_speichern()

Anpassungsmöglichkeiten

  • Datenquellen: Ersetzen Sie projekt_hinzufuegen durch Datenbankabfragen, API-Aufrufe oder CSV-Importe.
  • Kennzahlen: Fügen Sie benutzerdefinierte Kennzahlen über die kennzahl_map in projekte_vergleichen hinzu.
  • Schwellenwerte: Passen Sie SCHWELLENWERTE für Ihren spezifischen Risikoappetit an.
  • Visualisierung: Integrieren Sie die Ausgabe in Ihre bevorzugte Dashboard-Plattform (Grafana, Tableau, benutzerdefiniertes Web-Frontend).
  • Integration: Nutzen Sie die Dataclasses als Grundlage für die Generierung von REST-API-Antworten zum Abruf von Portfolio-Daten über HTTP.

Individual skills in this repo

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

majiayu000/claude-skill-registry-data

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry-data

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry-data

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry-data

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry-data

Analyzes current state and user query to answer BMad questions or recommend the next workflow or agent. Use when user says what should I do next, what do I do now, or asks a question about BMad

majiayu000/claude-skill-registry-data

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry-data

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry-data

Portfolio allocation and rebalancing optimizer. Manages asset allocation across stocks/cash/bonds, performs periodic rebalancing, and ensures diversification according to market regime and risk tolerance.

majiayu000/claude-skill-registry-data

Create a hilarious and ultra-realistic video of an anthropomorphic animal acting like a human vlogger in a real-world setting.

majiayu000/claude-skill-registry-data

Speech-to-text transcription and translation via OpenAI Audio API -- models, response formats, timestamps, prompting, streaming, chunking, and diarization

majiayu000/claude-skill-registry-data

This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.

majiayu000/claude-skill-registry-data

小省导购员数字人带货版即梦视频提示词生成系统,基于四大智能体协同(提示词生成师、质量管控师、知识库运维师、跨环节适配师),按照"主体+运动+场景+(镜头语言+光影+氛围)"公式输出中英文双版提示词,适配5s短视频。确保人物一致性、视觉连贯性、情绪连贯性,支持知识库智能复用和跨工具适配(Suno音乐、AI绘画),为数字人带货视频提供高质量提示词生成服务。

majiayu000/claude-skill-registry-data

Upload and manage files using Google Gemini File API via scripts/. Use for uploading images, audio, video, PDFs, and other files for use with Gemini models. Supports file upload, status checking, and file management. Triggers on "upload file", "file API", "upload image", "upload PDF", "upload video", "file management".

majiayu000/claude-skill-registry-data

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry-data

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry-data

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

majiayu000/claude-skill-registry-data

Conduct domain and industry research. Use when the user says "lets create a research report on [domain or industry]

majiayu000/claude-skill-registry-data

Conduct market research on competition and customers. Use when the user says "create a market research report about [business idea]".

majiayu000/claude-skill-registry-data

Conduct technical research on technologies and architecture. Use when the user says "create a technical research report on [topic]".

majiayu000/claude-skill-registry-data

Builds, edit or validate Agent Skill through conversational discovery. Use when the user requests to "Create an Agent", "Optimize an Agent" or "Edit an Agent".

Verwandte Skills