KI-Programmierung: Einführung und Best Practices 2026

KI-Programmierung verändert die Art und Weise, wie wir Software entwickeln, grundlegend. Tools wie GitHub Copilot, ChatGPT, Claude und Windsurf AI haben sich vom Experimentierfeld zum Standardwerkzeug in professionellen Entwicklungsteams entwickelt. Wer 2026 noch ohne KI-Unterstützung programmiert, ist nicht langsamer — er ist auch teurer und weniger wettbewerbsfähig.

Aber Vorsicht: KI-Programmierung ist kein Zaubermittel. Sie ersetzt kein Programmierwissen, sie multipliziert es. Ohne solide Basis produzierst Du mit KI schneller schlechten Code statt langsamer guten. In diesem Artikel erkläre ich Dir die Kernkonzepte, die wichtigsten Tools, Best Practices aus der Praxis und die typischen Fallstricke, die ich in über zwei Jahren KI-gestützter Entwicklung erlebt habe.

TL;DR — KI-Programmierung in 60 Sekunden

Was ist KI-Programmierung?

KI-Programmierung bezeichnet die Nutzung von Large Language Models (LLMs) und spezialisierten KI-Tools, um den Softwareentwicklungsprozess zu unterstützen. Das ist mehr als “Code generieren lassen” — es betrifft jeden Schritt des Entwicklungszyklus:

Die 6 Kernbereiche der KI-Programmierung

1. Code-Generierung Du beschreibst in natürlicher Sprache, was Du brauchst, und die KI schlägt fertigen Code vor. Das geht von einzelnen Funktionen bis zu ganzen Modulen. Beispiel: “Schreibe eine Express.js-Middleware, die Requests nach API-Key validiert und Rate-Limiting pro Key durchführt” — und Du erhältst funktionsfähigen Code inklusive Fehlerbehandlung.

2. Code-Vervollständigung (Autocomplete) Während Du tippst, schlägt die KI die nächsten Zeilen oder Blöcke vor. GitHub Copilot macht das in Echtzeit — es analysiert den Kontext Deiner offenen Dateien, erkennt Muster und schlägt den wahrscheinlichsten nächsten Code vor. Das spart bei repetitivem Code (CRUD-Endpunkte, Test-Setups, DTOs) enorm viel Zeit.

3. Refactoring und Code-Verbesserung KI kann bestehenden Code analysieren und Verbesserungen vorschlagen: Dead Code entfernen, komplexe Funktionen aufteilen, Namenskonventionen anwenden, Performance-Optimierungen identifizieren. Besonders nützlich bei Legacy-Code, den Du nicht selbst geschrieben hast.

4. Dokumentation und Kommentare Aus Code automatisch verständliche Dokumentation zu generieren ist eine der unterschätztesten KI-Fähigkeiten. Statt Stunden an JSDoc/Sphinx-Kommentaren zu verbringen, lässt Du die KI aus dem Code die Doku ableiten — inklusive Beispielen und Edge-Case-Beschreibungen.

5. Test-Generierung KI kann Unit-Tests, Integration-Tests und sogar End-to-End-Tests aus Deinem Code generieren. Sie identifiziert Edge Cases, die Du übersehen hast, und erstellt Test-Szenarien für Fehlerbedingungen, die manuell schwer zu testen sind.

6. Debugging und Fehleranalyse Fehlermeldungen in die KI werfen und Lösungsansätze bekommen. Die KI kann Stack Traces analysieren, häufige Fehlermuster erkennen und konkrete Lösungsvorschläge machen — oft schneller als eine Google-Suche.

Wie LLMs beim Programmieren funktionieren

Large Language Models wie GPT-4o, Claude 3.5 Sonnet oder Llama 3 sind darauf trainiert, den nächsten Token (Wortfragment) in einer Sequenz vorherzusagen. Beim Programmieren bedeutet das:

• Das Modell hat Milliarden von Code-Zeilen gesehen (GitHub, Stack Overflow, Dokumentationen)
• Es “versteht” Code nicht wie ein Mensch, sondern erkennt statistische Muster
• Es generiert Code, der plausibel aussieht, weil er ähnlich ist zu Code, den es oft gesehen hat
• Es kann Code nicht ausführen — es weiß nicht, ob der Code läuft

