Pillar Page

KI-Softwareentwicklung

Ein bewährter Prozess zur Automatisierung der Softwareentwicklung mit einem Team aus KI-Agenten — von der Anforderungsanalyse über Coding und mehrschichtiges Testing (Unit, Integration, E2E, Security, Performance) bis zum Produktivdeployment mit vollständigem Audit-Trail.

Lassen Sie uns über ein Pilotprojekt sprechen Unsere Leistungen

Wir betreiben ein Team spezialisierter KI-Agenten, das an jeder Phase des Softwareentwicklungszyklus beteiligt ist — von der Anforderungsanalyse über das Architekturdesign, Coding und mehrschichtiges Testing bis hin zu Code Review, Dokumentation und Deployment mit vollständigem Audit-Trail.

So entwickeln wir unsere eigenen ESKOM AI Produkte — die Multi-Agenten-Plattform HybridCrew, das Compliance-Auditsystem, den KRS+CRBR-Microservice und ein Portfolio an Integrationen. Denselben Prozess wenden wir in Kundenprojekten an: sowohl bei der Entwicklung neuer Microservices als auch bei der Modernisierung von Legacy-Systemen.

Dieser Artikel beschreibt, wie das in der Praxis funktioniert: welche Aufgaben die Agenten übernehmen, welche bei den Menschen verbleiben, welche Tests wir ausführen und warum dieser Prozess über verschiedene Projekttypen hinweg wiederholbar ist.

Warum die Softwareentwicklung automatisieren?

Ein klassischer Softwareentwicklungszyklus (Analyse → Code → Tests → Review → Deploy) dauert in einem reifen Team typischerweise 2-4 Wochen für ein mittelgroßes Feature. Den größten Teil dieser Zeit beanspruchen sich wiederholende Aufgaben: Boilerplate schreiben, Unit-Tests generieren, Änderungen prüfen, Dokumentation aktualisieren, Datenbankmigrationen erzeugen. All das ist automatisierungsfreundlich.

Das Ziel unseres Prozesses ist einfach: zwei bis drei Personen mit KI-Agenten liefern den Wert eines 8-10-köpfigen Teams — ohne Burnout, mit höherer Qualität (mehr Tests, besseres Code Review, vollständige Dokumentation) und kürzerer Time-to-Market.

Das ist nicht „KI ersetzt Entwickler". Es ist „Entwickler mit KI ersetzen Entwickler ohne KI". Erfahrene Ingenieure bleiben unverzichtbar — sie entwerfen die Architektur, treffen strategische Entscheidungen und prüfen komplexe Änderungen. Die KI-Agenten übernehmen die Routine.

Der sechsstufige Prozess

Die Pipeline von den Anforderungen bis in die Produktion. Jede Stufe wird von spezialisierten KI-Agenten ausgeführt, während Menschen überwachen und Schlüsselentscheidungen freigeben.

Anforderungsanalyse und Architektur

KI-Agenten analysieren die Businessdokumentation, Kundengespräche (aus Transkripten) und bestehenden Code. Sie schlagen eine Microservice-Architektur, ein Datenbankschema, eine Endpoint-Liste und ein Berechtigungsmodell vor. Ein Mensch (CTO/Architekt) prüft und genehmigt den Vorschlag, bevor das Coding beginnt.

Coding (TDD)

Zuerst die Tests, dann die Implementierung. Ein Backend-Agent schreibt APIs in FastAPI/Express, ein Frontend-Agent schreibt React-Komponenten. Jede Änderung ist ein separater Pull Request mit sauberer Commit-Message. Coding-Standards (Black, ESLint, Prettier) werden automatisch durchgesetzt.

Mehrschichtiges Testing

Unit (pytest, Jest), Integration (testcontainers mit echtem PostgreSQL), E2E (Playwright), UI-Snapshot, Security (OWASP, gitleaks, bandit), Performance (k6/locust), Accessibility (axe). Jeder PR durchläuft die vollständige Pipeline — ein fehlschlagender Test blockiert den Merge.

Code Review durch KI

Der SecurityReviewer-Agent scannt nach OWASP Top 10, der QualityReviewer-Agent prüft Lesbarkeit und Patterns, der ArchitectureReviewer-Agent verifiziert die Konsistenz mit dem Rest des Systems. Grenzfälle werden an Menschen eskaliert.

Dokumentation und CHANGELOG

Jede Logikänderung = Versionssprung + Eintrag in CHANGELOG.md im Keep-a-Changelog-Format. API-Dokumentation (OpenAPI/Swagger) wird automatisch generiert. CLAUDE.md wird nach jeder Sitzung mit neuen Lessons Learned aktualisiert.

