Von Claude zitiert werden: die Brave-Abhängigkeit

Am Ende dieser Lektion hast du eine eigene Zahl: den Anteil deiner Anfragen, bei denen eine von Claude zitierte URL auch in einer Trefferliste stand – mit dem Vertrauensintervall, das dein Umfang trägt, und mit dem Umfang, den ein Vergleich braucht.

Dreizehn Treffer. So viele Anfragen von fünfzehn stehen hinter dem Anteil, der in dieser Sache überall zitiert wird: Profound berichtete am 21. März 2025 von 86,7 % Deckung bei p<0,0001, erhoben über 15 Anfragen. Wie viele Anfragen nötig wären, um 86,7 % von 60 % zu unterscheiden, rechnet das Skript dieser Lektion aus: 22. Diesen Vergleich hat Profound nicht angestellt und musste es nicht – wer die Zahl als Planungsgröße weitergibt, stellt ihn.

Gegenstand ist ein einzelner Assistent und die Arithmetik über die veröffentlichten Stichproben. Die Zitatfrage über alle Antwortflächen hinweg bearbeitet GEO und AIO, das vierte Level dieses Kurses, und davon wiederholt diese Seite nichts.

Was du lernst

• Den Umfang ausrechnen, den ein Vergleich braucht, bevor du eine Überschneidungszahl zur Planungsgröße machst.
• Aus 86,7 % und 15 Anfragen die 13 Treffer und das Intervall herausholen – und begründen, warum ein p-Wert etwas anderes beantwortet.
• Profounds Nenner – Anfragen – von MERJs Nenner – zitierte URLs – trennen und keine Mischrechnung zulassen.
• Sagen, was ein Eintrag in einer Subunternehmerliste belegt und was er nicht hergibt.
• An einem Rückgabewert erkennen, ob ein Bedienfehler vorliegt oder ein Befund über deine Website.

Dreizehn Treffer, und was der p-Wert davon nicht sagt

Profounds Erhebung vom 21. März 2025 stellt die von Claude zitierten Seiten den obersten unbezahlten Ergebnissen von Brave Search gegenüber und kommt auf 86,7 % Deckung bei p<0,0001, erhoben über 15 Anfragen. Anteil und Umfang sind beides Angaben der Erhebung. Was dort nicht steht, ist das Produkt aus beiden, und darin liegt der ganze Punkt: 86,7 % von 15 sind 13 Treffer. Eine einzige abweichende Anfrage verschiebt die Schlagzeile damit um 6,7 Prozentpunkte.

Ein kleiner p-Wert schließt den Zufall als Erklärung aus und sagt über die Höhe des Anteils nichts. Dafür steht das Vertrauensintervall, und das Skript weiter unten gibt es für 13 von 15 aus: 62,1 bis 96,3 %, also 34,1 Prozentpunkte breit. Die Breite kommt aus den ungerundeten Enden; aus den beiden gedruckten Zahlen gerechnet wären es 34,2. Gerechnet ist es nach Wilson, einer Normalapproximation an eine Binomialverteilung – damit selbst eine Näherung und keine scharfe Grenze. Zwischen diesen Enden liegen zwei Welten: an einem folgen Zitate den Platzierungen fast immer, am anderen in nicht einmal zwei von drei Fällen. Wer eine Entscheidung trifft, die an diesem Unterschied hängt, hat die Erhebung nicht auf seiner Seite, obwohl er ihre Zahl zitiert.

MERJ zählt URLs, Profound zählt Anfragen

MERJ zählt keine Anfragen, sondern zitierte URLs, und damit ist jeder Mittelwert aus den beiden bekanntesten Zahlen zu Claude hinfällig. Für 2026, ohne Monat, berichtet MERJ: von den URLs, die Claude zitiert hatte, lagen 79,2 % in den Top 10 von Brave und 34 % in denen von Google. Einen Umfang gibt MERJ dazu nicht an. Nachprüfbar bleibt daran die Richtung: innerhalb derselben Zählweise liegt Brave vor Google. Eine Fehlerspanne um 79,2 % lässt sich nicht angeben, solange der Nenner fehlt.

Zwei weitere Zahlen tauchen hier auf und scheitern an verschiedenen Stellen. Die eine gehört zu einer Sammlung von Claude-zitierten URLs, die in der Branche herumgeht: auf dieser Seite steht zu ihr keine Ziffer, denn Datensatz und Erhebungszeitraum waren nicht aufzufinden, und ohne beides ist an ihr nichts nachzurechnen. Die andere stammt von Profound selbst – 20 % Überschneidung mit ChatGPT, im Text vom 21. März 2025. Ob diese 20 % Claudes Zitate gegen ChatGPTs Zitate stellen oder ChatGPT gegen einen eigenen Index, entscheidet der Text nicht, und ohne diese Angabe bleibt eine Zahl ohne Verfahren. Daraus die Regel für diese Seite: genannt werden die 20 %, weil die Erhebung sie nennt, in eine Reihe mit den 86,7 % kommen sie nicht, weil eine Reihe das Verfahren voraussetzt.

Gruppiert ist die Tabelle nach ihrer ersten Spalte, und die vierte zieht die Folgerung: von vier Zeilen trägt eine eine Fehlerspanne, in den drei anderen steht, welche Angabe dafür fehlt.

Der Umfang, den keine der beiden Erhebungen nennt