Das ist der wichtigste Unterschied: Die KI schreibt Code, den sie für wahrscheinlich hält, nicht Code, den sie für korrekt hält. Deshalb kann plausibel aussehender Code subtile Fehler enthalten, die erst bei der Ausführung auffallen.

Die wichtigsten KI-Programmier-Tools 2026

GitHub Copilot — Der IDE-Integrierte

GitHub Copilot war 2021 das erste KI-Code-Vervollständigungstool, das breite Akzeptanz fand. Es basiert auf OpenAI-Modellen und ist direkt in die IDE integriert.

Stärken:

• Tiefe IDE-Integration (VS Code, JetBrains, Neovim, Visual Studio)
• Kontextbewusste Vorschläge: Copilot sieht alle offenen Dateien und schlägt Code vor, der zum Projekt passt
• Copilot Chat: Konversationelle KI direkt in der IDE, ohne Kontextwechsel
• Multi-File-Editing: Kann Änderungen über mehrere Dateien hinweg vorschlagen
• Copilot CLI: Befehle für das Terminal natürlichsprachig beschreiben

Schwächen:

• Manchmal generische Vorschläge bei spezifischen Frameworks
• Weniger gut bei komplexer Architektur — kennt Dein Projekt nicht ganzheitlich
• Kosten: 10$/Monat (Individual), 19$/Monat (Business)

Bestes Einsatzgebiet: Tägliche Code-Vervollständigung, schnelle Funktionen, Boilerplate-Code. Wenn Du schon weißt, was Du tun willst, und nur schneller tippen willst.

ChatGPT und Claude — Die Konversationellen

ChatGPT (OpenAI) und Claude (Anthropic) sind general-purpose KI-Modelle, die auch hervorragend programmieren können. Sie laufen im Browser oder als Desktop-App.

Stärken von ChatGPT:

• Sehr schnell, gute Code-Qualität für gängige Sprachen
• Code Interpreter: Kann Python-Code tatsächlich ausführen und testen
• Custom GPTs: Eigene KI-Assistenten mit Projektkontext definieren
• Große Community und viele Tutorials

Stärken von Claude:

• Hervorragend bei langem Kontext (200K Tokens) — ganze Codebases in den Chat werfen
• Claude Artifacts: Generierten Code direkt im Browser anzeigen und testen
• Besser bei komplexem Reasoning und Architektur-Entscheidungen
• Claude Projects: Ähnlich wie Custom GPTs, aber mit besserem Kontext-Management

Schwächen (beide):

• Keine direkte IDE-Integration — Code muss manuell kopiert werden
• Kontextverlust in sehr langen Konversationen
• Kosten: 20$/Monat für Plus/Pro

Bestes Einsatzgebiet: Komplexe Probleme, Architektur-Diskussionen, Code-Review ganzer Module, Debugging von schweren Fehlern. Wenn Du Zeit hast, über die Lösung nachzudenken.

Windsurf AI und Cursor — Die KI-Native IDEs

Windsurf AI (von Codeium) und Cursor (von Anysphere) sind IDEs, die von Grund auf für KI-Programmierung gebaut wurden. Beide basieren auf VS Code, haben aber KI tief in den Workflow integriert.

Stärken von Windsurf AI:

• Cascade-Agent: Autonomer Agent, der Multi-File-Änderungen über das gesamte Projekt durchführt
• Projektweites Verständnis: Cascade liest alle relevanten Dateien, bevor es Code ändert
• Terminal-Integration: Cascade kann Befehle ausführen, Tests laufen lassen und Build-Fehler beheben
• Sehr gutes Kontext-Management: weiß, welche Dateien zusammengehören
• Supercomplete: Geht über Autocomplete hinaus und schlägt ganze Logik-Blöcke vor

Stärken von Cursor:

• Composer: Multi-File-Editor mit KI, der Änderungen über mehrere Dateien koordiniert
• Cursor Chat: Chat mit vollem Codebase-Kontext
• @-Mentions: Spezifische Dateien, Dokumentationen oder Web-Suchen im Chat referenzieren
• Große Community und viele Erweiterungen
• Modell-Auswahl: Zwischen GPT-4o, Claude 3.5 Sonnet und anderen wechseln

Schwächen (beide):

• Eigene IDE-Umgebung — man muss von VS Code migrieren (though beide sind VS Code Forks, also geringer Aufwand)
• Höhere Kosten: Windsurf 15$/Monat (Pro), Cursor 20$/Monat (Pro)
• Lernkurve für die Agenten-Features (Cascade, Composer)

