CommunityRecherche & Datenanalysegithub.com

AI-Mindshare-Map

Claude Code Skill, das misst, wie sichtbar ein Unternehmen oder Markt für KI-Assistenten (ChatGPT) ist und kartiert, wer empfohlen wird und warum.

Was ist AI-Mindshare-Map?

Das **AI Mindshare Map** Skill für Claude Code ist ein Competitive-Intelligence-Tool, das die Sichtbarkeit eines Unternehmens oder Marktes in KI-basierten Systemen wie ChatGPT analysiert. Es erstellt eine detaillierte Landkarte der Wettbewerbslandschaft, basierend auf automatisierten Abfragen, Quellenbewertungen und Entity-Extraktion. Das Skill unterstützt zwei Modi: den Entity-Modus (zielt auf ein bestimmtes Unternehmen) und den Market-Modus (Landschaftsanalyse ohne festen Fokus). Nach der Definition von idealen Kundenprofilen (ICPs) und Suchintentionen führt das Skill eine mehrstufige Pipeline aus: Abfrage von GPT, Abruf zitierter URLs, Entity-Extraktion, Quellenbewertung und finale Destillation in eine umfassende JSON-Datei (distillation.json) sowie eine durchsuchbare SQLite-Datenbank (tuff.db). Es ist besonders nützlich für Produktmanager, Marktforscher und Strategen, die verstehen wollen, warum und wie ihr Unternehmen in KI-Ökosystemen wahrgenommen wird. Das Skill benötigt eine OpenAI-API-Key und optional Playwright MCP für eine verbesserte Audience Discovery.

Funktioniert mit✓Claude Code✓Codex CLI~Cursor
npx skills add unfamiliar-city/skill-ai-mindshare-map

Installed? Explore more Recherche & Datenanalyse skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht AI-Mindshare-Map?

Competitive-Intelligence-Tool: Entdecke dein Publikum, befrage KI-Systeme, analysiere Antworten, erstelle Wettbewerbs-Rankings und identifiziere Quellenlücken.

Befehlsyntax

/mindshare-map --entity <url> [--frame "..."] [--name <slug>] [--skip-validation] [--intents-per-track=N] [--intents=N]
  Entity-Modus: Verfolgt ein bestimmtes Unternehmen/eine bestimmte Marke.

/mindshare-map --market "<description>" [--frame "..."] [--name <slug>] [--skip-validation] [--intents-per-track=N] [--intents=N]
  Market-Modus: Landschaftsanalyse ohne Fokus-Entity.

Optionen:

  • --frame "..." Intent/Persona-Dialog – wer sucht und warum (Standard: Käufer, die Optionen recherchieren)
  • --name <slug> Name des Arbeitsverzeichnisses (Standard: abgeleitet von der URL-Domain oder Marktbeschreibung)
  • --skip-validation Überspringe ICP-Bestätigung (verwende abgeleitete ICPs; Käufer → Standard-Tracks, andere → trackless)
  • --intents-per-track=N Intents pro Track im Tracked-Modus (Standard: 6)
  • --intents=N Intents pro ICP im Trackless-Modus (Standard: 12)

Beispiele:

  • /mindshare-map --entity https://example.com → work/example-com-20260213/
  • /mindshare-map --market "creative agencies" → work/creative-agencies-20260213/
  • /mindshare-map --entity https://foo.com --name=foo-q1-2026 → work/foo-q1-2026/
  • /mindshare-map --entity https://foo.com --frame "investors assessing category leaders"

Abhängigkeiten

  • Playwright MCP: Zielgruppenentdeckung
  • WebFetch: Zielgruppenentdeckung
  • Bash: Pipeline-Ausführung
  • OpenAI API: GPT-5.2 für Abfragen, GPT-5-mini für vollständige Quellenbewertung, GPT-5-nano für Extraktion/Analyse/leichte Bewertung
  • tuff-lil-unit: Pipeline-Ausführung – Crash-Recovery, Schritt-Memoisation, Nebenläufigkeit

Arbeitsverzeichnis

