Künstliche Intelligenz hat längst den Weg in die Softwareentwicklung gefunden. Sie kann Code generieren, analysieren, testen, refaktorieren und dokumentieren. Doch immer wieder zeigt sich ein paradoxes Phänomen: Je komplexer der Code, desto schlechter werden die Ergebnisse.

Gerade bei großen Entscheidungsmatrizen, ineinandergeschachtelten Bedingungen und logischen Sonderfällen wirkt die KI plötzlich hilflos. Sie verliert den Überblick, verwechselt Zustände, wiederholt Fehler oder schlägt widersprüchliche Lösungen vor. Die Ursache liegt nicht in mangelnder Rechenleistung, sondern in fehlender Struktur und semantischer Orientierung.

1. Warum KI an komplexer Logik scheitert

Sprachmodelle „denken“ nicht im klassischen Sinn, sie rekonstruieren Muster aus Sprache. Ihre Stärke liegt darin, bekannte Strukturen wiederzuerkennen und fortzuführen. Wenn jedoch mehrere Logikebenen gleichzeitig ineinandergreifen – etwa bei Statusprüfungen, Berechtigungslogik oder Abrechnungsprozessen – bricht diese Fähigkeit zusammen.

Ein Beispiel:

public function evaluatePayment(array $payment): string
{
	if ($payment['method'] === 'card') {
		if ($payment['type'] === 'subscription') {
			if ($payment['invoicePaid'] === true) {
				return 'success';
			} elseif ($payment['retryCount'] < 3) {
				return 'retry';
			} else {
				return 'failed';
			}
		} elseif ($payment['type'] === 'single') {
			if ($payment['chargeSucceeded'] === true) {
				return 'success';
			} else {
				return 'failed';
			}
		}
	} elseif ($payment['method'] === 'sepa') {
		// weitere verschachtelte Bedingungen ...
	}
	return 'unknown';
}

Für einen Menschen ist dieser Code schon schwer zu lesen, für eine KI ist er nahezu undurchsichtig.
Sie sieht eine lange, unstrukturierte Abfolge von Bedingungen, aber keine erkennbaren semantischen Abschnitte, keine Beschreibung der Intention und keinen Hinweis auf Abhängigkeiten.

2. Problemzerlegung: Struktur als Denkstütze

Der erste Schritt besteht darin, das Problem zu zerlegen – so, wie man es einem neuen Entwickler erklären würde.

• Jede Klasse sollte nur eine Verantwortung haben.
• Jede Methode sollte ein klar umrissenes Ziel verfolgen.
• Namen müssen den Zweck eindeutig widerspiegeln.

Ein Refactoring könnte so aussehen:

final class PaymentDecisionService
{
	private PaymentStatusEvaluator $paymentStatusEvaluator;
	private PaymentTypeResolver $paymentTypeResolver;

	public function __construct(
		PaymentStatusEvaluator $paymentStatusEvaluator,
		PaymentTypeResolver $paymentTypeResolver
	) {
		$this->paymentStatusEvaluator = $paymentStatusEvaluator;
		$this->paymentTypeResolver = $paymentTypeResolver;
	}

	public function evaluate(array $payment): string
	{
		$type = $this->paymentTypeResolver->resolve($payment);
		return $this->paymentStatusEvaluator->evaluate($payment, $type);
	}
}

Die Logik wird dadurch nicht nur wartbarer, sondern für die KI narrativ nachvollziehbar:
Sie erkennt, dass es um zwei Teilschritte geht – Typ bestimmen und Status bewerten.

3. Dokumentation als semantischer Anker

KIs brauchen Orientierung. Eine saubere Dokumentation ist wie ein mentales Geländer.
Mit prägnanten PHPDoc-Kommentaren, klaren Typen und Beispielen kann die KI ableiten, was du von ihr erwartest.

/**
 * Bewertet den Zahlungsstatus anhand von Zahlungsdaten.
 *
 * @param array<string,mixed> $payment Strukturierte Zahlungsdaten (z. B. aus Stripe oder PayPal)
 * @param string $type Der ermittelte Typ der Zahlung (z. B. 'single', 'subscription')
 * @return string Ergebnisstatus ('success', 'failed', 'retry', 'unknown')
 *
 * Beispiel:
 * ```php
 * $result = $paymentStatusEvaluator->evaluate($payment, 'subscription');
 * // Ergebnis: 'success'
 * ```
 */
final class PaymentStatusEvaluator
{
	public function evaluate(array $payment, string $type): string
	{
		if ($type === 'subscription') {
			if ($payment['invoicePaid'] === true) {
				return 'success';
			}
			if ($payment['retryCount'] < 3) {
				return 'retry';
			}
			return 'failed';
		}

		if ($type === 'single') {
			return $payment['chargeSucceeded'] === true ? 'success' : 'failed';
		}

		return 'unknown';
	}
}

Die KI erkennt hier deutlich:

• Was die Klasse tun soll
• Welche Eingaben erwartet werden
• Welche Rückgabewerte möglich sind
• Wie ein Beispielaufruf aussieht

Dadurch kann sie bei einer späteren Anpassung den semantischen Kontext rekonstruieren – selbst wenn nur ein Ausschnitt gezeigt wird.

4. Wie man der KI „Gedächtnisstützen“ gibt

Beim Arbeiten mit großen Projekten oder APIs (z. B. Stripe, OpenAI, Symfony Services) hilft es, sogenannte Gedankenstützen einzubauen:

• Dateiüberschriften mit kurzer Beschreibung der Funktion
• Kontextbezogene Namen statt Abkürzungen (PaymentDecisionService statt PaySvc)
• Inline-Kommentare nur dort, wo der Zweck nicht sofort klar ist
• Beispiele und Tests als Erklärgrundlage

Dadurch kann die KI beim Generieren neuer Klassen Muster wiedererkennen – etwa, dass alle Services in deinem Projekt ähnlich aufgebaut sind und immer eine evaluate()-Methode mit typisiertem Rückgabewert besitzen.

5. KI-gerechtes Refactoring als Arbeitsprinzip

Das Ziel ist nicht, Code für Maschinen zu schreiben, sondern Code so zu gestalten, dass Menschen und Maschinen ihn gleichermaßen verstehen.
Wenn eine KI einen Teilbereich deines Projekts zuverlässig versteht, kannst du sie gezielt an diesem Punkt einsetzen – etwa, um neue Typen zu ergänzen, Tests zu generieren oder Validierungen zu erweitern.

So wird die KI zu einem Assistenten auf Architekturebene, nicht zu einem unberechenbaren Autovervollständiger.

Fazit

Wenn die KI bei komplexer Logik „versagt“, liegt das Problem meist im Code, nicht in der Maschine.
Ein unübersichtlicher Entscheidungsbaum, fehlende Struktur und mangelnde Dokumentation sind für Künstliche Intelligenz ebenso verwirrend wie für jeden menschlichen Entwickler.

Mit klarer Problemzerlegung, sprechenden Klassennamen und präziser Dokumentation verwandelst du chaotische Logik in verständliche Architektur.
Das Ergebnis: Die KI versteht den Kontext, bleibt konsistent – und liefert statt endloser Fehlversuche sauberen, nachvollziehbaren Code.

Oder kurz gesagt:
Nicht die KI muss schlauer werden – der Code muss klarer werden.