Bevor eine Überschneidungszahl zur Planungsgröße wird, gehört eine Rechnung davor, die weder Profound noch MERJ anstellt: wie viele Anfragen es braucht, um 86,7 % von einem anderen Wert zu unterscheiden. Das Verfahren ist der gewöhnliche Anteilstest in Normalapproximation, zweiseitig, mit einer Irrtumswahrscheinlichkeit von 0,05 und einer Trennschärfe von 80 %, also mit z = 1,96 und z = 0,8416. Es ist eine Näherung, und bei kleinen Umfängen eine grobe.

Die letzte Zeile ist künstlich, und das gehört dazugesagt: 79,2 % ist MERJs Zahl, sie zählt URLs statt Anfragen, und hier dient sie allein als Wert, von dem man trennen möchte. Sie zeigt eine Größenordnung: zwei Anteile, die 7,5 Prozentpunkte auseinanderliegen, verlangen eine Erhebung in anderer Liga als 15 Anfragen. Und die Rechnung beantwortet nur die Streuung, nicht die Auswahl: fünfhundert Anfragen, die du ausgesucht hast, weil du dort auftauchen wolltest, bleiben fünfhundert ausgesuchte Anfragen.

Das Protokoll, das du selbst führst

Das Skript dieser Lektion rechnet über eine semikolongetrennte Datei, die du selbst führst: eine Zeile je Anfrage, dazu das Urteil ja oder nein, je nachdem, ob unter Claudes Zitaten eine URL deiner erfassten Trefferliste war. Ein Urteil pro Anfrage ist Absicht – das ist Profounds Nenner, und nur mit demselben Nenner darf deine Zahl neben seiner stehen.

Die Tiefe der Trefferliste übergibt der Schalter --tiefe; ohne ihn steht im Bericht die Vorgabe 10, so wie in beiden Läufen weiter unten. Mitgeschrieben wird dieser Wert, gerechnet wird mit ihm nicht, denn das Urteil ist beim Erfassen gefallen – eine andere Tiefe heißt neu erfassen. Geprüft wird in dieser Reihenfolge: erst die Befehlszeile, dann die Datei Zeile für Zeile, erst danach geht eine Zeile in eine Zahl ein. So ist es vorgegeben, denn andernfalls sieht ein halb kaputtes Protokoll aus wie ein Befund über deine Website.

Drei bekannte Stolperstellen sind einzeln behandelt. UnicodeDecodeError leitet sich von ValueError her, nicht von OSError, bekommt also einen Zweig für sich und den Wert 6; dekodiert wird streng, weil ein ersetztes Zeichen zwei verschiedene Anfragen gleich aussehen ließe. Wahrheitswerte zählen in Python als Ganzzahlen, weshalb die Tiefenprüfung True zuerst abweist. Ein Vorgabewert über get kommt nicht vor: die fehlende Spalte endet im Wert 9, die vorhandene leere Zelle im Wert 10 – zwei Befunde, nicht einer. Der Wert 1 ist nicht belegt: kein Zweig des Skripts vergibt ihn, und damit teilt keine Ursache ihren Wert mit einer anderen.

#!/usr/bin/env python3
"""Rechnet aus einem selbst geführten Anfrageprotokoll den Anteil der Anfragen,
bei denen eine von Claude zitierte URL auch in einer Trefferliste stand, dazu
das Wilson-Intervall und den Umfang, den ein Vergleich bräuchte.

    python3 ueberschneidung.py protokoll.csv
    python3 ueberschneidung.py protokoll.csv --tiefe 3

--tiefe nennt die Tiefe der Trefferliste, die beim Erfassen beurteilt wurde.
Vorgabe ist 10. Der Wert wird mitgeschrieben und geht in keine Rechnung ein.

Nur Standardbibliothek, kein Netzzugriff. Die Eingabe ist semikolongetrennt
und nennt in der ersten Zeile genau anfrage;zitat_in_top_k. Ein Urteil pro
Anfrage, geschrieben als ja oder nein.

Reihenfolge: Befehlszeile prüfen, Datei vollständig prüfen, erst dann rechnen.
Ohne diese Reihenfolge sieht ein halb kaputtes Protokoll aus wie ein Befund
über deine Website.

Ausgegeben werden Dezimalkomma und ausgeschriebenes Prozent, damit sich die
Zeilen ohne Umformatierung in eine deutschsprachige Tabellenkalkulation
übernehmen lassen.

Rückgabewerte, einer pro Ursache:
     0  Bericht vollständig auf stdout
     2  nicht genau ein Positionsparameter
     3  unbekannter Schalter, oder ein Schalter ohne Wert
     4  --tiefe ist keine ganze Zahl größer als null
     5  der Pfad ist keine lesbare reguläre Datei
     6  die Bytes der Datei sind nicht UTF-8
     7  die erste Zeile ist nicht die Kopfzeile anfrage;zitat_in_top_k
     8  gültige Kopfzeile, aber keine einzige Datenzeile
     9  eine Datenzeile hat nicht so viele Felder wie die Kopfzeile
    10  eine Pflichtzelle ist vorhanden und leer
    11  ein Urteil ist weder ja noch nein
    12  zwei Datenzeilen nennen dieselbe Anfrage
    13  eine Ausnahme ohne eigenen Zweig; gedruckt wird dann kein Prüfurteil

Der Wert 1 ist nicht belegt. Kein Zweig dieses Skripts vergibt ihn, und keine
Ursache teilt sich deshalb einen Wert mit einer anderen.
"""
import math
import pathlib
import sys

KOPF = ("anfrage", "zitat_in_top_k")
JA, NEIN = "ja", "nein"
KODIERUNG = "utf-8"
Z_ALPHA = 1.96        # zweiseitig, Irrtumswahrscheinlichkeit 0,05
Z_BETA = 0.8416       # Trennschärfe 80 Prozent
GEMESSEN = 86.7       # Profound, 21. März 2025, veröffentlichter Anteil
GEGENWERTE = (50.0, 60.0, 70.0, 79.2)