Deployment mit Change Request

Deployment läuft immer über Git (NIEMALS direkter scp). Zunächst die Testumgebung mit Playwright-Verifikation, erst dann die Produktion nach CR-Freigabe. Das Deploy-Skript enthält einen Rollback-Plan (<5 Min.) und Health Checks.

Was gewinnt das Unternehmen?

Tausende automatisierte Tests

Jedes Produktivprojekt hat von mehreren tausend bis hin zu zehntausenden Tests — Unit, Integration, E2E, Security, Performance. Regressionen werden in CI erkannt, bevor sie Nutzer erreichen.

Vollständiger Audit-Trail

Jede Änderung an Code, Datenbank oder Konfiguration wird protokolliert: Git, Audit-Log in der Datenbank, CHANGELOG, Change Request. Erfüllt die Anforderungen von ISO 27001, EU AI Act und DSGVO.

Skalierbarkeit des Teams

Zwei bis drei Personen mit KI-Agenten liefern den Wert eines 8-10-köpfigen Teams. Ohne Burnout, mit höherer Qualität und kürzeren Timelines.

Eskalation zu stärkeren Modellen

LLM-Routing wählt das passende Modell für jede Aufgabe: kleine Änderungen — lokales Ollama (null Kosten), komplexe Architektur — Claude Opus. Kosten- und Qualitätsoptimierung in einem.

Wiederholbarkeit und Standards

Jedes Projekt folgt denselben Standards: Feature-Branch-Workflow, Squash-Merge, Conventional Commits, CHANGELOG, EU AI Act, DSGVO. Ein neuer Entwickler versteht die Struktur am ersten Tag.

Security by Default

Gitleaks im Pre-Commit + CI, Secrets im HashiCorp Vault, private Repositories, Keycloak SSO, Tailscale VPN für interne Services. Keine Kompromisse zugunsten der Geschwindigkeit.

Mehrschichtiges Testing — das Fundament der Qualität

Jede Änderung am Produktivcode durchläuft eine vollständige Testpipeline. Ohne Ausnahmen — selbst eine Tippfehlerkorrektur in einem Kommentar löst CI aus, denn die Testpipeline ist über einen Git-Hook erzwungen, nicht über die politische Entscheidung eines Entwicklers.

Unit-Tests: pytest, Jest, vitest. Decken einzelne Funktionen und Klassen ab. >80% Coverage bei kritischem Code.
Integrationstests: testcontainers mit echten Instanzen von PostgreSQL, Redis, Vault. Mocks ausschließlich für externe Third-Party-APIs.
End-to-End-Tests (E2E): Playwright in Firefox (Standard), Chrome (optional). Simulieren vollständige User-Pfade: Login → Aktion → Verifikation.
UI-Tests (Snapshot, Accessibility): Playwright + axe-core. WCAG 2.0 AA als Baseline, Lighthouse 100/100/100/100 als Ziel.
Security-Tests: OWASP Top 10 (semgrep, bandit, eslint-plugin-security), gitleaks (Secret-Scanning im Pre-Commit und CI), trivy (Scanning von Docker-Images).
Performance-Tests: k6 oder locust für Lasttests, Prüfung von p95/p99-Response-Times unter Last.
Regressionstests: die vollständige Suite läuft vor jedem Produktivdeployment. Jeder gemeldete Bug wird zu einem Regressionstest.
Smoke-Tests: ein minimales Set von 5-10 Tests, die nach dem Produktivdeployment ausgeführt werden (ist die Anwendung überhaupt hochgekommen).
Acceptance-Tests: Business-Tests (Cucumber/Gherkin), die bestätigen, dass die Anforderung erfüllt wurde.

Ein fehlschlagender Test = blockierter Merge. Ohne Ausnahmen. Ist ein Test „flaky" (instabil), analysiert ein Diagnose-Agent die Ursache und repariert den Test oder den Code — entfernt den Test aber niemals ohne menschliche Entscheidung.

Typische Anwendungsfälle

Die Muster, die wir am häufigsten anwenden. Jedes kommt mit eigenem Set aus Agenten, Werkzeugen und Templates. Time-to-Value wird in Wochen gemessen, nicht in Monaten.

Legacy-Systemmodernisierung