Bestes Einsatzgebiet: Ganze Features implementieren, Refactoring über das gesamte Projekt, komplexe Änderungen die mehrere Dateien betreffen. Wenn Du eine Aufgabe beschreiben willst und die KI soll sie selbstständig lösen.

Vergleichstabelle

Tool	Typ	Preis/Monat	Stärke	Schwäche
GitHub Copilot	IDE-Plugin	10-19$	Schnelle Vervollständigung	Wenig Ganzheitskontext
ChatGPT Plus	Web/Desktop	20$	Schnell, Code Interpreter	Kein IDE-Integration
Claude Pro	Web/Desktop	20$	Lange Kontexte, Reasoning	Keine IDE-Integration
Windsurf AI	KI-IDE	15$	Cascade Agent, Projektverständnis	Eigene IDE
Cursor	KI-IDE	20$	Composer, @-Mentions, Modell-Wahl	Eigene IDE

Best Practices für KI-Programmierung

1. Klare und präzise Prompts — Das Fundament

Der wichtigste Faktor für gute KI-Ergebnisse ist die Qualität Deiner Prompts. Ein vager Prompt liefert vagen Code. Ein präziser Prompt liefert präzisen Code.

Schlecht:

Schreibe eine Funktion für Benutzeranmeldung

Was passiert: Die KI schreibt irgendeine Login-Funktion. Vielleicht mit MD5-Hashing (veraltet), ohne Validierung, mit fest codierten Credentials. Sie weiß nicht, was Du willst.

Gut:

Schreibe eine TypeScript-Funktion für die Benutzeranmeldung mit:
- E-Mail-Validierung (RFC-konform, max 254 Zeichen)
- Passwort-Validierung (min 8 Zeichen, 1 Groß, 1 Klein, 1 Zahl, 1 Sonderzeichen)
- JWT-Token-Generierung mit 24h Gültigkeit und Refresh-Token
- bcrypt für Passwort-Hashing (cost factor 12)
- Fehlerbehandlung mit aussagekräftigen Fehlermeldungen (deutsch)
- TypeScript-Typen für Input und Output
- Logging bei fehlgeschlagenen Versuchen
- Rate-Limiting: max 5 Versuche pro E-Mail in 15 Minuten

Was passiert: Die KI schreibt eine produktionsnahe Funktion mit allen Anforderungen. Du musst nur noch Edge Cases prüfen und an Deine Datenbank anpassen.

Die 5 Elemente eines perfekten Prompts:

1. Rolle: “Du bist ein Senior Backend-Entwickler mit 10 Jahren Erfahrung in TypeScript”
2. Kontext: “Ich arbeite an einer Express.js-API mit PostgreSQL und Prisma ORM”
3. Aufgabe: “Schreibe einen Endpunkt für die Benutzerregistrierung”
4. Anforderungen: Liste mit konkreten, messbaren Kriterien
5. Format: “Gib mir nur die Funktion mit Typen, keine Erklärung”

2. Kontext geben — Die KI ist nicht hellseherisch

KI-Modelle arbeiten dramatisch besser, wenn sie den Kontext verstehen. Das ist der häufigste Anfängerfehler: Die KI wird wie eine Suchmaschine benutzt, statt wie ein Teammitglied, das eingearbeitet werden muss.

Welchen Kontext geben:

• Projektbeschreibung: “Ich baue eine E-Commerce-Plattform mit Next.js 14, Prisma und PostgreSQL”
• Architektur: “Wir verwenden Clean Architecture mit Use Cases, Repositories und DTOs”
• Verwendete Bibliotheken: “Wir nutzen Zod für Validierung, Winston für Logging, Bull für Queues”
• Coding-Standards: “Wir verwenden Functional Programming, keine Klassen. Arrow Functions nur für Callbacks”
• Bestehender Code: Zeige der KI ähnliche Funktionen aus dem Projekt als Referenz

Beispiel aus der Praxis:

Ich wollte eine WebSocket-Verbindung in einer NestJS-Anwendung implementieren. Der erste Prompt war: “Schreibe einen WebSocket-Gateway in NestJS”. Die KI lieferte einen funktionsfähigen Gateway, aber mit Socket.IO — wir nutzten aber native WebSockets. Nach dem Kontext “Wir nutzen native WebSockets, nicht Socket.IO. Verwende @WebSocketGateway und @WebSocketServer aus @nestjs/websockets” lieferte die KI genau das richtige.