AUFRUF = "Aufruf: ueberschneidung.py protokoll.csv [--tiefe N, Vorgabe 10]"


class Bedienfehler(Exception):
    """Ein benannter Eingabefehler samt seinem Rückgabewert. Jede
    dokumentierte Ursache wirft diesen Typ; was hier nicht hineinpasst,
    bekommt am Schluss den Wert 13 und kein Prüfurteil."""

    def __init__(self, code, meldung):
        super().__init__(meldung)
        self.code = code


def ausstieg(code, meldung):
    raise Bedienfehler(code, meldung)


def dezimal(wert, stellen=1):
    """Dezimalkomma nach DIN 5008. Ein Prozentzeichen kommt in dieser Ausgabe
    nicht vor, das Wort steht ausgeschrieben daneben."""
    return format(wert, "." + str(stellen) + "f").replace(".", ",")


def tiefe_aus(eingabe):
    """Ganze Zahl größer als null, sonst None. Wahrheitswerte zählen in Python
    als Ganzzahlen; die erste Abfrage hält True davon ab, hier als Tiefe 1
    durchzugehen, falls ein eigenes Vorschaltskript diese Funktion aufruft."""
    if type(eingabe) is bool:
        return None
    ziffern = str(eingabe).strip()
    if not ziffern.isdigit():
        return None
    zahl = int(ziffern)
    return zahl if zahl > 0 else None


def hole_text(pfad):
    ort = pathlib.Path(pfad)
    if not ort.is_file():
        ausstieg(5, "keine lesbare reguläre Datei: " + pfad)
    try:
        bytes_der_datei = ort.read_bytes()
    except OSError as grund:
        ausstieg(5, "keine lesbare reguläre Datei: {0} ({1})".format(
            pfad, grund.strerror))
    try:
        return bytes_der_datei.decode(KODIERUNG)
    except UnicodeDecodeError as grund:
        # Diese Ausnahme leitet sich von ValueError her, nicht von OSError;
        # ein Zweig, der allein OSError fängt, liefert hier einen Traceback
        # statt des Wertes 6. Dekodiert wird streng, denn ein ersetztes
        # Zeichen ließe zwei Anfragen gleich aussehen, die es nicht sind.
        ausstieg(6, "nicht UTF-8: {0} ({1})".format(pfad, grund))


def lies_urteile(pfad):
    """Liste von (Anfrage, Urteil). Erst ist jede Zeile geprüft, dann entsteht
    die Liste. Ein Vorgabewert über get kommt nicht vor: eine fehlende Spalte
    endet im Wert 9, eine vorhandene leere Zelle im Wert 10."""
    inhalt = [z for z in hole_text(pfad).splitlines() if z.strip()]
    if not inhalt:
        ausstieg(7, "keine erste Zeile in {0}, erwartet wird die Kopfzeile "
                    "{1}".format(pfad, ";".join(KOPF)))
    kopf = tuple(name.strip().lower() for name in inhalt[0].split(";"))
    if kopf != KOPF:
        ausstieg(7, "Kopfzeile in {0} lautet {1}, erwartet wird {2} "
                    "mit Semikolon".format(pfad, inhalt[0].strip(),
                                           ";".join(KOPF)))
    if len(inhalt) == 1:
        ausstieg(8, "Kopfzeile gültig, aber keine Datenzeile in " + pfad)
    urteile, gesehen = [], {}
    for nummer, zeile in enumerate(inhalt[1:], start=2):
        felder = zeile.split(";")
        if len(felder) != len(KOPF):
            ausstieg(9, "Zeile {0} in {1} hat {2} Felder statt {3}: "
                        "{4}".format(nummer, pfad, len(felder), len(KOPF),
                                     zeile.strip()))
        anfrage, urteil = felder[0].strip(), felder[1].strip().lower()
        if not anfrage or not urteil:
            leer = KOPF[0] if not anfrage else KOPF[1]
            ausstieg(10, "Zeile {0} in {1}: {2} ist vorhanden und "
                         "leer".format(nummer, pfad, leer))
        if urteil not in (JA, NEIN):
            ausstieg(11, "Zeile {0} in {1}: Urteil {2!r} ist weder {3} noch "
                         "{4}; Wahrheitswerte und Ziffern übersetzt du von "
                         "Hand".format(nummer, pfad, felder[1].strip(),
                                       JA, NEIN))
        if anfrage.lower() in gesehen:
            ausstieg(12, "Zeile {0} in {1} wiederholt die Anfrage aus Zeile "
                         "{2}: {3}".format(nummer, pfad,
                                           gesehen[anfrage.lower()], anfrage))
        gesehen[anfrage.lower()] = nummer
        urteile.append((anfrage, urteil))
    return urteile


def wilson_intervall(treffer, umfang, z=Z_ALPHA):
    """Unteres und oberes Ende in Prozent. Normalapproximation an eine
    Binomialverteilung, also selbst eine Näherung."""
    anteil = treffer / umfang
    nenner = 1 + z * z / umfang
    mitte = (anteil + z * z / (2 * umfang)) / nenner
    spanne = z * math.sqrt(anteil * (1 - anteil) / umfang
                           + z * z / (4 * umfang * umfang)) / nenner
    return 100 * (mitte - spanne), 100 * (mitte + spanne)


