KI-Coding im Kundenprojekt 2026: Welche Aufgaben Agenturen sinnvoll an AI-Agents delegieren

KI-Coding 2026 im Kundenprojekt: Warum das Thema für Agenturen jetzt relevant ist

2026 ist KI im Entwicklungsalltag nicht mehr die Frage nach dem "Ob", sondern nach dem "Wie kontrolliert". Agenturen stehen dabei unter einem besonderen Druck: Sie müssen Lieferfähigkeit, Qualität und Nachvollziehbarkeit gegenüber Kunden garantieren. Gleichzeitig wachsen Codebasen (Monorepos, Headless-Setups, Microservices), Release-Zyklen werden kürzer, und Plattformen wie TYPO3 oder Shopware bringen regelmäßig Major-Upgrades mit echten Migrationskosten.

AI-Agents wie Claude Code, GitHub Copilot CLI oder vergleichbare Tools können heute (bei guter Einbettung) messbar Zeit sparen. Der Hebel entsteht aber nicht durch "KI schreibt Code", sondern durch delegierbare Teilaufgaben: Analyse, Vorbereitung, Vorschläge, Generierung von repetitivem Code, Dokumentation und Automationsbausteine. Der entscheidende Punkt für Kundenprojekte: Verantwortung bleibt beim Team. Die KI ist ein Werkzeug, kein Lieferant.

Dieser Artikel ist als Entscheidungshilfe gedacht: Welche Aufgaben lassen sich 2026 realistisch delegieren, wo sind die Grenzen, und wie startet man mit einem Pilot-Workflow, ohne die Kontrolle zu verlieren.

Welche Aufgaben heute realistisch delegierbar sind (und wie man sie sauber einbettet)

Die folgenden Einsatzfelder funktionieren in der Praxis besonders gut, wenn Sie drei Leitplanken setzen: (1) klarer Kontext (Repo-Struktur, Coding-Standards, Zielversionen), (2) kleine, überprüfbare Arbeitspakete, (3) maschinell prüfbare Akzeptanzkriterien (Tests, Linter, Build, Security-Checks).

1) Code-Analyse in großen Repositories (Orientierung, Impact, Abhängigkeiten)

In großen TYPO3- oder Shopware-Projekten ist "Verstehen" oft der teuerste Teil. AI-Agents sind hier stark, wenn es um strukturierte Bestandsaufnahme geht:

• Hotspots finden: Welche Module sind am häufigsten betroffen? Wo sind zyklische Abhängigkeiten? Welche Klassen sind überladen?
• Impact-Analyse: "Wenn wir Checkout X ändern, welche Services/Events/Templates sind betroffen?"
• Konventions-Check: Abweichungen von Team-Standards (Namensgebung, Layering, Ordnerstruktur) sammeln.

Wichtig: Lassen Sie die KI nicht "raten", sondern geben Sie ihr konkrete Fragen und verlangen Sie konkrete Fundstellen (Dateipfade, Funktionsnamen, Zeilenausschnitte). In Reviews gilt: Aussagen ohne Referenz sind wertlos.

2) Refactoring-Vorbereitung (nicht das Refactoring selbst)

Refactoring ist riskant, weil es semantische Änderungen einschleusen kann. Delegierbar ist aber die Vorbereitung:

• Refactoring-Plan als Checkliste: Schritte, betroffene Dateien, erwartete Seiteneffekte.
• Extraktion von Duplikaten: Kandidatenlisten für gemeinsame Helper/Services.
• "Before/After"-Skizzen: Vorschlag für neue Schnittstellen, ohne sie direkt umzusetzen.

Praxisregel: Die KI darf Vorschläge machen, aber das Team entscheidet über Zielbild und Reihenfolge. Umsetzung nur in kleinen PRs mit Tests.

3) Test-Erstellung (Unit/Integration) als Beschleuniger

Hier liegt einer der größten realen Produktivitätsgewinne: AI-Agents können Testgerüste, Datenprovider, Mock-Setups und Randfalllisten erzeugen. Besonders gut funktioniert:

• Unit-Tests für pure Funktionen/Services: klarer Input/Output, wenig I/O.
• Regression-Tests für gefixte Bugs: "Schreibe einen Test, der den Bug reproduziert und nach Fix grün ist."
• API-Contract-Checks: Schema-Validierung, Statuscodes, Fehlerfälle.

Grenze: Tests, die fachliche Wahrheit behaupten, müssen vom Team validiert werden. Die KI kann plausible Fälle erfinden, die am echten Prozess vorbeigehen. Daher: Testnamen und Assertions immer fachlich gegenlesen.

4) Boilerplate-Code und wiederholbare Patterns

Boilerplate ist ideal für Delegation, weil die Anforderungen meist eindeutig sind. Beispiele aus Agenturalltag:

• CRUD-Scaffolding: DTOs, Mapper, Controller/Routes, Form-Handling.
• Event-Subscriber/Listener: Standard-Pattern in Shopware oder Symfony-basierten Projekten.
• TYPO3-Konfiguration: wiederkehrende Strukturen, z.B. TCA-Arrays oder einfache Extbase-Patterns (mit Vorsicht bei Projektkonventionen).