Jeder Durchlauf erhält ein datiertes Verzeichnis unter work/:

work/creative-agencies-20260213/
  audience-profile.json       # ICPs + Intents + target_focus (Projektidentität)
  subject-context.json        # Forschungswissen
  tuff.db                     # SQLite: tuff-Schritte + Domain-Tabellen (abfragbar)
  distillation.json           # Vollständige Wettbewerbslandschaft-Ausgabe

Ausgaben

  1. distillation.json – eine einzelne Datei mit der vollständigen Wettbewerbslandschaft:
    • meta – Schema-Version, Lauf-ID, Modus, Zeitstempel, Abfrageanzahl, Antwortrate, primäre Entity-Typen
    • landscape – query_answer-Entities gruppiert nach Typ (Unternehmen, Produkt, …), nach Reichweite sortiert
    • other_entities – authority_source/platform-Entities gruppiert nach Typ
    • by_icp – Aufschlüsselung pro ICP: { icp_001: { landscape: {…}, other_entities: {…} } }
    • sources.market – nach Publisher-Typ, pro-Domain-Bewertungen (jeweils mit source_type, is_competitor, authority, citation_count, citation_count_by_icp)
    • client – Position, Kategorie-Position, Salienz, Sichtbarkeit, Reputation (nur Entity-Modus)
  2. tuff.db – abfragbar via sqlite3: Schrittstatus, Token-Nutzung, Domain-Tabellen

DB: Details hinter den Destillations-Zusammenfassungen

tuff.db behält alle Details, die die Destillation zusammenfasst. Abfrage mit sqlite3 tuff.db:

GewünschtTabelle → Spalte
Quellen-Autoritäts-Begründung + Signaleassessments.result → authority
Quellenformat + Wettbewerbsbeziehungassessments → source_type, is_competitor
Alle zitierten URLs pro Domainassessments.result → urls
Detail pro Antwort-Erwähnung (Salienz, ICP, Abfrage)analysed.mentions
Vollständiger GPT-Antworttextqueries.response
Abgerufener Quellseiteninhaltsources.content
Roh-Extraktionen von Entities pro Quelleextractions.entities

Einrichtung (erster Durchlauf)

Ein SessionStart-Hook installiert tuff-lil-unit automatisch in ${CLAUDE_PLUGIN_DATA} und führt die Installation erneut aus, wenn sich package.json ändert. Stelle sicher, dass OPENAI_API_KEY über die Shell gesetzt ist (empfohlen: Keychain-gestützt, exportiert aus ~/.zshenv – siehe README). Playwright MCP ist optional (die Entity-Modus-Website-Recherche fällt ohne ihn auf WebFetch zurück).

Wenn eine Pipeline-Phase mit Could not locate the bindings file fehlschlägt (ein better-sqlite3-Native-Binding-Fehler), wurde der native Build-Schritt übersprungen. Behebung: cd ${CLAUDE_PLUGIN_DATA} && npm rebuild better-sqlite3, dann versuche die Phase erneut.


Phase 0: Arbeitsverzeichnis einrichten

Vor allem anderen: Arbeitsverzeichnis bestimmen.

  1. Slug ableiten aus der Eingabe:
    • --entity: Domain extrahieren, sluggifizieren → example-com
    • --market: Beschreibung sluggifizieren → creative-agencies
    • --name=-Flag überschreibt (kein Datumssuffix)
  2. Datumszusatz anhängen: ${slug}-${YYYYMMDD} (z.B. creative-agencies-20260213)
    • Überspringen, wenn --name= angegeben wurde (Benutzer kontrolliert den vollständigen Namen)
  3. WORK_DIR setzen = work/${slug}-${YYYYMMDD}/
  4. Existenz prüfen: wenn WORK_DIR bereits Daten enthält, Benutzer fragen:

    work/creative-agencies-20260213/ existiert bereits. Überschreiben oder anderen Namen verwenden?

  5. Verzeichnis erstellen: mkdir -p ${WORK_DIR}

