🤖 AI

A Methodology for Investigating AI Patterns Prevalence in Software Repositories

Dieses Paper schlägt eine Methodik vor und validiert diese, welche Literature Mining zur Identifizierung von 14 KI-Musterklassen mit Active Learning kombiniert, um deren Prävalenz und Genauigkeit in realen GitHub-Repositories empirisch zu messen, wodurch eine aktuelle Lücke im Verständnis darüber schließt, wie KI-Muster in der Praxis tatsächlich angewendet werden.

Ursprüngliche Autoren: Srinath Perera, Hasinthaka Piyumal, Frank Leymann, Rania Khalaf

Veröffentlicht 2026-07-02

📖 5 Min. Lesezeit🧠 Tiefgang

CC BY 4.0

Ursprüngliche Autoren: Srinath Perera, Hasinthaka Piyumal, Frank Leymann, Rania Khalaf

Originalarbeit lizenziert unter CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dies ist eine KI-generierte Erklärung des untenstehenden Papers. Sie wurde nicht von den Autoren verfasst oder gebilligt. Für technische Genauigkeit konsultieren Sie das Originalpaper. Vollständigen Haftungsausschluss lesen

Stellen Sie sich vor, Sie sind ein Stadtplaner, der verstehen möchte, wie Menschen tatsächlich Häuser bauen in einer geschäftigen, modernen Stadt. Sie besitzen ein dickes Buch mit „Idealen Hausentwürfen“ (die von Experten in der Literatur vorgeschlagenen KI-Muster), aber Sie haben keine Ahnung, ob diese Entwürfe tatsächlich in den echten Nachbarschaften verwendet werden oder ob die Leute einfach ihre eigenen seltsamen Strukturen erfinden, während sie arbeiten.

Dieses Paper ist das Team von Forschern, die beschlossen haben, auszugend, 100 tatsächliche Hausviertel (GitHub-Code-Repositories) zu besichtigen, um herauszufinden, welche „Idealen Entwürfe“ wirklich verwendet werden.

Hier ist, wie sie es gemacht haben, einfach erklärt:

1. Das Problem: Zu viele Ideen, zu wenig Beweise

Experten haben hunderte von „KI-Mustern“ (Rezepten für das Bauen intelligenter Software) aufgeschrieben. Aber niemand wusste, ob diese Rezepte auch wirklich in echten Küchen gekocht werden. Die Forscher wollten von der „Theorie“ zur „Realität“ übergehen.

2. Schritt Eins: Das Rezeptbuch aufräumen

Zuerst sammelten sie 769 verschiedene „Rezepte“ aus Büchern, Blogs und Dokumentationen. Das war zu unordentlich, um damit zu arbeiten.

Die Analogie: Stellen Sie sich vor, Sie hätten 769 verschiedene Namen für das „Zubereiten eines Sandwiches“. Einige sagen „Club“, andere „BLT“, andere „Schinken und Käse auf Weizentoast“.
Die Lösung: Sie nutzten einen smarten Computer (ein LLM), um ähnliche Rezepte zusammenzufassen. Dann schauten Menschen über die Gruppen und ordneten sie in 14 klare Kategorien ein (wie „RAG“, „Agent Architecture“, „Preprocessing“ usw.). Dies erstellte eine saubere, organisierte Speisekarte aus 14 Hauptgerichten.

3. Schritt Zwei: Die „Nachbarschaften“ finden (Code-Gemeinschaften)

Sie konnten nicht einfach nur eine einzelne Zeile Code betrachten; das wäre so, als würde man ein ganzes Haus nach einem einzigen Ziegelstein beurteilen. Sie brauchten „Code-Gemeinschaften“, die zusammenarbeiten.

Die Analogie: Anstatt auf einzelne Ziegelsteine zu schauen, betrachteten sie die „Zimmer“ des Hauses. Sie nutzten eine spezielle Karte (einen Call Graph), um Gruppen von Code zu finden, die eng miteinander verbunden sind, wie eine Küche, in der Herd, Kühlschrank und Spüle alle miteinander verknüpft sind.
Die Auswahl: Sie wählten 100 reale KI-Projekte von GitHub (die „Nachbarschaften“) aus, die populär waren, aber nicht die massiven, grundlegenden Frameworks (wie TensorFlow). Sie wollten sehen, was typische Entwickler bauen, nicht nur die riesigen Werkzeuge, auf denen alle anderen aufbauen.

4. Schritt Drei: Das „Raten und Prüfen“-Spiel (Active Learning)

Dies ist der cleverste Teil. Sie hatten keinen Lehrer mit dem Lösungsschlüssel (gelabelte Daten), um ihr Computermodell zu trainieren.

