Der Engpass ist nicht mehr der Code.

Sondern die Frage, ob das Richtige gebaut wird. Und ob es in einem Jahr noch jemand versteht.

SDD beantwortet beides mit einem Dokument: einer präzisen, versionierten Spezifikation. Problem, Architektur, Randbedingungen, Tests, Abnahme. Bevor die erste Zeile Code entsteht.

Vier Stufen. Ein Dokument.

SDD ist nicht an eine Sprache oder Plattform gebunden. Dieselbe Vorlage trägt Web, Backend, Embedded und Apps.

Ablauf anhand eines Beispiels aus dem Android/Kotlin-Umfeld

Eine Live-Plattform für Indoor-Cycling-Rennen. Die Ausschnitte stammen aus zwei Spezifikationen dieses Projekts: Spec 12 (Architektur) und Spec 68 (Datenpfad). Namen sind entfernt.

  1. Vision
  2. Microspecs
  3. Umsetzung
  4. Nachweis

Vision. Erst das Problem.

Ziel, Problem, Architektur. Versioniert wie Quellcode. Der Code folgt daraus, nicht umgekehrt.

Bevor Geld in Code fließt, steht fest, was gebaut wird und woran Erfolg gemessen wird.

Ausschnitt aus Spec 12: das Stage-Interface mit gemeinsamer Basisklasse, die Theater-API und die festgelegte Reihenfolge von replaceScene, als Code mit Erläuterungen.
Schnittstellen, festgelegt bevor Code entsteht. Anonymisiert.
Spec 12, Abschnitt Stage-Interface und Theater-API, in voller Größe.

Microspecs. Jede Anforderung wird ein Test.

Die Spec zerfällt in nummerierte Einheiten. Jede mit Testszenarien aus echten Werten. Ergebnis: grün oder rot.

Ob etwas fertig ist, entscheidet kein Bauchgefühl.

IDGegebenWennDannPrüft
T68-02Kaltstart, 8 Feldererster Refreshjedes Feld = Zielwert ±1e-6, kein Gleiten von nullAC-02
T68-03Slot wird von neuem Rad belegterster RefreshWert des neuen Rads, kein Rest des altenAC-02
T68-0920 Fahrer, alle gleichaufSortierungFallback auf Neusortierung greiftAC-03
T68-17aVoller Raumpublish0 Byte alloziertAC-07
T68-21Schema-Konstante verletztGenerator läuftBuild bricht ab, kein HeaderAC-09

5 von 24 Szenarien

Umsetzung. Gegen die Spec, nicht gegen den Prompt.

Agenten schreiben den Code, testgetrieben. Die Randbedingungen stehen in der Spec, nicht im Kopf eines Entwicklers.

Kein Wissen versickert in Chatverläufen. Die Spec ist die Dokumentation.

  1. Funk-GatewayUDP-Multicast, die Daten aller Räder
  2. Empfangein Thread: Absender prüfen, parsen, Slot schreiben
  3. Puffer-Poolpublish() alle 33 ms, Rangfolge im Header
  4. Glättung & SortierungKotlin-Referenz, C-Beschleuniger
  5. Anzeigemehrere Leser, ein Datenstand

Generator erzeugt den C-Header aus dem Schema. Weicht etwas ab, hält der Build an.

Der Datenpfad, vereinfacht. Hervorgehoben: was die Spec ändert.

Randbedingungen

  • Die Kotlin-Implementierung bleibt für immer: als lesbare Referenz und als Testorakel.
  • Native Puffer müssen allocateDirect sein. Ein Heap-Puffer lässt den nativen Aufruf still zurückkehren, ohne zu schreiben.
  • publish() alloziert pro Takt nichts, auch nicht bei vollem Raum.
  • Ein einziger Schreiber, der Event-Loop-Thread. Keine zusätzlichen Locks.

Nachweis. Abgenommen wird, was belegt ist.

Jedes Abnahmekriterium nennt die Tests, die es prüfen. Was offen ist, steht als offen da.

Sie nehmen gegen Kriterien ab, die Sie vorher kannten.

  • AC-01 Native Glättung entspricht der Kotlin-Referenz auf 1e-4 genau. T68-01, -05, -06
  • AC-07 publish alloziert nichts und bleibt unter 10 % des Takts. T68-17a/b, -19a/b, -20
  • AC-09 Schema-Drift bricht den Build, nicht die Anzeige. T68-21
  • AC-11 Toleranz für exp() nativ gegen Kotlin auf dem Gerät. offen: Entscheidung nötig

Ein Team aus Agenten. Ein Mensch, der freigibt.

Jeder Agent hat genau eine Aufgabe. Keiner kann eine Spec allein erfüllen. Koordiniert wird über die Spezifikation.

Animation: Der Domain-Agent klärt mit dem Architekten die Fachbegriffe. Der Architekt zerlegt die Spezifikation in Microspecs und verteilt sie an drei Worker. Die Worker arbeiten testgetrieben: Test rot, Code, Test grün. Die Ergebnisse gehen an Reviewer und Security-Agent; beide schicken je einen Befund zurück, die Worker beheben ihn mit einem neuen Test. Am Ende prüft ein Mensch und gibt frei. Der Ablauf steht als Liste daneben.

  1. Domain ↔ Architekt Fachbegriffe geklärt, Glossar steht
  2. Spec → Architekt Vision-Spec 12: Ziel, Problem, Architektur, Szenarien
  3. Architekt zerlegt in Microspecs mit Abhängigkeiten
  4. Architekt → Worker 12.1, 12.2, 12.3 parallel
  5. Worker, TDD Test rot → Code → Test grün, Szenario für Szenario
  6. Worker → Reviewer, Security umgesetzt, alle Tests grün
  7. Reviewer, Security prüfen gegen die Spec und auf Schwachstellen
  8. Security → Worker Befund 12.2: Eingabe ungeprüft
  9. Reviewer → Worker Befund 12.3: Zuständigkeit doppelt, SoC
  10. Worker, TDD neuer Test rot → Fix → grün
  11. Worker → Reviewer, Security behoben
  12. Reviewer, Security → Mensch Bericht: Kriterium → Test → Ergebnis
  13. Mensch geprüft gegen die Abnahmekriterien, freigegeben

Schematischer Ablauf, keine Aufzeichnung.

  • Domain kennt die Fachsprache und klärt Begriffe, bevor geplant wird. Plant nicht.
  • Architekt liest alle Specs, zerlegt in Microspecs, plant und delegiert. Schreibt keinen Code.
  • Worker arbeiten testgetrieben: erst der rote Test, dann der Code, eine Microspec nach der anderen. Treffen keine Architekturentscheidungen.
  • Reviewer prüft gegen die Spec: Testabdeckung, Architektur, DRY, SoC, KISS. Implementiert nicht.
  • Security prüft auf Schwachstellen, angelehnt an OWASP. Implementiert nicht.
  • Mensch bewertet das Ergebnis gegen die Abnahmekriterien und gibt frei.

Nicht die Agenten entscheiden, wann sie fertig sind. Die Tests tun es, und am Ende ein Mensch.

Soll Ihr nächstes Projekt so entstehen?

Schreiben Sie mir kurz, worum es geht. Das Erstgespräch ist unverbindlich, die Antwort kommt von mir.