Open-Source-LLMs im Test: Wie gut eignen sie sich als Entwicklungsunterstützung?

1. Einführung

In diesem Blogartikel widmen wir uns der Frage, inwiefern lokal im Unternehemen bereitgestellte Open-Source-Modelle ausgereift genug sind, um mit den „großen“, kommerziellen Modellen wie Claude oder Chat-GPT mithalten zu können. Der Rummel um KI – egal in welcher Branche – könnte kaum größer sein. Überall werden Automatisierung und Effizienzsteigerungen versprochen, denn Maschinen sollen in gleicher Zeit mehr leisten, als es dutzende Menschen je könnten. Wir untersuchen, in wie weit das auch für die kostenfreien Open-Source-Modelle gilt. Dafür haben wir uns ein realistisches Angular-Beispielprojekt genommen und den LLMs Code Llama 3.1, Deep Seek Coder 2, Phind Code Llama und Wizard Coder ein paar Aufgaben gestellt…

Die Resultate werden dann mit den Antworten von Claude Sonnet 4 verglichen, um einen soliden Referenzwert zu haben. Wer gewinnt? Und wie knapp? Das lest ihr hier.

Die Ergebnisse dieses Tests beinhalten nicht vermeidbare, subjektive Bewertungen und spiegeln daher unweigerlich unsere Perspektive wider. Der ein oder andere Leser wird sicherlich andere Erfahrungen gemacht haben und daher unsere Meinung zum Testergebnis nicht teilen. Und das ist auch in Ordnung so!

1.1 Motivation

Large Language Models (LLMs) sind längst nicht mehr nur ein Hype – sie haben sich als praktische Helfer in der Softwareentwicklung etabliert. Besonders im Webdevelopment, wo sich Frameworks, Bibliotheken und Best Practices ständig weiterentwickeln, können sie wertvolle Unterstützung bieten. Doch wie gut sind lokal Open-Source-Modelle mit bis zu 60B wirklich? Und lohnt sich ihr Einsatz im professionellen Umfeld?

Genau das wollen wir in unserem Test herausfinden. Denn wenn Open-Source-LLMs halten, was sie versprechen, könnten sie nicht nur unsere Workflows optimieren, sondern auch eine unabhängigere, und vor allem datenschutzfreundlichere Alternative zu proprietären Modellen darstellen.

1.2 Getestete LLMs

In unserem Test haben wir uns die bekanntesten und erfolgreichsten Open-Source-Modelle herausgesucht. Darunter Modelle, die von großen Konzernen wie Meta oder DeepSeek AI entwickelt und trainiert wurden, sowie solche, die auf dem Big Code Models Leaderboard hoch gerankt sind.

2. Testaufbau

Der Test findet in einem realitätsnahen Angular 18-Projekt statt, das als realistische Basis für unsere Bewertung dient. Als IDE nutzen wir VS Code mit der Continue Extension, die es ermöglicht, lokal gehostete Modelle einzubinden. Die Open-Source-LLMs werden auf unserer Infrastruktur mittels Ollama bereitgestellt und in Continue integriert, um einen komfortablen Zugriff auf die Modelle aus der IDE heraus zu schaffen.

Hardware Limitierungen

Durch das Hosten auf der eigenen Infrastruktur, unterliegen wir natürlich Hardware-Limitierungen, die bspw. maximale Parameteranzahl der Modelle beschränken. Die größten, bei uns noch reibungslos lauffähigen Modelle haben 60 Milliarden Parameter. Mit größeren Modellen würde der Test hier und da sicherlich anders ausfallen.

2.1 Vorgehen

Alle Modelle erhalten dieselben acht Aufgaben mit identischen Prompts und Kontextdaten. Die Tests decken verschiedene Aspekte der Webentwicklung ab:

• App- und Routing-Struktur erklären (Code-Verständnis): Das LLM soll die Routing-Struktur erklären und den Aufbau der App beleuchten.
• API eines Services analysieren (Code-Analyse): Hier sollte erklärt werden, welche Verantwortung ein Service übernimmt und wie er in der App eingesetzt wird.
• Simples Feature hinzufügen (Code-Modifikation): Die LLMs sollen eine Artikel-Vorschau um die Informationen „Wortzahl“ und „Lesezeit“ erweitern.
• Bug beheben (Critical Thinking): Hier wurde ein Bug eingebaut, der sehr subtile Auswirkungen hat. Die LLMs sollen ihn finden und lösen.
• Refaktorierung von Initialisierungs-Observables (Refactoring): Hier wurden den Modellen mehrere Komponenten-Initialisierungslogiken präsentiert, die auf RxJS beruhen und ein gemeinsames Pattern aufweisen. Dieses Pattern soll gefunden und sauber extrahiert werden.
• Accessibility-Prüfung (A11y-Kenntnisse): Diese Aufgabe prüft das Erkennen von Accessibility-Problemen in Komponenten.
• Unit-Tests schreiben (Test-Automatisierung): Den LLMs wird eine Komponente präsentiert, für die sie Unit-Tests schreiben sollen.
• Anti-Pattern-Erkennung (Framework-spezifisches Wissen): Dieser Task prüft das Wissen rund um Best-Practices, sei es Angular-spezifisch oder allgemein zur Softwareentwicklung.

