Was macht Software-Architektur-Engineering?
Zweck
Die Architektur während der Änderung der Software kohärent halten, einschließlich Änderungen, die von KI-Agenten geschrieben wurden. Dies ist ein operativer Skill, kein Befehl, jedes Projekt neu zu entwerfen. Seine wiederverwendbaren Prinzipien stammen aus Fundamentals of Software Architecture, 2. Aufl. (Richards und Ford, 2025); kontinuierliche Agenten-Workflows und Artefakte sind originäre Erweiterungen. Es ist kein spezifisches Modell, keine spezifische Programmiersprache, kein Repository-Host, CI-Tool oder Framework erforderlich.
Wende drei Gesetze durchgängig an:
- Alles ist ein Kompromiss. Bewerte Kosten sowie Nutzen, gewichtet nach tatsächlichem Kontext; bewerte neu, wenn sich die Bedingungen ändern.
- Warum ist wichtiger als Wie. Bewahre Begründungen, abgelehnte Optionen, Risiken und Entscheidungsverantwortliche, nicht nur Diagramme und Code.
- Entscheidungen liegen auf einem Spektrum. Lehne falsche Dichotomien, pauschale Microservice-Regeln und Architekturmoden ab.
Aufwand nach Auswirkung wählen
| Modus | Typischer Auslöser | Aktion und erwartete Ausgabe |
|---|---|---|
| Leicht | Isolierter Bug, Formatierung, lokale Implementierung ohne Vertrags-/Grenzauswirkung | Inspiziere relevanten Code und Einschränkungen; nimm minimale Änderung vor; führe relevante Prüfungen durch; berichte nur über wesentliche Probleme. Kein obligatorischer ADR. |
| Standard | Feature über Module hinweg, neue Integration, API-/Schemaänderung, folgenreiche Refaktorisierung | Stelle Projektkontext her; inspiziere Abhängigkeiten; vergleiche realistische Optionen; implementiere inkrementell; überprüfe Grenzen und Verträge; dokumentiere bedeutende Entscheidungen. |
| Tief | Neue Plattform, Service-Aufteilung, größere Migration, risikoreiche Daten-/Sicherheits-/Zuverlässigkeitsänderung, Architekturüberprüfung | Vollständige Kontext- und Architekturanalyse, Alternativen, explizite Daten-/Fehlermodi, Migration und Rollback, messbare Fitnessfunktionen, ADR(s), Risiko- und Genehmigungsgrenzen. |
Hochstufen, wenn eine vermeintlich kleine Änderung Eigentumsgrenzen überschreitet, öffentliche Verträge ändert, Persistenz verändert, neue Laufzeit-/Bereitstellungskomponenten einführt, die Fehlerauswirkung erweitert oder Architekturabweichung offenbart. Herabstufen, wenn die Untersuchung keine sinnvollen Architekturauswirkungen zeigt. Benutzer-/Projekt-/Sicherheitsanweisungen haben Vorrang. Erzwinge niemals schwerfällige Berichte für triviale Aufgaben.
Erforderlicher Coding-Agenten-Loop
Für Arbeiten in einem bestehenden Repository führe diesen Loop aus. Siehe Agentenimplementierungs-Governance für genaue Vorgehensweise, Fehlerbehandlung und Parallel-Agenten-Regeln.
0. Entdecke das aktuelle System – erfinde es nicht
- Inspiziere relevanten Code, Tests, Paket-/Build-Dateien, Infrastruktur, Konfiguration, Dokumentation, ADRs, Verzeichnisstruktur und tatsächliche Abhängigkeitspfade wenn zugänglich.
- Lokalisiere etwaige Projektarchitekturverträge, z.B.
docs/architecture/CONTRACT.mdund akzeptierte ADRs; behandle sie als Projekteinschränkungen, nicht als unveränderliche Wahrheiten. - Halte beobachtet / geliefert / angenommen / unbekannt getrennt fest. Wenn kein Code-/Tool-Zugriff besteht, sage, dass das Ergebnis ein Vorschlag ist, keine verifizierte Repository-Analyse.
- Ersetze nicht stillschweigend die bereits verwendete Architektur durch einen bevorzugten Stil.
1. Bewerte die Auswirkungen vor dem Bearbeiten
- Definiere den Änderungsumfang, betroffene Geschäftsfunktionen, besitzende Module, APIs/Verträge, Datenverantwortlichkeiten, Abhängigkeiten, Sicherheitsgrenzen, Bereitstellungseinheiten und Fehlerpfade.
- Klassifiziere die Aufgabe als Leicht / Standard / Tief und wähle die kleinste ausreichende Überprüfung.
- Leite für wesentliche Entscheidungen einige priorisierte Architekturmerkmale (z.B. Sicherheit, Latenz, Verfügbarkeit, Skalierbarkeit, Elastizität, Wartbarkeit, Testbarkeit, Bereitstellbarkeit, Wiederherstellbarkeit, Kosten) mit Umfang, Ziel und Messung ab. Trenne explizite Anforderungen von impliziten, unbestätigten Bedürfnissen.
- Wähle minimale, umkehrbare Standardeinstellungen für risikoarme Unbekannte; gehe nicht von unbestätigten, risikoreichen Annahmen aus.
2. Bewahre Grenzen und vergleiche Alternativen, wo angebracht
- Bevorzuge hohe Kohäsion und lose Kopplung. Halte Geschäftsverantwortung, Abhängigkeitsrichtung, zeitliche Kopplung und Datenbesitz explizit. Unterscheide logische Module von unabhängig bereitgestellten Diensten.
- Überprüfe Auswirkungen auf Betriebs- und Datenarchitektur, nicht nur auf die Verzeichnisstruktur. Eine gemeinsame Datenbank, Transaktionsgrenze oder synchroner Aufruf kann scheinbare Modularität zunichtemachen.
- Vergleiche für folgenreiche Änderungen mindestens zwei machbare Optionen mittels kontextgewichteter Kompromisse. Kandidaten können geschichtete, modulare Monolithen, Pipeline-, Microkernel-, servicebasierte, ereignisgesteuerte, raumbasierte, orchestrierungsgesteuerte SOA, Microservices oder Hybride umfassen. Kein Architekturstil ist der universelle Standard.
- Verteilte Designs müssen Netzwerkausfall/-latenz, Verfügbarkeit, Konsistenz, Transaktionsgrenzen, Wiederholungen, Idempotenz, Beobachtbarkeit, Sicherheit und Betriebskosten soweit anwendbar adressieren.
- Benenne Bedingungen, die die Entscheidung umkehren würden. Verwende Stile, verteiltes Design und Grundlagen selektiv.
3. Plane die Implementierung in sicheren Schritten
- Identifiziere erwartete Datei-/Moduländerungen, Verträge, die stabil bleiben müssen, Migrationsreihenfolge und ggf. Rollback-Strategie.
- Lege Architekturinvarianten (Regeln, die wahr bleiben müssen) fest: erlaubte Abhängigkeitsrichtung, interner API-Besitz, Datenschreibberechtigung, Mandanten-/Authentifizierungsgrenzen, Rückwärtskompatibilität, Fehlerbehandlung usw.
- Wähle objektive Prüfungen für diese Invarianten vor der Implementierung. Kopiere/passe Projektarchitekturvertrag und Änderungsauswirkungsvorlage an, wo nützlich; erstelle keine Projektdateien ohne Erlaubnis oder klaren Aufgabenumfang.
- Fordere irreversible/risikoreiche Entscheidungen, die menschliche/Geschäftsentscheidungsbefugnis erfordern, an oder verschiebe sie. Fälsche keine Genehmigungen.
4. Implementiere ohne Architekturabweichung
- Nimm die kleinste kohärente Änderung vor, die mit der aktuellen Architektur konsistent ist. Teile keine Dienste auf, führe keine Broker, globalen Abstraktionen oder neuen Frameworks ohne nachgewiesenen Bedarf ein.
- Halte Schnittstellen und Datenbesitz explizit. Erstelle keine Abkürzungen durch Interna eines anderen Moduls, umgehe Auth/Validierung, ändere stillschweigend Ereignisschemata oder mische nicht zusammenhängende Änderungen.
- Wenn die Implementierung einen wesentlichen Fehler im Plan offenbart, stoppe und bewerte die betroffene Entscheidung neu, anstatt sie mit Workaround-Code zu verbergen. Aktualisiere ADR/Vertrag nur, wenn gerechtfertigt.
- Lege bei Multi-Agenten-Arbeiten Komponenten-/Dateibesitz, stabile Verträge und einen Integrationsverantwortlichen fest. Parallele Änderungen überschreiben keine gemeinsamen Architektureinschränkungen.
5. Überprüfe die Architektur, nicht nur die Funktion
- Führe relevante vorhandene Unit-/Integrations-/Vertragstests und Build-Prüfungen aus wenn verfügbar und autorisiert.
- Überprüfe architekturspezifische Fitnessfunktionen: verbotene Abhängigkeiten, Zyklen, Modulbesitz, API-Kompatibilität, Schema-Migration, Idempotenz, Leistungsbudgets, Beobachtbarkeit, Resilienz, Sicherheit, Bereitstellung/Rollback, soweit anwendbar.
- Vergleiche die Abhängigkeitsstruktur vorher/nachher und betroffene Invarianten. Ein optionaler Stdlib-Importgrenzenprüfer mit Beispielkonfiguration kann ausgewählte Python/JS/TS-Importregeln durchsetzen; er ist bewusst begrenzt und beweist keine vollständige architektonische Korrektheit.
- Kennzeichne Nachweise als BESTANDEN / FEHLGESCHLAGEN / NICHT AUSGEFÜHRT / NICHT ANWENDBAR. Behaupte keine Tests, Skalierbarkeit, Produktionsreife, Sicherheit oder Bereitstellungen, die ohne tatsächliche Ausführung/Nachweis verifiziert wurden.
- Wenn ein obligatorisches Gate fehlschlägt, korrigiere/mache rückgängig, oder identifiziere explizit das ungelöste Problem und den Entscheidungsverantwortlichen. Präsentiere niemals ein fehlgeschlagenes Gate als abgeschlossene Arbeit.
6. Dokumentiere und kommuniziere folgenreiche Entscheidungen
- Erstelle oder aktualisiere einen präzisen ADR nur für architekturrelevante Änderungen: Titel, Status, Kontext, gewählte Lösung, Warum, Alternativen, Kompromisse, Konsequenzen, Durchsetzung und erneuten Prüfungsauslöser. Verwende ADR-Vorlage.
- Bewahre historische Entscheidungen, wenn sie ersetzt werden. Behandle Diagramme als Kommunikationshilfen, nicht als Nachweis der Implementierung oder Validierung.
- Gib im Abschlussbericht an: was sich geändert hat; Architekturauswirkung; bestandene, fehlgeschlagene oder nicht ausgeführte Prüfungen; ausstehende Risiken; und jede erforderliche menschliche Entscheidung. Für leichte Änderungen reicht in der Regel ein präziser Absatz.
Nur-Design- und Prüfungsaufgaben
Wenn kein Repository bearbeitet wird, wende die Schritte 0–3 und 6 anteilig an; erstelle ein Design, eine Kompromissanalyse, eine Architekturskizze oder Überprüfung, ohne vorzutäuschen, dass etwas implementiert oder getestet wurde. Führe für eine vollständige Architekturprüfung eine Bestandsaufnahme der Komponenten, Datenbesitzverhältnisse, Grenzen, Bereitstellung und Team-/Infrastruktureinschränkungen durch; bewerte konkrete Risiken mit Nachweisen; schlage inkrementelle Abhilfemaßnahmen und Fitnessfunktionen vor, bevor umfassende Neuschreibungen empfohlen werden.
Nicht verhandelbare Sicherheitsvorkehrungen
- Keine unüberprüfbaren Fakten: Keine erfundenen Repository-Inspektionen, Testergebnisse, Lastniveaus, Compliance-Status, Kosten, Stakeholder-Genehmigungen oder Messungen.
- Keine falschen Universalien: Weder Microservices noch Monolithen noch ereignisgesteuerte Systeme sind grundsätzlich am besten. Teile Dienste nicht allein nach Tabelle/Entität auf.
- Keine Umfangsverwirrung: Logische Module, bereitgestellte Einheiten, Datenbesitz und Architekturmerkmalumfang sind unterschiedliche Konzepte.
- Keine versteckte Kopplung: Untersuche gemeinsame Schemata, gemeinsame Bibliotheken, zeitliche Kopplung, dienstübergreifende Aufrufe und Ereignisverträge; die Wiederverwendung volatiler Domänenlogik kann die Kopplung erhöhen.
- Keine Risikoverharmlosung: Verteilte Konsistenz, Transaktionsverarbeitung, Schemaänderungen, Fehlerbehebung und Rollback erfordern explizite Überlegung, wenn relevant.
- Keine Prozessvorführung: Eine ausgefüllte Checkliste oder Selbsteinschätzung ist kein Nachweis. Priorisiere tatsächliche Prüfungen und Codenachweise.
- Keine stillschweigenden Architekturänderungen: Markiere wichtige Abweichungen, dokumentiere Gründe und behalte die Verantwortung beim menschlichen/Projektentscheidungsverantwortlichen.
- Keine urheberrechtlich geschützte Buchverbreitung: Dieser Skill ist eine originäre Synthese. Kopiere das Buch oder seine Diagramme nicht in nachgelagerte Repos.
Referenzdateien auf Abruf
Lies nur die für die Aufgabe benötigten Dateien (Pfade relativ zu diesem Skill-Verzeichnis):
- KI-Coding und kontinuierliche Architektur-Governance – erforderlich für umfangreiche Repository-Bearbeitungen, PR-Überprüfungen, parallele Agenten und Diagnose von Architekturabweichungen.
- Grundlagen und Architekturmerkmale – Anforderungen, Kopplung, Kohäsion, Komponenten, Merkmalsumfang.
- Architekturstile – neun Stile und Auswahlbedingungen.
- Verteilte Systeme und Muster – Netzwerkrealiät, Ereignisse, Transaktionen, Konsistenz, Orchestrierung, CQRS.
- Entscheidungen, Fitnessfunktionen und Risiken – ADRs, Governance, Risiko-Storming, Diagramme.
- Menschen, Daten, Infrastruktur und KI – Teams und betriebliche Einschränkungen.
- Quellverzeichnis – alle 27 Buchkapitel und Unterscheidung zwischen Buchideen und agentenspezifischen Erweiterungen.
- Verifikationsrubrik – Qualitätskriterien für wichtige Designentscheidungen und Implementierungsüberprüfung.
Artefakte: Architekturskizze, Architekturvertrag, Änderungsauswirkung, ADR, Kompromissmatrix, Risikoregister, Architekturüberprüfung, Grenzrichtlinienbeispiel. Durchgespieltes Szenario: KI-Coding ohne Grenzabweichung. Andere Modell-/Laufzeitanweisungen sind optional; siehe Portabilität.