Alle nachfolgenden Phasen verwenden --work-dir=${WORK_DIR}.


Phase 1: Zielgruppenentdeckung

Subagent-getriebene Recherche + Benutzer-Validierung. Erzeugt audience-profile.json.

Schritt 1.0: Rahmen

Erfasse das --frame-Flag (Standard: Buyer-Frame).

Schritt 1.1: ICPs generieren

Task({
  subagent_type: 'general-purpose',
  prompt: `Führe aus: references/${'entity' in subject
    ? 'entity-mode-instructions' : 'market-mode-instructions'}.md\n\n${
    'entity' in subject ? `Entity-URL: ${subject.entity}` : `Markt: "${subject.market}"`}\n\nWORK_DIR: ${WORK_DIR} — schreibe subject-context.json in dieses Verzeichnis, nicht in einen hartcodierten work/-Pfad.`
})

Schritt 1.2: ICPs validieren

Präsentiere vorgeschlagene ICPs dem Benutzer. Sammle Feedback, verfeinere bei Bedarf. Überspringen, wenn --skip-validation.

Wenn die Entdeckung research_limited zurückgab (Entity-Modus, eine JS-gerenderte Seite, die WebFetch nicht lesen konnte), informiere den Benutzer – auch bei --skip-validation:

{entity} sieht JS-gerendert aus, daher stützen sich diese ICPs eher auf allgemeine Web-Recherche als auf die Website selbst. Die Installation von Playwright MCP würde es mir ermöglichen, die vollständige Seite zu lesen – füge es hinzu und starte die Entdeckung neu, oder fahre mit diesen fort?

Schritt 1.2a: Track-Auswahl

Nach Bestätigung der ICPs: Markt-Mapping-Tracks festlegen:

RahmenMit --skip-validationInteraktiv
BuyerStandard-Tracks (4)Standard oder trackless anbieten
CustomTracklessEigene Tracks oder trackless vorschlagen

Standard-Tracks: landscape, recommendation, specialization, scenario. Alle Tracks müssen Entity-aufdeckend sein. Siehe references/intent-query-generation-instructions.md für Formulierungshilfe.

Schritt 1.3: Intents + Abfragen generieren

Ein Subagent pro ICP, parallel. Erstelle ein Rollenspiel-Briefing für jeden ICP mit drei neutralen Slots, die durch den Rahmen interpretiert werden:

SlotBuyerInvestorJournalist
motivationsZieleInvestment-TheseRessort und Blickwinkel
constraintsSchmerzpunkteSorgfaltsanliegenRedaktionelle Einschränkungen
contextAktuelle SituationPortfoliokontextAktuelle Aufgaben

Zeichne das erstellte Briefing im brief-Block des ICPs in audience-profile.json auf, bevor du es an den Subagenten sendest.

Verwende die getrackte oder trackless-Vorlage aus references/intent-query-generation-instructions.md. Getrackt: --intents-per-track=N (Standard 6), Intent-JSON enthält track. Trackless: --intents=N (Standard 12), track weggelassen.

const icpResults = await Promise.all(confirmedICPs.map(icp =>
  Task({
    subagent_type: 'general-purpose',
    model: 'sonnet',
    prompt: buildRoleplayBrief(icp, confirmedTracks, trackless)
  })
))

Schritt 1.3b: Abfrage-Review

Ein einzelner Review-Subagent (Sonnet) scannt alle generierten Abfragen auf methodische Probleme. Gibt markierte Abfragen mit Gründen zurück; der Orchestrator repariert oder verwirft sie, bevor sie dem Benutzer präsentiert werden.

Task({
  subagent_type: 'general-purpose',
  model: 'sonnet',
  prompt: `Überprüfe diese generierten Abfragen auf forschungsmethodische Probleme...\n${allQueries}`
  // Siehe references/query-review-instructions.md für Kriterien und Ausgabeformat
})

Schritt 1.4: Intents validieren + Profil schreiben

Präsentiere Intents dem Benutzer, sammle Feedback. Schreibe ${WORK_DIR}/audience-profile.json. Überspringe Validierung, wenn --skip-validation.


