System-Thinking für Agenten
Projektanforderungen an Entwickler in Zeiten von KI, Teil 4
Ein Projekt in einer mittelständischen Versicherung. Die Aufgabe: ein Angebotssystem für Gewerbekunden. Der technische Lead gibt Claude Code den Auftrag, die Architektur vorzuschlagen. Der Agent liefert innerhalb von Minuten ein Designdokument: acht Microservices, ein API-Gateway, ein Message-Broker, Service Discovery, verteiltes Tracing. Technisch vorbildlich. Das Team beginnt mit der Umsetzung. Sechs Wochen später verbringt einer der drei Entwickler seine gesamte Arbeitszeit mit Infrastrukturwartung. Die anderen beiden kommen kaum zur Fachlogik, weil jede Änderung mehrere Services betrifft und die lokale Entwicklungsumgebung regelmäßig zusammenbricht.
Der Agent hat die Aufgabe gelöst, die ihm gestellt wurde. Aber er hat nicht gefragt, wie groß das Team ist, welche Last zu erwarten ist und ob die Organisation verteilte Systeme betreiben kann. Agenten optimieren auf technische Korrektheit. Architektur erfordert System-Thinking: das Verständnis, wie technische Entscheidungen mit Teamstruktur und Geschäftsstrategie zusammenhängen. Dieser letzte Teil der Serie zum Thema „Projektanforderungen an Entwickler in Zeiten von KI“ zeigt anhand von drei Szenarien, warum Architekturentscheidungen die Grenze markieren, an der Delegation aufhört.
Szenario 1: Monolith versus Microservices
Das Versicherungsbeispiel ist kein Sonderfall. Agenten liefern Microservice-Lösungen, weil ihre Trainingsdaten von Foren- und Blogartikeln, Fachartikeln und Best-Practice-Guides dominiert sind, in denen Microservices als Standard präsentiert werden. Der Agent hat kein Modell von Conway’s Law: dass die Struktur eines Systems die Kommunikationsstruktur der Organisation widerspiegelt. Ein Dreierteam mit acht Services hat keine natürlichen Service-Owner. Jeder Entwickler muss jedes System kennen, was den Vorteil unabhängiger Deployments eliminiert.
Die Entscheidung hängt von Faktoren ab, die ein Agent nicht bewerten kann: Teamgröße, erwartete Last, Deployment-Frequenz, organisatorische Reife. Ein System mit 200 gleichzeitigen Nutzern braucht keine horizontale Skalierung einzelner Komponenten. Im konkreten Fall wäre ein modularer Monolith richtig gewesen: saubere Modul-Grenzen innerhalb einer Deployment-Unit, ein Repository, eine Pipeline. Der Agent hätte diese Lösung vorgeschlagen, wenn die CLAUDE.md Vorgaben enthalten hätte:
## Architecture Decisions This project is a modular monolith. Do NOT suggest microservice splits. Reasons: - Team size: 3 developers - Expected load: <500 concurrent users - Deployment: bi-weekly release cycle Module boundaries follow domain contexts. Cross-module communication via internal events (MediatR), NOT HTTP.
Aber um diese Vorgabe schreiben zu können, muss der Entwickler die Architekturentscheidung bereits getroffen haben. Der Agent kann Architektur implementieren. Er kann sie nicht bewerten.
Szenario 2: CQRS als Overengineering
Ein zweites Muster: Der Agent übernimmt Architekturmuster aus der CLAUDE.md und wendet sie auf jede Aufgabe an. Ein Projekt nutzt CQRS für komplexe Domänen-Logik, sinnvoll bei Operationen mit unterschiedlichen Lese- und Schreibmodellen. Aber der Agent wendet dasselbe Muster auf triviale CRUD-Operationen an. Das Team braucht eine Kategorieverwaltung: Erstellen, Lesen, Ändern, Löschen, keine Geschäftsregeln. Der Agent liest, dass MediatR verwendet wird, und erzeugt:
public record CreateCategoryCommand(
string Name, string Description)
: IRequest<CreateCategoryResponse>;
public class CreateCategoryHandler
: IRequestHandler<
CreateCategoryCommand,
CreateCategoryResponse>
{
private readonly AppDbContext _ctx;
public CreateCategoryHandler(
AppDbContext ctx) => _ctx = ctx;
public async Task<CreateCategoryResponse>
Handle(CreateCategoryCommand req,
CancellationToken ct)
{
var entity = new Category
{
Name = req.Name,
Description = req.Description
};
_ctx.Categories.Add(entity);
await _ctx.SaveChangesAsync(ct);
return new CreateCategoryResponse(
entity.Id);
}
}
Für vier CRUD-Operationen entstehen zwölf Dateien: vier Commands oder Queries, vier Handler, vier Response-Typen. Jede enthält weniger als zwanzig Zeilen. Der eigentliche Datenbankzugriff ist ein Einzeiler. Der Overhead von zum Beispiel MediatR bringt bei einer Operation ohne Geschäftsregeln keinen Vorteil. Ein Service mit vier Methoden hätte denselben Zweck in einer Datei erfüllt.
Der Agent differenziert nicht zwischen Komplexitätsstufen. CQRS eignet sich für Szenarien, in denen Lese- und Schreibvorgänge unterschiedliche Anforderungen haben. Bei einer Kategorieverwaltung sind sie symmetrisch. Entwickler müssen nicht nur das Muster dokumentieren, sondern auch dessen Anwendungsgrenzen:
## When to use CQRS (MediatR) Use Command/Query + Handler for: - Operations with business rules - Operations that publish domain events - Operations needing pipeline behaviors Use a simple service class for: - Pure CRUD without business logic - Reference data management
Szenario 3: Caching ohne Invalidierung
Das dritte Szenario betrifft eine Entscheidung, die rein technisch wirkt, aber weitreichende geschäftliche Konsequenzen hat. Ein E-Commerce-System zeigt Produktpreise an. Der Agent soll die Performance verbessern und implementiert aggressives Caching:
public class CachedProductService
: IProductService
{
private readonly IProductRepo _repo;
private readonly IMemoryCache _cache;
public async Task<ProductDto>
GetProduct(int id)
{
return await _cache
.GetOrCreateAsync(
$"product:{id}",
async entry =>
{
entry.AbsoluteExpiration =
DateTimeOffset.UtcNow
.AddHours(1);
return await _repo
.GetByIdAsync(id);
});
}
}
Technisch einwandfrei. Die Datenbankabfragen gehen zurück, die Antwortzeiten sinken. Aber ohne Invalidierungsstrategie zeigt das System bis zu sechzig Minuten den alten Preis. Bei einer Preiserhöhung verkauft das Unternehmen unter dem aktuellen Preis. Bei einem Flash-Sale sehen manche Nutzer die reduzierten Preise sofort, andere erst eine Stunde später.
In einem verteilten System verschärft sich das Problem. IMemoryCache ist prozesslokal. Bei drei Instanzen hinter einem Load-Balancer hat jede ihren eigenen Cache. Ein Nutzer sieht bei jedem Seitenaufruf möglicherweise einen anderen Preis, was bei Bestellungen zu rechtlichen Problemen führt, wenn der angezeigte Preis nicht dem berechneten entspricht.
Eine tragfähige Caching-Strategie erfordert Antworten jenseits des Codes: Welche Daten dürfen veraltet sein? Wer ändert sie? Laufen mehrere Instanzen? Die korrekte Lösung hätte einen verteilten Cache mit expliziter Invalidierung verwendet:
public async Task UpdatePrice(
int productId, decimal newPrice)
{
await _repo.UpdatePriceAsync(
productId, newPrice);
await _distributedCache
.RemoveAsync($"product:{productId}");
await _eventBus.PublishAsync(
new PriceChangedEvent(
productId, newPrice));
}
Aber auch diese Lösung ist eine Architekturentscheidung: verteilter versus lokaler Cache, explizite Invalidierung versus kurze TTL, Events versus Cache-Aside. Jede Variante hat Trade-offs, die nur im Kontext des Gesamtsystems bewertbar sind.
Agenten sehen Dateien, Entwickler sehen Zusammenhänge
Alle drei Szenarien zeigen dasselbe Grundmuster. Der Agent optimiert lokal: die beste Architektur für das Feature, das beste Pattern für die Aufgabe, die beste Performance für die Abfrage. Architektur ist aber nicht lokal. Sie entsteht aus Abwägungen zwischen konkurrierenden Anforderungen: Teamkapazität, Betriebskompetenz, Geschäftsstrategie, Time-to-Market.
Die Frage ist nicht, ob Agenten bei Architekturarbeit helfen sollen. Sie sollen. Agenten listen Optionen auf, beschreiben Trade-offs, implementieren Patterns. Aber die Auswahl, welches Pattern in diesem Kontext für dieses Team richtig ist, bleibt beim Entwickler. Als Orientierung: Entscheidungen, die nur den Code betreffen, kann man delegieren. Entscheidungen, die die Struktur des Systems betreffen, trifft man selbst. Variablenbenennung, Algorithmus, Unit-Test: delegierbar. Architektur, Modulschnitt, Caching-Strategie, Datenmodell: nicht delegierbar.
Diese Serie hat vier Perspektiven auf dieselbe These gezeigt: CLAUDE.md als Interface, Prompt-Engineering als Präzisionswerkzeug, Code-Review als Qualitätssicherung, System-Thinking als nicht delegierbare Kernkompetenz. Zusammen bilden sie das Anforderungsprofil an Entwickler, die mit KI-Agenten arbeiten: nicht weniger technische Kompetenz, sondern mehr, siehe dazu auch den Hauptartikel dieser Serie unter [1].
Die Werkzeuge werden mächtig. Aber Werkzeuge treffen keine Architekturentscheidungen. Das bleibt die Aufgabe der Menschen, die das System verantworten.
[1] Patrick Schnell, Der Stellenwert von Developern in Zeiten von KI, dotnetpro 4/2026, Seite 6 ff.