2.2 Bewertung

Die Antworten werden nach folgenden Kriterien bewertet:

• Richtigkeit: Sind die Aussagen korrekt oder irreführend?
• Vollständigkeit: Fehlen essentielle Aspekte?
• Verständlichkeit: Ist die Antwort klar und strukturiert?
• Relevanz: Trifft die Lösung den Kern der Frage?

Jeder Aspekt erhält eine Punktzahl von 1–10, aus denen der Durchschnitt als Gesamtbewertung berechnet wird.

Ergebnisse …

Der Kürze halber haben wir die genauen Aufgabenstellungen und deren Antworten der LLMs hier nicht mit aufgeführt; der Artikel zeigt lediglich die Benotung und Auswertung der Ergebnisse.

Einordnung der Bewertung

Obwohl wir uns große Mühe gegeben haben, die Bewertungen so objektiv wie möglich zu halten, ist ein gewisser Bias nicht auszuschließen. Nicht jeder wird mit allen vergebenen Punktzahlen einverstanden sein, und das ist auch legitim so. Arbeitsumgebungen und -anforderungen variieren oft stark, daher ist eine „one-size-fits-all“ Bewertung auch gar nicht möglich.

Erklärungen zu den Extrema

Um die höchst- und niedrigst-Punktzahlen besser einordnen zu können, haben wir die Extrema hier kurz beschrieben:

… Und Auswertung

Das proprietäre Modell Claude dominiert mit Ø 9,2/10 klar und übertrifft Open-Source-Modelle (Ø 5,6–6,3) in fast allen Aufgaben, besonders bei komplexem Debugging, Refactoring und Framework-Wissen. Hier eine Zusammenfassung der Ergebnistabelle:

Stärken aller LLMs:

• Code-Verständnis:
• Zusammenfassen von offensichtlichen App-Architekturen
• Zusammenfassen von Klassen-APIs
• Benutzung von Klassen und Komponenten

Durchwachsene Performance

• Unit-Test-Generierung
• Von „zu aufwändig zum Laufen zu bringen“ bis „kompiliert out-of-the-box“
• Von „relevante Sachen ausgelassen“ bis „zu viele Details getestet“
• Feature-Erweiterung
• Von „enthält absolute Beginner-Level-Fehler“ bis „einwandfrei implementiert“

Schwächen der open-source LLMs:

• Subtile Bugs finden
• der Bug wird nicht auf eine oder wenige konkrete Stellen festgelegt, sondern es werden viele Möglichkeiten „geraten“
• eine Art Checkliste wird gegeben, die nicht unbedingt was mit dem Fehler zu tun hat
• die Erklärungen zum Bug ergeben zuweilen keinen wirklichen Sinn im tatsächlichen Fehlerkontext
• Schlecht im Critical Thinking (Bugfixing, Best Practices)
• Oberflächliches Accessibility- und Angular-Wissen

Schwächen aller LLMs:

• RxJS / Observables refaktorieren
• sehr häufig werden sinnfreie Abstraktionen geschaffen
• dadurch ist auch die Benennung schlecht und wenig verständlich
• meistens kompiliert der Code nach dem Refactoring nicht mehr
• Code wird komplizierter, nicht einfacher

Fazit

Open-Source-LLMs reichen für einfache Code-Generierung aus, doch für professionelle Entwicklung sind (noch) proprietäre Modelle überlegen. Während erfahrene Entwickler von den Modellen wertvolle Denkanstöße erhalten können, besteht bei Einsteigern die Gefahr, dass sie durch falsche oder veraltete Vorschläge der LLMs fehlerhafte Konzepte übernehmen und sich dadurch ungünstige Gewohnheiten aneignen. Die Modelle haben ganz unterschiedliche Stärke- und Schwächeprofile, was zu einem breiten Spektrum von Anwendungsfeldern aber auch -grenzen führt.

Am Ende des Tages zählen die Resultate. Wer KI-Modelle effektiv einsetzt, kann sie zu einem wertvollen Werkzeug machen, um verschiedenste Aufgaben, schnell und komfortabel zu erledigen. Wir für unseren Teil bleiben gespannt, was künftige Modelle uns noch bescheren werden und experimentieren gerne mit ihnen weiter.