def mindestumfang(gemessen, gegenwert, z_alpha=Z_ALPHA, z_beta=Z_BETA):
    """Anfragen, die nötig wären, um gemessen von gegenwert zu trennen."""
    eins, zwei = gemessen / 100.0, gegenwert / 100.0
    oben = (z_alpha * math.sqrt(zwei * (1 - zwei))
            + z_beta * math.sqrt(eins * (1 - eins))) ** 2
    return math.ceil(oben / (eins - zwei) ** 2)


def bericht(pfad, urteile, tiefe):
    umfang = len(urteile)
    treffer = sum(1 for _, urteil in urteile if urteil == JA)
    unten, oben = wilson_intervall(treffer, umfang)
    anteil = 100.0 * treffer / umfang
    text = [
        "",
        "Protokoll: " + pfad,
        "Tiefe der Trefferliste: top {0} – mitgeschrieben, nicht "
        "gerechnet".format(tiefe),
        "",
        "Beobachtung",
        "  Anfragen beurteilt        {0}".format(umfang),
        "  davon mit Zitat im top {0}  {1}".format(tiefe, treffer),
        "  Anteil                    {0} Prozent".format(dezimal(anteil)),
        "  Wilson-Intervall          {0} bis {1} Prozent".format(
            dezimal(unten), dezimal(oben)),
        "  Breite                    {0} Prozentpunkte".format(
            dezimal(oben - unten)),
        "  eine Anfrage bewegt       {0} Prozentpunkte".format(
            dezimal(100.0 / umfang)),
        "",
        "Nötiger Umfang, um {0} Prozent von einem Gegenwert zu "
        "trennen".format(dezimal(GEMESSEN)),
    ]
    for gegenwert in GEGENWERTE:
        gebraucht = mindestumfang(GEMESSEN, gegenwert)
        text.append("  gegen {0} Prozent  {1:>4} Anfragen  {2}".format(
            dezimal(gegenwert), gebraucht,
            "erreicht" if umfang >= gebraucht else "nicht erreicht"))
    text += [
        "",
        "Zweiseitig, Irrtumswahrscheinlichkeit 0,05, Trennschärfe 80 Prozent,",
        "Normalapproximation. Gezählt sind Anfragen, nicht zitierte URLs.",
        "Ein Intervall bemisst die Streuung einer Stichprobe. Ob diese",
        "Anfragen für irgendetwas stehen, bemisst es nicht.",
        "",
    ]
    return "\n".join(text)


def main(argv):
    rest, tiefe, stelle = [], 10, 1
    while stelle < len(argv):
        wort = argv[stelle]
        if wort == "--tiefe":
            if stelle + 1 >= len(argv):
                ausstieg(3, "--tiefe ohne Wert.\n" + AUFRUF)
            gelesen = tiefe_aus(argv[stelle + 1])
            if gelesen is None:
                ausstieg(4, "--tiefe {0!r} ist keine ganze Zahl größer als "
                            "null.\n{1}".format(argv[stelle + 1], AUFRUF))
            tiefe, stelle = gelesen, stelle + 2
            continue
        if wort.startswith("-"):
            ausstieg(3, "unbekannter Schalter {0!r}.\n{1}".format(wort, AUFRUF))
        rest.append(wort)
        stelle += 1
    if len(rest) != 1:
        ausstieg(2, "{0} Positionsparameter übergeben, erwartet wird genau "
                    "einer.\n{1}".format(len(rest), AUFRUF))
    return bericht(rest[0], lies_urteile(rest[0]), tiefe)


if __name__ == "__main__":
    try:
        sys.stdout.write(main(sys.argv))
    except Bedienfehler as benannt:
        sys.stderr.write(str(benannt) + "\n")
        sys.exit(benannt.code)
    except Exception as unbenannt:
        sys.stderr.write("abgebrochen, kein Prüfurteil: "
                         + repr(unbenannt) + "\n")
        sys.exit(13)

Zwei Protokolle aus einer erfundenen Rösterei

Erfunden sind beide Dateien, die ueberschneidung.py einliest: für sie wurde kein Assistent gefragt und keine Suchmaschine abgefragt, und keine Zeile darin stammt von einer echten Website. Abgedruckt sind sie ganz, eine Datei pro Block und ohne Beschriftungszeile – wer den Block kopiert, hat die Datei. Die Anfragen spielen in einer erfundenen kleinen Kaffeerösterei.

anfrage;zitat_in_top_k
filterkaffee mahlgrad einstellen;ja
espresso röstprofil entwickeln;ja
kaffee direkt vom röster kaufen;nein
trommelröster oder heißluftröster;ja
first crack erkennen;ja
rohkaffee lagern luftfeuchtigkeit;nein
röstgrad nach agtron bestimmen;ja
entgasung nach der röstung;ja
siebträger brühtemperatur stabil halten;ja
abschreckung beim trommelröster;ja
kaffeeröster münchen bio;nein
röstverlust berechnen;ja
cupping protokoll vorlage;nein
sauerstoffdichte verpackung ventil;ja

Der erste Lauf liefert den Fall, der diese Lektion begründet: 10 Treffer in 14 Anfragen, also 71,4 %, Intervall 45,4 bis 88,3 %. Dieses Intervall enthält 60 % und 86,7 % zugleich, das Protokoll kann also nicht einmal sagen, ob die eigene Rösterei näher am vielzitierten Wert oder an einem deutlich niedrigeren liegt – und der Bericht nennt dazu 22 Anfragen als nötigen Umfang, acht mehr, als vorliegen.

$ python3 ueberschneidung.py roesterei-protokoll.csv