Wichtig ist, dass Sie dem Agent klare Projektstandards geben (PSR, Architekturregeln, Naming, Ordnerstruktur). Ohne diese Leitplanken entsteht "fast richtig"-Code, der später teuer wird.

5) Doku und PR-Zusammenfassungen (mit Fokus auf Nachvollziehbarkeit)

Viele Teams scheitern nicht am Coding, sondern an fehlender Dokumentation und Review-Zeit. Delegierbar sind:

• PR-Summaries: Was wurde geändert, warum, welche Risiken, wie testen?
• Changelog-Entwürfe: Nutzerrelevante Änderungen aus Commits/PRs extrahieren.
• Runbooks: "Wie deployen wir?", "Wie rollt man zurück?", "Welche Feature-Flags gibt es?"

Praxisregel: Doku aus Code ableiten lassen, aber vom Team finalisieren. Kunden lesen Doku als Vertrag; Ungenauigkeiten sind politisch teuer.

6) Upgrade-Unterstützung bei TYPO3 oder Shopware (Analyse, To-do-Listen, mechanische Anpassungen)

Upgrades sind ein typischer Agentur-Schmerzpunkt: viele kleine Änderungen, Deprecations, API-Shifts. AI-Agents helfen besonders bei:

• Deprecation-Scanning: Fundstellen sammeln, priorisieren, Vorschläge für Ersatz-APIs.
• Composer/Dependency-Impact: Konflikte erklären, Upgrade-Pfade skizzieren.
• Mechanische Codeanpassungen: Umbenennungen, Signaturen, Konfig-Keys (immer mit Tests/Build absichern).

Grenze: Die KI kann nicht wissen, welche Erweiterungen/Plugins im Kundenkontext wirklich kritisch sind oder welche Workarounds historisch eingebaut wurden. Daher: Upgrade immer mit Staging, Datenkopie, Smoke-Tests und klarer Rollback-Strategie.

7) Automatisierung in CI/CD-nahen Workflows (Checks, Reports, Assistenz)

AI-Agents können CI/CD nicht "magisch" machen, aber sie können helfen, wiederkehrende Aufgaben zu standardisieren:

• Build-Fehler erklären: Log-Auswertung, Hypothesen, nächste Schritte.
• Release-Checklisten generieren: aus Repo-Konventionen und letzten Changes.
• Automatisierte Review-Hinweise: "Welche Dateien sind sicherheitsrelevant?", "Wo fehlen Tests?"

Wichtig: CI/CD bleibt deterministisch. KI darf Vorschläge liefern, aber die Pipeline muss ohne KI reproduzierbar laufen.

Konkrete Mini-Workflows (mit Commands) für den Agenturalltag

Die folgenden Beispiele sind bewusst simpel gehalten und passen in fast jedes Projekt. Sie dienen als Startpunkt für einen kontrollierten Pilot.

Workflow A: Agent erstellt PR-Zusammenfassung aus Git-Historie

git diff --name-only origin/main...HEAD

git log --oneline origin/main..HEAD

Geben Sie diese Outputs dem Agent und verlangen Sie eine Zusammenfassung mit: Änderungsbereiche, Risiken, Testhinweise, Rollback-Hinweis. Ergebnis wird vom Reviewer gegengezeichnet.

Workflow B: Upgrade-Vorbereitung (Dependencies sichtbar machen)

composer outdated

composer why-not shopware/core 6.6.0

Der Agent kann daraus eine priorisierte To-do-Liste erstellen: Blocker, kompatible Versionen, betroffene Pakete, Vorschlag für Upgrade-Reihenfolge. Das Team entscheidet final und führt die Änderungen in kleinen Schritten aus.

Welche Aufgaben besser beim Team bleiben (menschliche Verantwortung ist nicht delegierbar)

In Kundenprojekten gibt es Bereiche, in denen "fast richtig" nicht reicht. Hier sollte die KI höchstens assistieren (Ideen, Alternativen, Checklisten), aber nicht autonom entscheiden oder implementieren.

1) Architekturentscheidungen und Systemdesign

Schichten, Boundaries, Datenflußse, Integrationsmuster, Caching-Strategien, Mandantenfähigkeit, Observability: Das sind Entscheidungen mit Langzeitkosten. AI-Agents können Optionen auflisten, aber sie kennen Ihre Teamfähigkeiten, Betriebsrealität und Kundenpolitik nicht. Architektur ist Verantwortung, nicht Output.

2) Fachliche Logik und Prozesswahrheit

Checkout-Regeln, Preislogik, Rechtekonzepte, Content-Freigaben in TYPO3, kundenspezifische Workflows: Die KI kann Anforderungen missverstehen oder implizite Regeln übersehen. Fachliche Logik muss vom Team (idealerweise mit Product Owner/Stakeholder) validiert werden. KI-Generated Tests können hier sogar gefährlich sein, wenn sie falsche Annahmen "zementieren".

3) Sicherheitskritisches und Compliance