3. Iterativ arbeiten — Rom wurde auch nicht an einem Prompt gebaut

Verwende KI nicht als One-Shot-Lösung. Der beste Workflow ist iterativ:

Schritt 1: Grober Entwurf

Schreibe einen Express.js-Endpunkt für Datei-Uploads mit Multer

Schritt 2: Verfeinerung

Ergänze: Dateigrößen-Limit von 5MB, nur PDF und JPEG erlauben,
Fehlerbehandlung für Multer-Errors

Schritt 3: Edge Cases

Was passiert bei zu großen Dateien? Bei falschem MIME-Type?
Bei Netzwerkabbruch während des Uploads? Füge diese Fälle hinzu.

Schritt 4: Tests

Schreibe Jest-Tests für diesen Endpunkt. Decke alle Edge Cases ab.

Schritt 5: Dokumentation

Schreibe JSDoc-Kommentare und ein kurzes README für diesen Endpunkt.

Dieser Workflow dauert 15 Minuten und liefert produktionsreifen Code. Ohne KI würdest Du 2-3 Stunden brauchen.

4. Code IMMER verstehen — Der goldene Regel

NIEMALS Code verwenden, den Du nicht verstehst. Die KI ist ein Assistent, kein Ersatz für Dein Wissen. Wenn Du Code nicht verstehst, kannst Du:

• Bugs nicht finden, wenn etwas schiefgeht
• Den Code nicht an neue Anforderungen anpassen
• Sicherheitslücken übersehen
• Im Code-Review keine Fragen beantworten

Praxis-Tipp: Lass Dir den Code erklären, bevor Du ihn übernimmst:

Erkläre mir Zeile für Zeile, was diese Funktion macht.
Warum hast du bcrypt mit cost factor 12 gewählt?
Was passiert, wenn die Datenbankverbindung abbricht?
Gibt es eine einfachere Lösung?

Wenn die KI Dir den Code nicht überzeugend erklären kann, ist der Code wahrscheinlich nicht gut.

5. Sicherheit und Datenschutz — Nicht optional

KI-Tools senden Deine Prompts an Server. Das hat Sicherheitsimplikationen:

Was NIEMALS in Prompts gehören:

• API-Keys, Secrets, Passwörter, Tokens
• Personenbezogene Daten (DSGVO-relevant)
• Proprietärer Code, den das Unternehmen nicht freigegeben hat
• Kundendaten oder Produktionsdaten

Was Du tun solltest:

• Unternehmensrichtlinien für KI-Nutzung kennen und befolgen
• Generierten Code auf Sicherheitslücken prüfen (SQL-Injection, XSS, CSRF)
• Open-Source-Lizenzen bei generiertem Code beachten — KI kann GPL-Code vorschlagen
• Code-Reviews auch bei KI-generiertem Code durchführen
• Bei sensiblen Projekten: lokale Modelle (Ollama, llama.cpp) verwenden

Prompt Engineering für Entwickler — Fortgeschrittene Techniken

Chain of Thought (CoT)

Lass die KI Schritt für Schritt denken, bevor sie Code schreibt. Das verbessert die Qualität bei komplexen Problemen dramatisch.

Denke Schritt für Schritt:
1. Welche Datenstrukturen brauche ich?
2. Welche Edge Cases gibt es?
3. Welche Fehler können auftreten?
4. Wie sieht die optimale Lösung aus?

Schreibe dann erst den Code.

Few-Shot Prompting

Gib der KI Beispiele im Prompt, damit sie das Muster versteht:

Hier sind Beispiele für unsere Service-Klassen:

Beispiel 1 (UserService):
[Code-Beispiel]

Beispiel 2 (ProductService):
[Code-Beispiel]

Schreibe jetzt einen OrderService im gleichen Stil.

Constraint Prompting

Setze explizite Einschränkungen, um die KI in die richtige Richtung zu lenken:

Schreibe diese Funktion mit folgenden Constraints:
- Maximal 30 Zeilen
- Keine externen Abhängigkeiten außer lodash
- Keine Klassen, nur Functions
- Alle Parameter als const deklarieren
- Kein any in TypeScript

Negative Prompting

Sag der KI explizit, was sie NICHT tun soll:

