CommunityCodierung & Entwicklunggithub.com

Software-Architektur-Engineering

Coding-Skill. Entwerfe, implementiere, refaktoriere und überprüfe Software, während die architektonische Integrität kontinuierlich gewahrt bleibt. Verwende dies für KI-gestütztes Coden, Repository-Änderungen, Feature-Entwicklung, API-/Datenbank-Änderungen, Modulgrenzen, Systemdesign, Migrationen, Bereitstellungsentscheidungen, Skalierbarkeit, Zuverlässigkeit und Architekturüberprüfungen. Analysiere die bestehende Architektur vor Codeänderungen; wäge kontextgewichtete Kompromisse ab; überprüfe architektonische Einschränkungen nach Änderungen. Für isolierte Änderungen mit geringem Risiko leichtgewichtig bleiben.

Was ist Software-Architektur-Engineering?

Dieser Skill bietet ein strukturiertes, agententaugliches Framework zur Bewahrung der Architekturintegrität während KI-gestützter Codeänderungen. Er ist von den Prinzipien der Softwarearchitektur inspiriert, modelliert aber einen operativen Workflow, der speziell für KI-Agenten (wie Claude Code, Cursor, Codex) in bestehenden Repositories optimiert ist. Der Skill definiert drei grundlegende Gesetze (Alles ist ein Kompromiss, Warum ist wichtiger als Wie, Entscheidungen liegen auf einem Spektrum) und einen abgestuften Aufwand nach Auswirkung (Leicht, Standard, Tief), um Overhead für triviale Aufgaben zu vermeiden. Der Kern ist ein sechsschrittiger Coding-Agenten-Loop: 1) Entdecke das aktuelle System ohne es zu erfinden, 2) Bewerte die Auswirkungen vor dem Bearbeiten, 3) Bewahre Grenzen und vergleiche Alternativen, 4) Plane die Implementierung in sicheren Schritten, 5) Implementiere ohne Architekturabweichung, 6) Überprüfe die Architektur, nicht nur die Funktion, 7) Dokumentiere und kommuniziere folgenreiche Entscheidungen. Dieser Loop stellt sicher, dass Agenten die bestehende Architektur respektieren, Grenzen dokumentieren, objektive Fitnessfunktionen anwenden und nicht stillschweigend Architekturen durch bevorzugte Stile ersetzen. Der Skill enthält grundlegende, nicht verhandelbare Sicherheitsvorkehrungen (keine unüberprüfbaren Fakten, keine versteckte Kopplung, keine Prozessvorführung) und verweist auf optionale Referenzdateien (z. B. zu Architekturstilen, verteilten Systemen, Entscheidungsprotokollen) und Vorlagen (ADR, Architekturvertrag, Änderungsauswirkung).

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/iAmSerathion/Skills/tree/HEAD/software-architecture-engineering

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

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:

  1. Alles ist ein Kompromiss. Bewerte Kosten sowie Nutzen, gewichtet nach tatsächlichem Kontext; bewerte neu, wenn sich die Bedingungen ändern.
  2. Warum ist wichtiger als Wie. Bewahre Begründungen, abgelehnte Optionen, Risiken und Entscheidungsverantwortliche, nicht nur Diagramme und Code.
  3. Entscheidungen liegen auf einem Spektrum. Lehne falsche Dichotomien, pauschale Microservice-Regeln und Architekturmoden ab.

Aufwand nach Auswirkung wählen

ModusTypischer AuslöserAktion und erwartete Ausgabe
LeichtIsolierter Bug, Formatierung, lokale Implementierung ohne Vertrags-/GrenzauswirkungInspiziere relevanten Code und Einschränkungen; nimm minimale Änderung vor; führe relevante Prüfungen durch; berichte nur über wesentliche Probleme. Kein obligatorischer ADR.
StandardFeature über Module hinweg, neue Integration, API-/Schemaänderung, folgenreiche RefaktorisierungStelle Projektkontext her; inspiziere Abhängigkeiten; vergleiche realistische Optionen; implementiere inkrementell; überprüfe Grenzen und Verträge; dokumentiere bedeutende Entscheidungen.
TiefNeue Plattform, Service-Aufteilung, größere Migration, risikoreiche Daten-/Sicherheits-/Zuverlässigkeitsänderung, ArchitekturüberprüfungVollstä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.md und 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):

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.

Verwandte Skills