Protokoll: roesterei-protokoll.csv
Tiefe der Trefferliste: top 10 – mitgeschrieben, nicht gerechnet

Beobachtung
  Anfragen beurteilt        14
  davon mit Zitat im top 10  10
  Anteil                    71,4 Prozent
  Wilson-Intervall          45,4 bis 88,3 Prozent
  Breite                    42,9 Prozentpunkte
  eine Anfrage bewegt       7,1 Prozentpunkte

Nötiger Umfang, um 86,7 Prozent von einem Gegenwert zu trennen
  gegen 50,0 Prozent    12 Anfragen  erreicht
  gegen 60,0 Prozent    22 Anfragen  nicht erreicht
  gegen 70,0 Prozent    51 Anfragen  nicht erreicht
  gegen 79,2 Prozent   208 Anfragen  nicht erreicht

Zweiseitig, Irrtumswahrscheinlichkeit 0,05, Trennschärfe 80 Prozent,
Normalapproximation. Gezählt sind Anfragen, nicht zitierte URLs.
Ein Intervall bemisst die Streuung einer Stichprobe. Ob diese
Anfragen für irgendetwas stehen, bemisst es nicht.
# exit-code 0

Das zweite Protokoll ist ebenfalls erfunden, trägt aber eine Vorgabe: 15 Zeilen, davon 13 mit ja, weil 86,7 % von 15 genau diese Bilanz ergeben. Die Anfragetexte sind wieder ausgedacht und sagen über Profounds tatsächliche Anfrageliste nichts, denn veröffentlicht ist die nicht.

anfrage;zitat_in_top_k
röstkurve dokumentieren;ja
schütteldichte rohkaffee;ja
espressomühle scheiben wechseln;ja
kaffee einzelröstung kleinmenge;nein
maillard phase steuern;ja
brühverhältnis filter berechnen;ja
röstkammer temperatur messen;ja
grüner kaffee einkauf vertrag;ja
kaffeekirsche aufbereitung washed;nein
tds messung refraktometer;ja
chargengröße trommelröster;ja
ventilbeutel haltbarkeit;ja
sensorik rad verwenden;ja
luftröster bohnenbewegung;ja
röstprotokoll software vergleich;ja

Der Lauf über diese zweite Datei ist das zitierfähigste Stück dieser Seite, weil er die Schlagzeile und ihren Fehlerbereich in derselben Ausgabe zeigt: 86,7 %, und 62,1 bis 96,3 % daneben. Die letzten vier Zeilen des Berichts gehören dazu – ein Intervall beschreibt, wie eine Stichprobe streut, nicht, ob sie für etwas steht.

$ python3 ueberschneidung.py profound-nachbau.csv

Protokoll: profound-nachbau.csv
Tiefe der Trefferliste: top 10 – mitgeschrieben, nicht gerechnet

Beobachtung
  Anfragen beurteilt        15
  davon mit Zitat im top 10  13
  Anteil                    86,7 Prozent
  Wilson-Intervall          62,1 bis 96,3 Prozent
  Breite                    34,1 Prozentpunkte
  eine Anfrage bewegt       6,7 Prozentpunkte

Nötiger Umfang, um 86,7 Prozent von einem Gegenwert zu trennen
  gegen 50,0 Prozent    12 Anfragen  erreicht
  gegen 60,0 Prozent    22 Anfragen  nicht erreicht
  gegen 70,0 Prozent    51 Anfragen  nicht erreicht
  gegen 79,2 Prozent   208 Anfragen  nicht erreicht

Zweiseitig, Irrtumswahrscheinlichkeit 0,05, Trennschärfe 80 Prozent,
Normalapproximation. Gezählt sind Anfragen, nicht zitierte URLs.
Ein Intervall bemisst die Streuung einer Stichprobe. Ob diese
Anfragen für irgendetwas stehen, bemisst es nicht.
# exit-code 0

Kein Bedienfehler sieht aus wie ein Befund

Die Sitzung unten ruft ueberschneidung.py zwölfmal auf und löst dabei elf verschiedene Rückgabewerte aus, von 2 bis 12. Sechs beschädigte Dateien macht ein sed oder ein head aus dem erfundenen Protokoll von oben; latin1.csv schreibt ein printf von Hand, mit einem Byte, das keine gültige UTF-8-Folge beginnt, und fehlt.csv wird gar nicht angelegt – darin besteht ja der Fall. Mit den beiden Berichten davor sind zwölf der dreizehn belegten Werte auf dieser Seite zu sehen; der Wert 13 ist in keinem Lauf gefallen, und genau dafür ist er da.

$ python3 ueberschneidung.py
0 Positionsparameter übergeben, erwartet wird genau einer.
Aufruf: ueberschneidung.py protokoll.csv [--tiefe N, Vorgabe 10]
# exit-code 2

$ python3 ueberschneidung.py roesterei-protokoll.csv --tiefe
--tiefe ohne Wert.
Aufruf: ueberschneidung.py protokoll.csv [--tiefe N, Vorgabe 10]
# exit-code 3

$ python3 ueberschneidung.py roesterei-protokoll.csv --hilfe
unbekannter Schalter '--hilfe'.
Aufruf: ueberschneidung.py protokoll.csv [--tiefe N, Vorgabe 10]
# exit-code 3

$ python3 ueberschneidung.py roesterei-protokoll.csv --tiefe null
--tiefe 'null' ist keine ganze Zahl größer als null.
Aufruf: ueberschneidung.py protokoll.csv [--tiefe N, Vorgabe 10]
# exit-code 4