Schreibe eine REST-API für Benutzer:
- Verwende NICHT Express (wir nutzen Fastify)
- Verwende NICHT Mongoose (wir nutzen Prisma)
- Keine Klassen, nur Functions
- Kein console.log, verwende pino

Häufige Fallstricke — Und wie Du sie vermeidest

1. Halluzinationen — Die KI erfindet APIs

KI-Modelle können APIs, Funktionen oder Bibliotheken erfinden, die nicht existieren. Das ist das häufigste und gefährlichste Problem.

Beispiel: Die KI schlägt import { validateEmail } from 'validator-utils' vor. Das Paket existiert nicht. Wenn Du es installierst, könnte es Malware sein (Typosquatting).

Lösung:

• Jeden Import und jede API gegen die offizielle Dokumentation prüfen
• NPM-Pakete vor Installation verifizieren (Downloads, Maintainer, Last Update)
• npm install --dry-run verwenden, um zu sehen was installiert wird
• Bei unbekannten APIs: “Existiert diese API wirklich? Zeige mir die Dokumentation.”

2. Übermäßige Komplexität — Over-Engineering

KI neigt dazu, komplexeren Code zu generieren als nötig. Sie kennt das YAGNI-Prinzip (You Ain’t Gonna Need It) nicht instinktiv.

Beispiel: Du fragst nach einer einfachen Funktion zum Parsen von CSV-Dateien. Die KI schlägt eine generische CSV-Parser-Klasse mit Strategy-Pattern, Factory und Builder vor.

Lösung:

• Explizit um einfachen Code bitten: “Schreibe die einfachste Lösung, die funktioniert. Kein Over-Engineering.”
• “Refactor this to be simpler” als Follow-up verwenden
• YAGNI im Prompt erwähnen: “Keine Features, die ich nicht explizit angefragt habe”

3. Kontextverlust — Die KI vergisst

In langen Konversationen (50+ Nachrichten) verliert die KI den Kontext. Sie “vergisst” frühere Anforderungen oder widerspricht sich selbst.

Lösung:

• Neue Konversation für neue Themen starten
• Wichtige Anforderungen in jedem Prompt wiederholen
• Bei ChatGPT: Custom GPT mit festen Projekt-Instructions verwenden
• Bei Claude: Projects mit persistentem Kontext nutzen
• Bei Cursor/Windsurf: @-Mentions für Dateien, die relevant sind

4. Sicherheitslücken — Die KI kennt Dein Threat Model nicht

KI-generierter Code enthält häufig Sicherheitslücken, weil die KI nicht Dein spezifisches Threat Model kennt.

Häufige Probleme:

• SQL-Injection (KI nutzt String-Concat statt Parameterized Queries)
• XSS (KI nutzt innerHTML statt textContent)
• Hardcoded Secrets (KI schreibt API-Keys direkt in den Code)
• Fehlende Input-Validierung (KI vertraut User-Input)

Lösung:

• Im Prompt Sicherheitsanforderungen explizit nennen
• Generierten Code mit SAST-Tools (ESLint security rules, Semgrep) prüfen
• Code-Review mit Security-Fokus durchführen
• “Prüfe diesen Code auf Sicherheitslücken” als Follow-up

5. Copyright- und Lizenzfragen

KI-Modelle wurden auf Open-Source-Code trainiert. Manchmal generieren sie Code, der 1:1 aus einem GPL-lizenzierten Projekt stammt.

Lösung:

• Bei langen Code-Blöcken: Originalität prüfen (Google-Suche)
• Unternehmensrichtlinien zu KI-generiertem Code kennen
• Bei kritischen Projekten: Legal Team involvieren
• Copilot hat einen “Duplicate Detection” Filter, der exakte OSS-Matches blockiert

Der optimale KI-Programmier-Workflow

Hier ist der Workflow, den ich täglich nutze und der sich in der Praxis bewährt hat:

Phase 1: Planung (5 Min)

1. Aufgabe in natürlicher Sprache beschreiben
2. Der KI einen Plan erstellen lassen: “Erstelle einen Plan für diese Funktion, noch kein Code”
3. Plan prüfen und anpassen

Phase 2: Implementierung (15-30 Min)

4. Plan Schritt für Schritt umsetzen, je ein Schritt pro Prompt
5. Nach jedem Schritt: Code lesen, verstehen, testen
6. Bei Fehlern: Fehlermeldung + Kontext an die KI

Phase 3: Qualitätssicherung (10 Min)