Phase 2: Pipeline (task-basiert, Hintergrundjobs)

Schritt 2.1: Aufgaben erstellen + Abhängigkeiten setzen

const query = TaskCreate({
  subject: "GPT für alle ICPs abfragen",
  description: "Bash({ run_in_background: true, command: 'NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:query -- --work-dir=${WORK_DIR}' })",
  activeForm: "Frage GPT ab"
})

const fetch = TaskCreate({
  subject: "Zitierte URLs abrufen",
  description: "Bash({ run_in_background: true, command: 'NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:fetch -- --work-dir=${WORK_DIR}' })",
  activeForm: "Rufe URLs ab"
})

const extract = TaskCreate({
  subject: "Entities aus Quellen extrahieren",
  description: "Bash({ run_in_background: true, command: 'NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:extract -- --work-dir=${WORK_DIR}' })",
  activeForm: "Extrahiere Entities"
})

const assess = TaskCreate({
  subject: "Quellen-Autorität bewerten",
  description: "Bash({ run_in_background: true, command: 'NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:assess -- --work-dir=${WORK_DIR}' })",
  activeForm: "Bewerte Quellen"
})

const analyse = TaskCreate({
  subject: "GPT-Antworten analysieren",
  description: "Bash({ run_in_background: true, command: 'NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:analyse -- --work-dir=${WORK_DIR}' })",
  activeForm: "Analysiere Antworten"
})

const distill = TaskCreate({
  subject: "Wettbewerbslandschaft destillieren",
  description: "Bash({ run_in_background: true, command: 'NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:distill -- --work-dir=${WORK_DIR}' }). Ausgaben: distillation.json",
  activeForm: "Destilliere Landschaft"
})

// Abhängigkeitsgraph:
//   Abfrage → Abruf → Extraktion → Bewertung ─┐
//     └──→ Analyse ────────────────────────────┴→ Destillation
TaskUpdate({ taskId: fetch.id, addBlockedBy: [query.id] })
TaskUpdate({ taskId: extract.id, addBlockedBy: [fetch.id] })
TaskUpdate({ taskId: assess.id, addBlockedBy: [extract.id] })
TaskUpdate({ taskId: analyse.id, addBlockedBy: [query.id] })
TaskUpdate({ taskId: distill.id, addBlockedBy: [assess.id, analyse.id] })

Schritt 2.2: Aufgaben-Graph ausführen

Beginne mit query. Nach jedem Abschluss: Aufgabe als erledigt markieren, freigegebene Abhängige starten.

Fortschritt überwachen – jede Phase schreibt pro Element in die DB. Fortschritt jederzeit abrufbar:

NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:progress -- --work-dir=${WORK_DIR} query    # einzelne Phase: "query: 24/24"
NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline:progress -- --work-dir=${WORK_DIR}          # alle Phasen

Bei Absturz oder Unterbrechung: Führe die fehlgeschlagene Phase erneut aus – die Schritt-Memoisation von tuff überspringt bereits erledigte Elemente.

Vollständige Pipeline (nicht-interaktiv): NODE_PATH=${CLAUDE_PLUGIN_DATA}/node_modules npm run --prefix ${CLAUDE_PLUGIN_ROOT} pipeline -- --work-dir=${WORK_DIR} führt alle 6 Phasen sequenziell aus.


Phase 3: Auslieferung

Sobald die Pipeline abgeschlossen ist, präsentiere die Ausgaben dem Benutzer:

**AI-Mindshare-Map abgeschlossen** → `${WORK_DIR}/`

**Ausgaben:**
- `${WORK_DIR}/distillation.json` — Wettbewerbslandschaftsdaten
- `${WORK_DIR}/audience-profile.json` — ICPs + Intents

**Wichtige Erkenntnisse:**
- Entdeckte Entities: {{entities_discovered}}
- Quellengestützt: {{source_backed_count}}
- Ziel-Rang: #{{rank}} von {{rank_of}} *(nur Entity-Modus)*

Verwandte Skills