•Alte monolithische Anwendung (PHP/.NET, ohne Tests, schwer wartbar)
•Agenten zerlegen den Monolithen in Microservices (inkrementell, ohne Downtime)
•Generieren Characterization-Tests (Erfassung des aktuellen Verhaltens) vor dem Refactoring
•Datenmigration mit vollständigem Audit-Trail und Rollback-Plan

Neuer Enterprise-Microservice

•Spezifikation als Input (Jira-Ticket, PRD, Meeting-Transkript)
•Architektur → Code → Tests → Review → Deploy in 2-3 Wochen
•Integration mit bestehendem SSO (Keycloak), Audit-Log, Monitoring
•Vollständige EU AI Act- und DSGVO-Konformität ab Tag eins

Systemintegration

•Verbindung von ERP, CRM, KRS, Microsoft Graph, IBM, Cisco, externen Partnern
•Agenten schreiben Adapter, Mappings, Retry/Backoff, Idempotenz
•Integrationstests gegen echte Endpunkte (Sandbox-APIs)
•Monitoring (Prometheus + Grafana) und Alerts (Sentry) automatisch eingebunden

Multi-Tenant-Plattformen

•Mehrmandantenfähiges SaaS mit vollständiger Datenisolation (per-Tenant-Schema oder Row-Level Security)
•Automatisiertes Kunden-Onboarding (Keycloak-Provisioning, Datenbank, Rollen)
•Billing auf Basis des SSO Billing SDK (Token-Usage-Tracking, Fail-Open)
•Compliance: DSGVO, ISO 27001, EU AI Act audit-ready

Vergleich: klassisches Team vs. KI-gestützter Prozess

Aspekt	Klassisches Team (8-10 Personen)	Team mit KI-Agenten (2-3 Personen)
Time-to-Market (durchschnittliches Feature)	2-4 Wochen	3-7 Tage
Testabdeckung	40-60% (wenn das Team Zeit hat)	>80% standardmäßig (Tests werden mit dem Code generiert)
Code Review	1 Person, durchschnittlich 30-60 Min.	3 Agenten (Security, Quality, Architecture) + Mensch bei komplexen Änderungen
Dokumentation	Oft unvollständig, „nachträglich ergänzt"	Wird mit dem Code generiert (OpenAPI, README, CHANGELOG)
Audit-Trail	Git-Historie	Git + Audit-Log in der Datenbank + CHANGELOG + Change Request
Skalierung	Linear (mehr Personen = höhere Kommunikationskosten)	Nicht-linear (mehr Agenten = gleiche Anzahl überwachender Personen)
Compliance (EU AI Act, DSGVO, ISO 27001)	Oft externes Audit im Nachhinein	Von Tag eins in den Prozess eingebaut

Häufig gestellte Fragen

Was ist automatisierte KI-Softwareentwicklung?

Es ist ein Prozess, bei dem spezialisierte KI-Agenten an jeder Phase des Softwareentwicklungszyklus mitwirken: von der Anforderungsanalyse über das Architekturdesign, Coding, automatisierte Tests (Unit, Integration, E2E, Security, Performance, Regression) bis hin zu Code Review und Produktivdeployment. Menschen überwachen den Prozess weiterhin und treffen Schlüsselentscheidungen, doch Routineaufgaben (Code schreiben, Tests generieren, Refactoring, Dokumentation) werden von KI-Agenten unter Einhaltung der vereinbarten Qualitätsstandards ausgeführt.

Wie unterscheidet sich das vom klassischen Programmieren mit Copilot?

Copilot ist Autovervollständigung — er hilft, einzelne Codezeilen zu schreiben. KI-Softwareentwicklung ist vollständige Orchestrierung: ein Agent plant die Architektur, ein zweiter schreibt den Code, ein dritter schreibt die Tests, ein vierter macht Code Review, ein fünfter deployt. Jeder hat seine Spezialisierung, episodisches Gedächtnis (lernt aus vorherigen Projekten), Werkzeuge und Kontext. Das Ergebnis: ein deutlich größerer Automatisierungsumfang als bei einem einzelnen Copilot, unter Einhaltung von Enterprise-Standards (Tests, Security, Audit-Trail).

Welche Arten von Tests führt dieser Prozess aus?

Jede Testart, die reife Entwicklungsteams einsetzen: Unit, Integration, End-to-End (E2E), UI (Playwright), Security (OWASP Top 10, gitleaks), Performance (Load), Regression, Smoke und Acceptance. Tests werden vor oder parallel zum Code geschrieben (TDD), und jede Änderung muss die vollständige Pipeline durchlaufen.

Deployt die KI Code eigenständig in die Produktion?