Die Analogie: Stellen Sie sich einen Schüler vor, der eine Prüfung schreibt, aber die Antworten nicht kennt.
1. Der Schüler stellt ein paar Vermutungen basierend auf ein paar selbst generierten Beispielen an.
2. Der Computer schaut auf die 100 Nachbarschaften und sagt: „Bei diesem hier bin ich mir zu 50/50 unsicher, aber bei jenem bin ich mir sicher.“
3. Die Forscher (die menschlichen Lehrer) schauen sich nur die Fälle an, bei denen der Computer unsicher ist. Sie labeln diese, und dann lernt der Computer daraus.
4. Sie wiederholen diesen Zyklus. Der Computer wird mit jeder Runde klüger und bittet nur dann um Hilfe, wenn er wirklich verwirrt ist. Dies sparte ihnen die Arbeit, tausende Dateien manuell lesen und labeln zu müssen.

5. Schritt Vier: Die Ergebnisse zählen (Mit einem Sicherheitsnetz)

Sobald der Computer trainiert war, scannte er die 100 Nachbarschaften, um zu zählen, wie oft jedes Muster vorkam.

Der Twist: Der Computer ist nicht perfekt. Er macht Fehler. Deshalb gaben die Forscher nicht einfach eine einzelne Zahl an (z. B. „RAG wird 20 % der Zeit verwendet“).
Das Sicherheitsnetz: Sie nutzten einen statistischen Trick (wie das Durchspielen einer Simulation 20.000 Mal), um zu sagen: „Wir sind zu 95 % sicher, dass die wahre Zahl zwischen X und Y liegt.“ Dies liefert ein „Konfidenzintervall“ und räumt ein, dass ihre Schätzung eine Fehlermarge hat.

Was haben sie herausgefunden?

Die Punktzahl: Ihr Computer erreichte eine Genauigkeit von etwa 56 % bei der Identifizierung, welches Muster verwendet wurde. Das klingt niedrig, aber denken Sie daran, dass es 8 verschiedene Kategorien zur Auswahl gab. Zufälliges Raten würde nur 11 % ergeben. Sie waren also 5-mal besser als der Zufall.
Die Gewinner: Sie fanden heraus, dass Muster wie „Forecasting with Classical Models“ und „Multimodal Prompting“ sehr häufig waren.
Die Verlierer: Einige Muster, wie „Using Tools with LLMs“, waren schwer zu entdecken, weil sie keinen starken „Fingerabdruck“ im Code hinterließen, sodass der Computer sie oft mit „nichts Besonderem“ (der Kategorie „None“) verwechselte.
Das „None“-Problem: Viel Code wurde als „None“ (kein Muster erkannt) klassifiziert. Dies geschah, weil einige Muster subtil sind oder der Code zu unordentlich war, um vom Modell erkannt zu werden.

Das große Fazit

Dieses Paper sagte nicht nur „KI-Muster existieren“. Es baute eine robuste Methode auf, um zu beweisen, wie oft sie in der realen Welt verwendet werden, selbst wenn wir nicht über einen perfekten Datensatz zu Beginn verfügen.

Sie zeigten:

Man kann eine unordentliche Liste von Ideen in eine saubere Taxonomie organisieren.
Man kann einen Computer lehren, diese Muster zu finden, indem man Menschen nur dann um Hilfe bittet, wenn der Computer verwirrt ist (Active Learning).
Man kann schätzen, wie verbreitet diese Muster sind, während man ehrlich zu seinen „Fehlerspannen“ steht.

Es ist, als hätte man endlich eine zuverlässige Volkszählung der Architektur einer Stadt, ergänzt durch den Hinweis: „Wir sind uns bei den Häusern ziemlich sicher, aber die winzigen Schuppen könnten etwas unscharf sein.“ Dies gibt Entwicklern und Forschern eine fundierte, datengestützte Basis, um zu verstehen, wie KI heute tatsächlich gebaut wird.

Technisches Resümee: Eine Methodik zur Untersuchung der Prävalenz von KI-Mustern in Software-Repositories

Problemstellung