AuthN/AuthZ, Payment, PII, Session-Handling, Kryptografie, Secret-Management, DSGVO-relevante Datenflüsse: Hier gilt "Trust, but verify" nicht mehr, sondern "Verify, then trust". Nutzen Sie KI für Checklisten und Code-Scanning-Hinweise, aber lassen Sie Security-Entscheidungen, Threat Modeling und Freigaben beim Team.

4) Unklare Anforderungen und Konflikte im Kundenkontext

Wenn Anforderungen unvollständig oder widersprüchlich sind, produziert die KI schnell scheinbar plausible Lösungen. Das ist gefährlich, weil es Unsicherheit versteckt statt sichtbar zu machen. In solchen Situationen ist die beste "KI-Nutzung" oft: offene Fragen formulieren, Annahmen explizit machen, Akzeptanzkriterien vorschlagen. Die Klärung bleibt menschliche Arbeit.

5) Legacy-Risiken und "historische Sonderfälle"

Viele Agenturprojekte enthalten Workarounds, die niemand mehr dokumentiert hat: alte Importjobs, Cron-Skripte, Sonderpreise, kundenspezifische Deploy-Hacks. AI-Agents können diese Stellen finden helfen, aber nicht bewerten, warum sie existieren. Jede Änderung in Legacy-Bereichen braucht konservative Strategie: kleine Schritte, Monitoring, Rollback, und im Zweifel ein Feature-Flag.

6) Abnahme, Kommunikation und Haftung

Die Abnahme ist kein technischer Akt, sondern ein Vertragsmoment. Formulierungen, Nachweise, Testprotokolle, Scope-Abgrenzung: Das muss das Team verantworten. KI kann Texte vorschlagen, aber nicht die Verantwortung tragen.

Woran man einen sinnvollen ersten Pilot-Workflow erkennt (Schritt für Schritt)

Ein guter Pilot ist klein, messbar und reversibel. Er reduziert Risiko, statt es zu verlagern.

Schritt 1: Wählen Sie einen Prozess mit klaren Inputs/Outputs

• Gute Kandidaten: PR-Zusammenfassungen, Testgerüste für bestehende Services, Deprecation-Listen für Upgrades, Doku-Entwürfe.
• Schlechte Kandidaten: "Bau mal die neue Checkout-Logik", "Mach das Deployment sicher", "Refactor das ganze Modul".

Schritt 2: Definieren Sie Akzeptanzkriterien, die maschinell prüfbar sind

• Build muss grün sein (CI).
• Tests müssen laufen und neue Tests müssen sinnvoll benannt sein.
• Linter/Formatter ohne neue Warnungen.
• Keine Änderungen an sicherheitskritischen Dateien ohne explizite Freigabe.

Schritt 3: Legen Sie "Guardrails" fest (Policy für Agentenarbeit)

• Scope: Welche Ordner/Module darf der Agent bearbeiten?
• Verbote: Keine Änderungen an Auth, Payment, Deployment-Skripten ohne Senior-Review.
• Nachweispflicht: Jede Aussage muss Fundstellen enthalten (Datei/Zeile oder Command-Output).
• Transparenz: Agent muss Annahmen explizit markieren.

Schritt 4: Starten Sie mit "Assist" statt "Autopilot"

In der Praxis hat sich ein Reifegradmodell bewährt:

• Assist: Agent liefert Analyse, Checklisten, Vorschläge. Mensch implementiert.
• Co-Implement: Agent schreibt Code in kleinen PRs, Mensch reviewed streng.
• Teilautonom: Agent darf definierte, risikoarme Änderungen selbst erstellen (z.B. Doku, PR-Text, Testgerüste), aber nie ohne Review mergen.

Schritt 5: Messen Sie Wirkung und Nebenwirkungen

• Durchlaufzeit pro PR (Lead Time).
• Review-Zeit (steigt sie, weil Code schlechter ist?).
• Defect-Rate nach Release.
• Wiederholbarkeit: Funktioniert der Workflow bei 3 verschiedenen Tickets?

Wenn Review-Zeit explodiert oder Bugs steigen, war der Pilot zu groß oder die Guardrails zu weich.

Fazit: Pragmatismus statt Hype

AI-Agents sind 2026 im Kundenprojekt dann sinnvoll, wenn sie das Team bei klar abgrenzbaren, prüfbaren Aufgaben entlasten: Analyse großer Repos, Refactoring-Vorbereitung, Testgerüste, Boilerplate, Doku, PR-Zusammenfassungen, Upgrade-To-do-Listen und CI/CD-nahe Assistenz. Der produktive Nutzen entsteht durch Standardisierung und bessere Vorbereitung, nicht durch "KI ersetzt Entwickler".

Gleichzeitig bleiben Architektur, fachliche Wahrheit, Security, Legacy-Risikoabwägung und Abnahme unverhandelbar menschliche Verantwortung. Wer das sauber trennt, kann KI kontrolliert integrieren: weniger Stress in Upgrades, schnellere Reviews, bessere Doku und mehr Zeit für die wirklich teuren Entscheidungen im Projekt.