7. “Schreibe Tests für diesen Code”
8. “Prüfe diesen Code auf Edge Cases und Sicherheitslücken”
9. “Refactore diesen Code für bessere Lesbarkeit”

Phase 4: Integration (5 Min)

10. Code ins Projekt integrieren
11. Build und Tests laufen lassen
12. Bei Build-Fehlern: Fehler + Code an die KI

Gesamt: 35-50 Min für eine Funktion, die manuell 2-3 Stunden dauern würde.

Kosten-Optimierung

KI-Programmierung kostet Geld. Hier sind Tipps, um die Kosten im Griff zu behalten:

• Modell-Wahl: Nicht jede Aufgabe braucht GPT-4o. Einfache Tasks mit GPT-4o-mini oder Claude Haiku erledigen (10x günstiger)
• Caching: Gleiche Prompts nicht wiederholen. Bessere Ergebnisse in einer Konversation speichern
• Token-Bewusstsein: Lange Dateien nur anhängen, wenn nötig. @-Mentions für spezifische Dateien statt ganze Codebase
• Batch-Processing: Mehrere kleine Aufgaben in einem Prompt statt viele einzelne Prompts
• Lokale Modelle: Für einfache Autocomplete-Aufgaben: Codeium (kostenlos) oder Continue.dev mit Ollama

Prüfungsrelevante Punkte

• Definition: KI-Programmierung = Nutzung von LLMs zur Unterstützung des gesamten Softwareentwicklungsprozesses
• 6 Kernbereiche: Code-Generierung, Vervollständigung, Refactoring, Dokumentation, Tests, Debugging
• Tool-Kategorien: IDE-Plugins (Copilot), Konversationell (ChatGPT/Claude), KI-Native IDEs (Windsurf/Cursor)
• 5 Prompt-Elemente: Rolle, Kontext, Aufgabe, Anforderungen, Format
• Best Practices: Klare Prompts, Kontext geben, iterativ arbeiten, Code verstehen, Sicherheit wahren
• Risiken: Halluzinationen, Over-Engineering, Kontextverlust, Sicherheitslücken, Lizenzfragen
• Fortgeschrittene Techniken: Chain of Thought, Few-Shot, Constraint Prompting, Negative Prompting
• Workflow: Planen → Implementieren → QS → Integrieren

FAQ

Ist KI-Programmierung ein Ersatz für Programmierkenntnisse? Nein, absolut nicht. KI ist ein Werkzeug, das Programmierkenntnisse voraussetzt. Ohne Basiswissen kannst Du KI-Ausgaben nicht validieren, keine Bugs finden und keinen Code-Review durchführen. Die KI macht einen guten Entwickler schneller, aber sie macht keinen Anfänger zum Experten.

Welches Tool ist am besten für Anfänger? GitHub Copilot ist am einfachsten, da es direkt in der IDE funktioniert und man den Workflow nicht ändern muss. ChatGPT ist gut für Lernzwecke, weil es Dinge ausführlich erklären kann. Windsurf oder Cursor sind besser, wenn man bereit ist, eine neue IDE zu lernen.

Darf ich KI-generierten Code kommerziell nutzen? Ja, grundsätzlich schon. GitHub Copilot hat einen Duplicate Detection Filter, der OSS-Code blockiert. Aber Du solltest Unternehmensrichtlinien beachten, den Code auf Lizenzen prüfen und bei kritischen Projekten das Legal Team involvieren.

Wie vermeide ich, dass die KI schlechten Code produziert? Drei Dinge: 1) Präzise Prompts mit klaren Anforderungen. 2) Code immer lesen und verstehen. 3) Tests schreiben und Code-Reviews durchführen. Die KI ist ein Werkzeug, kein Autopilot.

Was mache ich, wenn die KI halluziniert? Stoppe, prüfe jeden Import und jede API gegen die offizielle Dokumentation. Wenn etwas nicht existiert, frage die KI explizit: “Existiert diese API? Zeige mir die offizielle Dokumentation.” Wenn sie zögert oder unsicher ist, ist es wahrscheinlich eine Halluzination.

Sollte ich KI für Tests nutzen? Ja, unbedingt. KI ist hervorragend für Test-Generierung, besonders für Edge Cases, die man leicht übersieht. Aber: Die Tests müssen selbst getestet werden — ein Test, der immer grün ist, ist wertlos.

Empfohlene Literatur