Da Anwendungen der Künstlichen Intelligenz (KI), insbesondere solche, die Large Language Models (LLMs) nutzen, allgegenwärtig werden, wächst der Bedarf zu verstehen, wie KI-Entwurfsmuster (Design Patterns) in der Praxis angewendet werden. Während zahlreiche KI-Muster in der akademischen Literatur und Industriedokumentation (z. B. RAG, ReAct, Agent Frameworks) vorgeschlagen wurden, bleibt deren tatsächliche Prävalenz und Bedeutung in realen Codebasen bisher unvalidiert. Die bestehende Software-Engineering-Forschung stützt sich oft auf kuratierte Benchmarks (wie P-MART oder DPB), die auf traditionellen Entwurfsmustern (z. B. GOF) basieren, welche jedoch nicht die notwendigen Daten für neu aufkommende KI-Muster liefern. Zudem besteht ein erheblicher Engpass: der Mangel an annotierten Datensätzen, die für das Training von Modellen zur Erkennung nischiger oder neu entstehender Muster erforderlich sind. Dieses Paper adressiert die Herausforderung, KI-Muster empirisch zu validieren, ohne auf vorab existierende annotierte Datensätze zurückgreifen zu müssen.

Methodik

Die Autoren schlagen eine vierstufige Methodik vor, um KI-Muster in Open-Source-Repositories zu identifizieren, zu detektieren und deren Prävalenz zu schätzen.

1. Literatur-Mining und Taxonomie-Konstruktion

Der Prozess beginnt mit der Extraktion von 769 KI-Muster-Kandidaten aus 44 veröffentlichten Quellen, einschließlich Büchern, Surveys, Fachartikeln und Dokumentationen.

Clustering: Die Musterbeschreibungen werden in Wort-Embeddings umgewandelt und mittels des DBSCAN-Algorithmus geclustert, um ähnliche Kandidaten zu gruppieren.
Verfeinerung: Ein LLM fasst jedes Cluster zusammen, um verfeinerte Kandidaten zu erstellen.
Kategorisierung: Durch manuelle Inspektion werden diese Kandidaten in 14 distinkte Musterklassen kategorisiert, darunter RAG, Multi-Agent-Architektur, LLM Fine-Tuning und MLOps.

2. Sammlung von Real-World-Code und Chunking

Um diese Muster zu validieren, haben die Autoren einen Datensatz von 100 Open-Source-GitHub-Repositories zusammengestellt, die reale KI-Anwendungen implementieren. Die Auswahlkriterien zielten auf Python-Repositories mit 250–1.000 Stars ab, um sich auf die „Applikationsschicht“ statt auf fundamentale Frameworks zu konzentrieren.

Code-Communities: Anstatt einzelne Dateien oder Funktionen zu analysen, erstellten die Autoren Prozedur-Aufruf-Graphen (Procedure Call Graphs) für jedes Repository.
Louvain-Methode: Sie wandten die Louvain-Methode an, um „Code-Communities“ (eng gekoppelte Gruppen von Methoden) zu detektieren.
Chunking-Strategie: Jede Code-Community wurde als einzelner Chunk für die Generierung von Embeddings behandelt. Dieser Ansatz wurde gewählt, da der Code innerhalb einer Community wahrscheinlich vollständige Muster enthält, was die Sensitivität von Embeddings gegenüber Chunking-Grenzen adressiert.

3. Aktives Lernen für das Modelltraining

Aufgrund des Mangels an gelabelten Daten setzten die Autoren einen Active-Learning-Ansatz ein, um einen Klassifikator für die häufigsten Musterklassen zu erstellen.

Bootstrapping: Ein initiales Modell wurde auf synthetischen Daten trainiert, die von einem LLM generiert wurden ( $D_{init}$ ).
Iteratives Labeling: Das Modell wählte iterativ Datenpunkte aus dem ungelabelten Pool ( $D_{unlabeled}$ ), die die höchste Vorhersageunsicherheit aufwiesen (mittels Margin Sampling).
Human-in-the-Loop: Diese unsicheren Stichproben wurden von Menschen manuell gelabelt. Das Modell wurde daraufhin unter Verwendung einer 5-fachen Kreuzvalidierung neu trainiert.
Ensemble-Modellierung: Das finale Modell nutzte ein Ensemble aus Logistischer Regression, SVC und KNN, gewichtet nach deren F1-Scores.
Klassenbehandlung: Um Stabilität zu gewährleisten, wurden Musterklassen mit weniger als 5 % der Daten oder weniger als 20 Instanzen während der Trainingsiterationen in eine „None“-Klasse zusammengeführt.

4. Prävalenzschätzung mit Fehlergrenzen

Um die wahre Häufigkeit von Mustern unter Berücksichtigung von Modellfehlern und Stichprobenrauschen zu schätzen, wandten die Autoren an:

Matrixinversion: Unter Verwendung der normalisierten Konfusionsmatrix ( $C$ ), die aus der Kreuzvalidierung abgeleitet wurde, invertierten sie die Beziehung $O_{samp} = C \cdot T_D$ , um die wahre Verteilung ( $T_D$ ) aus der beobachteten Verteilung ( $O_{samp}$ ) zu schätzen.
Monte-Carlo-Simulation: Um die Unsicherheit zu quantifizieren, simulierten sie Stichprobenfehler durch Ziehungen aus einer Multinomialverteilung und führten 20.000 Iterationen durch, um 95 %-Konfidenzintervalle für die Prävalenzschätzungen zu berechnen.