Nein — nicht automatisch. Produktivdeployments erfordern einen freigegebenen Change Request (CR) und eine menschliche Entscheidung. KI-Agenten erstellen die Änderungsdokumentation, führen Regressionstests aus und generieren Deploy-Skripte mit Rollback-Plänen, doch der finale Produktiv-Rollout erfordert die Freigabe durch den Operator. Diese Regel ist bewusst — sie minimiert das Risiko unerwarteter Auswirkungen und bewahrt einen vollständigen Audit-Trail.

Funktioniert dieser Prozess für Enterprise-Projekte?

Ja. Wir nutzen ihn in unseren eigenen Produkten, darunter die Multi-Agenten-Plattform HybridCrew, die Consulting-Plattform mit SSO, PostgreSQL-basierte Microservices und Integrationen mit externen Systemen (KRS, MS Graph, IBM, Keycloak). Jedes Projekt hat seine eigene CI/CD-Pipeline, Dev/Test/Prod-Umgebungen, Monitoring und Audit-Log. Der Prozess skaliert vom einzelnen Microservice bis zur Multi-Container-Plattform.

Wie lange dauert es, diesen Prozess in unserem Unternehmen einzuführen?

Das hängt vom Kontext ab. Für ein kleines Team (1-3 Entwickler) dauert die Integration mit dem bestehenden Repository und der CI/CD-Pipeline typischerweise 2-4 Wochen: Audit, Agentenkonfiguration, Abstimmung mit den Coding-Standards, Schulung. Für größere Organisationen dauern Pilotprojekte (ein Team, ein Microservice) 6-8 Wochen, gefolgt von einer schrittweisen Ausweitung auf weitere Teams.

Was ist mit der Sicherheit des Quellcodes?

Kunden-Repositories verlassen die Umgebung niemals zu externen Diensten ohne ausdrückliche Zustimmung. Standardmäßig läuft der gesamte Prozess (KI-Agenten, LLM-Modelle, Vektordatenbank, Audit-Log) in der Infrastruktur des Kunden oder in der privaten Cloud von ESKOM AI mit vollständiger Isolation. Secrets werden über HashiCorp Vault verwaltet, Code wird vor jedem Commit per gitleaks gescannt, und alle Repositories sind standardmäßig privat.

Werden Sie unser Entwicklerteam ersetzen?

Nein. Erfahrene Entwickler sind unverzichtbar — sie entwerfen die Architektur, treffen Entscheidungen, prüfen komplexe Änderungen, lösen ungewöhnliche Probleme. KI-Agenten übernehmen sich wiederholende, automatisierungsfreundliche Aufgaben: Boilerplate schreiben, Tests generieren, Dokumentation, Refactoring, Code Review erster Stufe. Das Ziel: zwei bis drei Personen mit KI liefern den Wert eines 8-10-köpfigen Teams — ohne Burnout, mit höherer Qualität und vollständigem Audit-Trail.

Wie viel kostet KI-Softwareentwicklung?

Die Preisgestaltung ist immer projektspezifisch und hängt von Skalierung, Abrechnungsmodell (Plattform-Abo vs. dediziertes Projekt), erforderlichen Integrationen sowie davon ab, ob die Agenten auf lokalen LLM-Modellen laufen (Ollama auf der GPU des Kunden — geringere Betriebskosten) oder in der Cloud (Anthropic, OpenAI — höhere Flexibilität). In Pilotprojekten streben wir an, den Return on Investment innerhalb des ersten Quartals nach dem vollständigen Start zu erreichen.

Was sind typische Signale, dass ein Unternehmen für diesen Prozess bereit ist?

Die besten Ergebnisse erzielen Teams, die bereits Folgendes haben: ein versionsverwaltetes Repository (Git), definierte Coding-Standards, eine grundlegende CI/CD-Pipeline, klar dokumentierte Anforderungen (Jira/Linear/eigene) und eine Code-Review-Kultur. Fehlt eines davon, blockiert das den Rollout nicht — wir beginnen dann mit einem Audit und der Grundlagenarbeit. Am wenigsten reif sind Organisationen ohne Versionskontrolle oder mit Produktivcode, den niemand testet.

Bereit für ein Pilotprojekt?

Wir beginnen mit einem Audit des bestehenden Prozesses und einem Pilotprojekt auf einem ausgewählten Microservice. Erste Ergebnisse sichtbar innerhalb von 2-4 Wochen. Keine langfristigen Vertragsbindungen erforderlich.

Gespräch vereinbaren Produkte ansehen