$ python3 ueberschneidung.py fehlt.csv
keine lesbare reguläre Datei: fehlt.csv
# exit-code 5

$ printf 'anfrage;zitat_in_top_k\nespresso r\366stprofil entwickeln;ja\n' > latin1.csv
$ python3 ueberschneidung.py latin1.csv
nicht UTF-8: latin1.csv ('utf-8' codec can't decode byte 0xf6 in position 33: invalid start byte)
# exit-code 6

$ sed 's/;/,/g' roesterei-protokoll.csv > kommas.csv
$ python3 ueberschneidung.py kommas.csv
Kopfzeile in kommas.csv lautet anfrage,zitat_in_top_k, erwartet wird anfrage;zitat_in_top_k mit Semikolon
# exit-code 7

$ head -1 roesterei-protokoll.csv > nur-kopf.csv
$ python3 ueberschneidung.py nur-kopf.csv
Kopfzeile gültig, aber keine Datenzeile in nur-kopf.csv
# exit-code 8

$ sed '5s/$/;10/' roesterei-protokoll.csv > feldzahl.csv
$ python3 ueberschneidung.py feldzahl.csv
Zeile 5 in feldzahl.csv hat 3 Felder statt 2: trommelröster oder heißluftröster;ja;10
# exit-code 9

$ sed '5s/^[^;]*//' roesterei-protokoll.csv > leerzelle.csv
$ python3 ueberschneidung.py leerzelle.csv
Zeile 5 in leerzelle.csv: anfrage ist vorhanden und leer
# exit-code 10

$ sed '5s/ja$/True/' roesterei-protokoll.csv > wahrheitswert.csv
$ python3 ueberschneidung.py wahrheitswert.csv
Zeile 5 in wahrheitswert.csv: Urteil 'True' ist weder ja noch nein; Wahrheitswerte und Ziffern übersetzt du von Hand
# exit-code 11

$ sed -n '1,5p;5p' roesterei-protokoll.csv > doppelt.csv
$ python3 ueberschneidung.py doppelt.csv
Zeile 6 in doppelt.csv wiederholt die Anfrage aus Zeile 5: trommelröster oder heißluftröster
# exit-code 12

Die Läufe mit den Werten 9, 10 und 11 gehören zusammen gelesen. Ein Feld zu viel, eine leere Pflichtzelle und ein True an der Stelle eines Urteils sind drei verschiedene Fehler, hier in drei Dateien, die je ein sed aus demselben Protokoll gemacht hat – und jeder bekommt seinen eigenen Wert samt Zeilennummer. Ein Skript, das stattdessen jede unklare Zeile überspringt, druckt am Ende einen Anteil mit einem kleineren Nenner, und nichts in der Ausgabe weist darauf hin.

Was ein Eintrag in Anthropics Subunternehmerliste belegt

Ein Eintrag in einer Subunternehmerliste ist eine datierte Angabe über eine Geschäftsbeziehung, und so weit reicht er. Xponent21 hat Anthropics Trust Center erfasst und dort am 2. Juli 2026 noch einmal nachgesehen: Brave Search trug als Subunternehmer das Datum 19. März 2025, turbopuffer den 6. Mai 2026. Belegt ist damit ein Leseergebnis mit Datum und kein Dauerzustand: so standen die Einträge, als Xponent21 zuletzt nachsah. Für diese Lektion wurde keine Seite dieser Liste geöffnet; sie steht hier mit Urheber und Datum ohne Link.

Zwei verbreitete Schlüsse gehen darüber hinaus, und beide zieht diese Seite nicht. Der erste macht aus zwei Namen einen Ablauf, obwohl ein Startdatum kein Abrufweg ist: wer die Schritte zwischen deiner Seite und einem Satz in einer Claude-Antwort erzählt, füllt Lücken, die in den Quellen offen geblieben sind. Der zweite macht aus der Nennung von Brave Search eine Aussage über Googles Index – nur nennt die Liste Google nicht, und ein fehlender Name ist keine Messung. Weiter oben steht sogar die Gegenzahl: von den von Claude zitierten URLs lagen laut MERJ 34 % auch in Googles Top 10. Welchen Index Claude abfragt, sagt auch diese Zahl nicht; sie nennt einen Anteil und keinen Abrufweg.

Überhaupt in Braves Index zu stehen ist die Frage davor, und sie hat eigene, nachlesbare Bedingungen: Im Brave-Index landen: das Web Discovery Project. Die Rechnung dieser Lektion beginnt ein Stück später, nämlich an dem Punkt, an dem ein bereits gespeichertes Dokument in eine Antwort kommt; den Schritt davor nimmt sie keinem ab. Erreichbar und lesbar zu sein gehört zu technischem SEO, das eigene Protokoll über Monate zu führen in SEO-Analytics und Messung, das fünfte Level.

Die Nachfrage nennt das Zitat, und ein Suchstamm führt in die Irre

Was Leute zum Erscheinen in Claude wirklich eintippen, dreht sich um ein Zitat und nicht um eine Platzierung. Google Autocomplete lieferte dazu am 20. September 2026, erhoben für diesen Kurs, how to get cited by claude und how to get mentioned in claude. Der Stamm how to rank on claude ist dagegen verschmutzt und liefert how to rate claude ai sowie how to rank characters. Wer eine Keyword-Recherche darauf aufsetzt, zählt Vorschläge mit, die mit dem Thema nichts zu tun haben. Was Autocomplete liefert, ist eine Liste von Formulierungen und keine Häufigkeit. Eine Volumenangabe steht auf dieser Seite darum nirgends.

Dicht daneben liegt eine offene Streitfrage: ob die modellierte Volumenangabe eines Keyword-Werkzeugs eine Messung ist oder eine Schätzung im Gewand einer Zählung. Dafür spricht, dass eine modellierte Zahl die beste verfügbare ist und ohne sie nichts priorisiert wird; dagegen, dass kein Anbieter sein Modell offenlegt und zwei Anbieter zum gleichen Begriff verschieden große Zahlen liefern. Eine Untersuchung, die Werkzeugschätzungen gegen eine offengelegte Grundwahrheit hält, wurde für diese Lektion nicht gefunden. Unbeantwortet bleibt die Frage hier, und sie muss es nicht werden: diese Seite rechnet ausschließlich über Anfragen, die du selbst gestellt hast. Was Claude im SEO leisten kann – und was nicht grenzt ein, welche Recherche ein Modell überhaupt übernimmt.

Was diese Rechnung nicht entscheidet

Diese Lektion liefert ein Messverfahren und keine Empfehlung zum Seiteninhalt. Wer aus einer Überschneidungszahl ableitet, wie eine Seite zu schreiben ist, hat das Fach gewechselt, und dafür ist GEO und AIO zuständig, wo dieselbe Frage für mehrere Antwortflächen bearbeitet wird. Dass Level 8 und Level 4 getrennt stehen, ist in diesem Kurs eine Einteilung des Stoffs und kein Urteil über Fachgrenzen.

Was ein Anfrageprotokoll festhält, ist eine Momentaufnahme von Positionen: an einem Tag stand diese URL dort und wurde hier zitiert. Über Berufsbilder folgt daraus nichts, und deshalb ist die Überschneidungszahl in der Frage, ob Generative Engine Optimization eine Disziplin für sich ist oder eine Umbenennung, das falsche Werkzeug. Gegriffen wird trotzdem nach ihr, von beiden Seiten. Für die Disziplin spricht am stärksten, dass ein zweiter Index mit eigenen Aufnahmebedingungen mitentscheidet und dass ihn vorher niemand bearbeitet hat. Für die Umbenennung spricht am stärksten, dass eine hohe Deckung zwischen Zitaten und Platzierungen beschreibt, was Suchmaschinenoptimierung seit Jahren leistet, nur mit einem weiteren Abnehmer. Entschieden wäre die Frage mit einer Erhebung, die eine bewegte Platzierung und die Zitatquote derselben Seiten danach zugleich festhält; unter den Erhebungen, die für diese Lektion gelesen wurden, ist sie nicht. Ein Protokoll über 15 Anfragen zählt Treffer und zieht keine Fachgrenze.

Häufige Fehler

1. Das Protokoll mit Wahrheitswerten füllen. Ein Export, der True und leere Zellen liefert, enthält kein Urteil pro Anfrage. Die Korrektur: ja und nein von Hand setzen; Wert 11 und Wert 10 nennen die Zeile, die es war.
2. Eine Überschneidung als Mechanismus lesen. Wie Claude auswählt und umsortiert, beschreiben weder Profound noch MERJ; beide messen das Ende des Vorgangs. Die Korrektur: als notwendige Bedingung formulieren – ausgewählt wird nur, was gespeichert ist – und nicht als Hebel.
3. Den nötigen Umfang erst hinterher ausrechnen. Eine Erhebung über 15 Anfragen trennt 86,7 % nicht von 60 %, und das steht fest, bevor jemand die erste Anfrage erfasst. Die Korrektur: zuerst die Zeile mit dem nötigen Umfang lesen, dann entscheiden, wie viele Anfragen du erfasst.
4. Eine kleine Stichprobe mit einer unauffindbaren verwechseln. Profounds 15 Anfragen sind klein und nachrechenbar; die herumgehende dritte Sammlung ist keines von beiden, weil ihr Erhebungszeitraum nicht aufzufinden war. Die Korrektur: eine kleine Stichprobe nennst du mit ihrem Umfang, eine unauffindbare gar nicht.
5. Zwei Quoten zu einer Zahl verrechnen. 86,7 % ist eine Quote je Anfrage, 79,2 % eine Quote je zitierter URL; ein Mittelwert daraus hätte keine Einheit. Die Korrektur: jede Quote mit ihrem Nenner führen und beim Zusammenfassen zuerst die Einheit prüfen; wo die Einheiten verschieden sind, bleibt es bei zwei Zahlen.

Kurzfassung

• Profounds Erhebung vom 21. März 2025 nennt 86,7 % Deckung zwischen Claudes Zitaten und Braves obersten unbezahlten Ergebnissen, bei p<0,0001 und über 15 Anfragen. Das sind 13 Treffer von 15, und das Vertrauensintervall reicht von 62,1 bis 96,3 %.
• MERJ berichtet für 2026 ohne Monat über zitierte URLs: 79,2 % in den Top 10 von Brave, 34 % in denen von Google – ohne Stichprobengröße und damit ohne rechenbare Fehlerspanne.
• Profounds Nenner sind Anfragen, MERJs zitierte URLs; die beiden Zahlen lassen sich nicht mitteln und nicht als eine Reihe lesen.
• Gespeichert kommt vor zitiert: diese Reihenfolge trägt ohne Auslegung, und sie verweist auf die Lektion zum Brave-Index statt auf eine Überschneidungszahl.
• Die 20 % Überschneidung mit ChatGPT aus derselben Erhebung nennen keine Vergleichsmenge und sind deshalb keine zweite Messung desselben Verfahrens.
• Eine Subunternehmerliste nennt beteiligte Dritte und Datumsangaben: Xponent21 las dort den 19. März 2025 für Brave Search und den 6. Mai 2026 für turbopuffer, nachgesehen am 2. Juli 2026. Einen Abrufweg beschreibt sie nicht, und über Googles Index sagt sie gar nichts.
• Ein Vertrauensintervall gilt für eine Stichprobe und nicht für deren Auswahl: ob die 15 Anfragen etwas vertreten, ist keine Frage der Arithmetik.
• Der Umfang ist die Zahl, die in beiden Erhebungen fehlt: 22 Anfragen trennen 86,7 % von 60,0 %, 51 von 70,0 % und 208 von 79,2 % – gerechnet in Normalapproximation, zweiseitig, Irrtumswahrscheinlichkeit 0,05, Trennschärfe 80 %.

Häufige Fragen

Mein Intervall ist über 40 Prozentpunkte breit. Was mache ich damit?

Du hältst deinen Beschluss gegen beide Enden. Bei 10 Treffern in 14 Anfragen reicht das Intervall von 45,4 bis 88,3 %: fällt der Beschluss bei 45 % anders aus als bei 88 %, erfasst du weiter, sonst reicht der Umfang für diesen Beschluss. Eine allgemeine Mindestzahl gibt es nicht, weil sie am Beschluss hängt und nicht an einer Konvention.

Warum steht hier kein Mittelwert aus den beiden veröffentlichten Zahlen?

Weil 86,7 % und 79,2 % verschiedene Dinge zählen. Profound beurteilt 15 Anfragen und fragt, ob bei einer davon ein Treffer dabei war; MERJ beurteilt zitierte URLs und fragt, wie viele in Braves Top 10 lagen. Ein Durchschnitt daraus hätte keine Einheit, weil die eine Quote je Anfrage und die andere je URL gebildet ist. Dass beide in dieselbe Richtung zeigen, ist eine Information; eine gemeinsame Kennzahl ist es nicht.

Ändert sich die Rechnung, wenn ich die Trefferliste nur bis Platz 3 erfasse?

Nein, und darum wird --tiefe im Bericht nur mitgeschrieben. Das Urteil ja oder nein ist gefallen, als du erfasst hast; nachträglich vertiefen kann das Skript es nicht. Zwei Protokolle mit verschiedenen Tiefen gehören deshalb nicht in dieselbe Zahl, und die Tiefe steht in der zweiten Berichtszeile, weil sie zur Beschreibung des Datensatzes gehört.

Das Skript meldet Wert 10 oder Wert 11 – wie weiter?

Du korrigierst die genannte Zeile und startest neu; eine Zahl hat das Skript in beiden Fällen nicht ausgegeben. Wert 10 heißt, eine Pflichtzelle ist vorhanden und leer; Wert 11, dort steht etwas anderes als ja oder nein – etwa ein True aus einem Export. Beides sind Bedienfehler und keine Befunde über deine Website; deshalb teilen sie keinen Wert mit der 0, die einen fertigen Bericht meldet.

Quellen

Keine der hier aufgeführten Quellen wurde geöffnet; sie stehen mit Urheber und Datum ohne Link, und das ist in diesem Kurs die Regel.

• Profound, What is Claude web search, 21. März 2025 – 86,7 % Überschneidung zwischen Claudes Zitaten und Braves obersten unbezahlten Ergebnissen, p<0,0001, n = 15 Anfragen; dazu 20 % Überschneidung mit ChatGPT, ohne Angabe der Vergleichsmenge. Ohne Link.
• MERJ, 2026, ohne Monat – von den zitierten URLs lagen 79,2 % in den Top 10 von Brave und 34 % in denen von Google. Keine Stichprobengröße veröffentlicht. Ohne Link.
• Anthropic, Trust Center – erfasst von Xponent21 und dort nachgesehen am 2. Juli 2026: Eintrag für Brave Search mit dem Datum 19. März 2025, Eintrag für turbopuffer mit dem 6. Mai 2026. Ohne Link.
• Eine in der Branche herumgehende dritte Sammlung von Claude-zitierten URLs – Datensatz und Erhebungszeitraum waren nicht auffindbar, deshalb steht keine ihrer Zahlen hier. Ohne Link.
• Eigene Erhebung von Google Autocomplete für diesen Kurs, 20. September 2026: how to get cited by claude und how to get mentioned in claude; der Stamm how to rank on claude liefert how to rate claude ai und how to rank characters. Erfasst ist damit eine Formulierung und keine Häufigkeit; eine Volumenangabe mit nachprüfbarer Herkunft war zu keinem Begriff zu beschaffen.
• Eigene Rechnung – die 13 Treffer aus 86,7 % und 15 Anfragen, jedes Wilson-Intervall und jede Umfangsangabe stammen aus ueberschneidung.py auf dieser Seite.
• ueberschneidung.py, die beiden erfundenen Protokolle und jeder Lauf sind ganz wiedergegeben: dreizehn belegte Rückgabewerte, keine Fremdbibliothek, kein Netzzugriff. Was die Läufe ausgeben, folgt allein aus den hier abgedruckten Dateien; deshalb steht daneben kein Datum.

Weiter im Kurs

• Vorher in diesem Level: Was Claude im SEO leisten kann – und was nicht, Claude Code für technisches SEO und Im Brave-Index landen: das Web Discovery Project.
• Level 4, die Nachbarschaft dieser Frage: GEO und AIO: SEO für KI-Suchmaschinen.
• Level: SEO mit KI: KI als Arbeitswerkzeug
• Alle Level: Kostenloser SEO-Kurs: 100 Lektionen von den Grundlagen bis Black Hat