Zentrale Beiträge

Robuste Methodik für datenarme Domänen: Das Paper schlägt ein Framework vor, das Active Learning und Human-in-the-Loop-Annotationen kombiniert, um Muster ohne vorab existierende annotierte Datensätze zu detektieren, und adressiert damit einen kritischen Engpass in der Software-Engineering-Forschung.
Neuartige Chunking-Technik: Die Autoren führen eine Methode unter Verwendung des Louvain-Algorithmus auf Aufruf-Graphen ein, um „Code-Communities“ als Chunks zu identifizieren, was die Generierung von Embeddings für die Mustererkennung in komplexem Real-World-Code optimiert.
Prävalenzschätzung mit Fehlergrenzen: Die Anwendung von Matrixinversion und Monte-Carlo-Simulationen liefert nutzbare Fehlergrenzen für die Häufigkeitsschätzungen, wodurch Forscher die Zuverlässigkeit ihrer Ergebnisse bewerten können.
Empirische Validierung: Die Studie synthetisiert 769 Kandidaten zu einer Taxonomie von 14 Klassen und liefert eine der ersten empirischen Validierungen der Prävalenz von KI-Mustern durch die Analyse von 100 Open-Source-Repositories.

Ergebnisse

Die Studie analysierte 2.442 Code-Communities über 100 Repositories hinweg.

Klassifikationsleistung: Das finale Modell erreichte eine Genauigkeit von 56 % und einen Recall von 55 % bei einer 8-Wege-Klassifikation (einschließlich einer „None“-Klasse). Dies übertrifft die Baseline von 11 % (Zufallschance) signifikant.
Muster-Prävalenz: Die Analyse bestätigte das Vorhandensein mehrerer Musterklassen. Beispielsweise waren „Forecasting with Classical Models“ und „Multimodal Generative Prompting“ zu den am häufigsten vorkommenden Klassen.
Fehlergrenzen: Die Prävalenzschätzung lieferte nutzbare Konfidenzintervalle für 5 von 7 analysierten Klassen. Klassen mit weniger Trainingsproben (z. B. „Tool Use with LLMs“) wiesen breitere Konfidenzintervalle oder Null-Grenzen auf, was auf eine höhere Unsicherheit aufgrund von Fehlklassifizierungen hindeutet (oft mit der „None“-Klasse verwechselt).
Vergleich mit Vorarbeiten: Während Pandey et al. [23] einen F1-Score von 0,91 auf kuratierten Datensätzen (P-MART) erreichten, wird die hier geringere Leistung auf die Komplexität von Real-World-Code im Vergleich zu sauberen, kuratierten Segmenten zurückgeführt.

Bedeutung und Ansprüche

Das Paper beansprucht, eine robuste Grundlage für das Verständnis der praktischen Anwendung von KI-Mustern zu bieten – ein Feld, dem es derzeit an empirischen Daten mangelt.

Praktischer Nutzen: Die Methodik ermöglicht es Forschern, die breite Verfügbarkeit spezifischer Musterklassen zu bestätigen und deren relative Häufigkeit zu verstehen. Beispielsweise legen die Ergebnisse nahe, dass „Forecasting with Classical Models“ und „Multimodal Prompting“ in den analysierten Repositories signifikant häufiger vorkommen als „Agent Architecture“.
Zuverlässigkeitsbewertung: Die vorgeschlagenen Fehlergrenzen ermöglichen es Nutzern, zu identifizieren, wann Schätzungen unzuverlässig sind (z. B. bei seltenen Klassen) und zu entscheiden, wann weitere Iterationen des Active Learning notwendig sind, um die Präzision zu verbessern.
Skalierbarkeit: Die Autoren behaupten, dass ihr Ansatz weitgehend unabhängig von spezifischen KI-Mustern ist und auf andere Domänen (z. B. Microservices, Quantencomputing) erweitert werden kann oder dazu genutzt werden kann, mehrere Muster innerhalb einer einzigen Code-Community via Wahrscheinlichkeitsverteilungen zu detektieren.

Das Paper schließt mit dem Schluss, dass die aktuellen Genauigkeitswerte zwar nicht ausreichen, um spezifische Muster in beliebigen Code-Segmenten zu identifizieren, die Methodik jedoch erfolgreich die Lücke zwischen theoretischen Muster-Vorschlägen und der empirischen Realität schließt und somit einen Weg zu einem datengesteuerten Software-Engineering für KI ebnet.