Fundierte Artikel über Technologien, die das Kommende formen.

Entwickler vs. Architekt: Wann welche Rolle gewinnt

Entwickler vs. Architekt ist keine Frage des Titels, sondern wer Architekturentscheidungen trifft. ADRs, Kopplung und Reversibilität für deine Beförderung.

Übersicht eines Schreibtischs mit zwei auseinanderlaufenden Lichtpfaden, einer verworren, einer sauber.
Der Tippteil ist schnell geworden. Das Entscheiden ist jetzt der Job.

Letzten Monat habe ich einen Diff geprüft, in dem ein KI-Coding-Assistent eine Kette von try/catch-Blöcken geschrieben hatte, um neue Installationen einer Browser-Erweiterung zu loggen. Zuerst versuchte er, die E-Mail-Adresse des Nutzers zu holen. Wenn das fehlschlug, fiel er auf eine User-ID zurück. Wenn das auch fehlschlug, loggte er achselzuckend: Jemand hat installiert, wir wissen nicht wer. Der Code funktionierte. Trotzdem war er falsch, denn die Plattform hatte kürzlich eingeschränkt, welche Identitätsdaten eine Erweiterung überhaupt abfragen darf. Die Frage Entwickler vs. Architekt versteckt sich genau in solchen Diffs, und niemand hat dir mitgeteilt, auf welcher Seite du jetzt stehst.

Die richtige Antwort war kein besserer catch-Block. Sie hätte gelautet: einen Zeitstempel loggen, einen Willkommensbildschirm zeigen und dem Marketing sagen, dass es die E-Mail-Adresse zum Installationszeitpunkt nicht bekommt, sofern der Nutzer sie nicht später selbst angibt. Diese Entscheidung kann kein Modell treffen, weil es weder deine Nutzer noch die Richtlinien deiner Plattform oder die Quartalsziele deines Marketingteams kennt. Es tut genau das, was du verlangst, und das mit beängstigender Geschwindigkeit. Damit wird die Person, die fragt, also du, für etwas verantwortlich, das über Code hinausgeht. Herzlichen Glückwunsch zur Beförderung. Tut mir leid, dass dir niemand Bescheid gesagt hat.

Es gibt ein berechtigtes Gegenargument: Viele Ingenieure werden dir sagen, dass jeder Job, den sie hatten, erwartete, Anforderungen zu hinterfragen und das Datenmodell für jedes übernommene Ticket zu entwerfen. Stimmt, in guten Teams war das schon immer die eigentliche Arbeit. Aber etwas Reales hat sich verändert. Die Tippgeschwindigkeit war früher eine natürliche Bremse für schlechte Ideen. Wenn ein mittelmäßiger Plan drei Tage Implementierung kostet, denkt man vorher darüber nach. Wenn er neunzig Sekunden kostet, ist der Plan gebaut, bevor jemand überhaupt darüber nachgedacht hat. Die Reibung, die früher architektonisches Denken erzwungen hat, ist weg, und außer dir hat sie nichts ersetzt.

Entwickler vs. Architekt: Zwei verschiedene Jobs

So kann ich den Unterschied am klarsten beschreiben: Ein Entwickler nimmt ein Ticket und fragt sich wie. Ein Architekt betrachtet dasselbe Ticket und fragt sich, ob es überhaupt existieren sollte und in welcher Form. Der Entwickler optimiert innerhalb der Rahmenbedingungen. Der Architekt legt die Rahmenbedingungen fest und trägt – entscheidend – die Konsequenzen dieser Wahl für die nächsten zwei Jahre. Beides ist echte Ingenieursarbeit, nur sind es unterschiedliche Jobs, und sie scheitern auf unterschiedliche Weise. Ein Fehler des Entwicklers ist ein Bug. Ein Fehler des Architekten ist ein Datenmodell mit redundanten Tabellen, auf dem drei Teams aufgebaut haben, bis es jemand bemerkt.

KI-Coding-Tools haben sich still auf den Entwicklerplatz gesetzt. Sie sind der schnellste Junior, den du je eingestellt hast: unermüdlich, sprachgewandt und völlig unwillig, dir zu sagen, dass deine Anforderung das eigentliche Problem ist. Fragst du nach einem Logging pro Nutzerinstallation, bekommst du genau das, mit einer Kaskade von Fallbacks, damit es „funktioniert“, auch wenn die Plattform das gar nicht will. Dem Modell ist dein Latenzbudget, deine Datenschutzstrategie und dein Bereitschaftsdienst egal. Das ist kein Fehler des Tools. Es ist die Stellenbeschreibung des Platzes, den es eingenommen hat. Und der andere Platz, der des Neinsagers, bleibt leer, solange du nicht selbst dort sitzt.

Wie sieht es also aus, wenn man dort sitzt? Im Wesentlichen drei Dinge. Deine Nutzer gut genug kennen, um zu erkennen, wenn eine Anforderung ihren Interessen widerspricht. Die Kopplung deines Systems gut genug verstehen, um den Wirkungsradius einer Einzeilenänderung abzuschätzen. Und bereit sein, das unangenehme Gespräch mit demjenigen zu führen, der die Anforderung geschrieben hat, und zwar bevor der Code existiert, nicht in einer Postmortem-Runde. Nichts davon verlangt Kästchen-und-Pfeile-Diagramme in einem Wiki, das niemand liest. Alles davon verlangt Urteilsvermögen, das sich nicht an ein Tool delegieren lässt, das nie widerspricht.

Architekturentscheidungen, die du bereits triffst

Du brauchst den Titel nicht, um Architekturentscheidungen zu treffen. Du triffst sie jede Woche, mitten in ganz gewöhnlichen Tickets. Wo die Validierung stattfindet (Client, API oder Datenbank). Ob ein Aufruf synchron oder in einer Warteschlange erfolgt. Was geloggt wird und was bewusst nicht. Die Form einer neuen Tabelle und auf welche Tabellen sie per Fremdschlüssel verweist. Jede dieser Entscheidungen ist eine Wette auf die Zukunft, und jede schränkt die nächsten zehn Tickets ein oder ermöglicht sie. Der Install-Logging-Diff sah nach einer Monitoring-Aufgabe aus. In Wirklichkeit war es eine Datenschutzentscheidung, eine Sicherheitsentscheidung und eine Produktentscheidung im Kostüm einer Einzeilerei.

Hier das Vorher, also das, was der Assistent getreu der Anforderung „log who installed“ produziert hat:

async function logInstall(req, res) {
let identity = null;
try {
identity = { email: await getUserEmail(req) };
} catch {
try {
identity = { userId: await getUserId(req) };
} catch {
identity = { note: "install without identity" };
}
}
await db.installs.insert({ ...identity, at: new Date() });
res.redirect("/welcome");
}

Fünfzehn Zeilen, drei Fehlerpfade und ein Schema, das E-Mail-oder-UserID-oder-keins für immer abbilden muss. Jeder Fallback koppelt den Installationspfad leise an eine Identitäts-API, sodass ein Ausfall eines einwilligungspflichtigen Dienstes jetzt dein Onboarding verlangsamen oder zerstören kann. Und die Zeile „jemand hat installiert, wir wissen nicht wer“ ist analytisch nutzlos. Sie sagt dem Marketing nichts, womit es arbeiten könnte. Die Anforderung wurde wörtlich erfüllt und im Sinn verfehlt.

async function logInstall(req, res) {
await db.installs.insert({ at: new Date() });
res.redirect("/welcome");
// Email is collected on the welcome screen, with consent,
// posted asynchronously — and never gates the install path.
}

Das Nachher hat vier Zeilen. Aber beachte, was sich tatsächlich geändert hat: nicht der Code, sondern die Anforderung. Das Ziel war nie „eine E-Mail-Adresse erfassen“, sondern „Installationen messen und neue Nutzer nachfassen“. Ein Zeitstempel misst Installationen. Der Willkommensbildschirm, auf dem der Nutzer ohnehin eine Einwilligungsabfrage sieht, ist der richtige Ort, um asynchron nach der E-Mail-Adresse zu fragen, wo ein Fehler nichts kostet. Der Architekturschritt bestand nicht darin, weniger Code zu schreiben. Er bestand darin, neu zu verhandeln, wofür der Code eigentlich da ist.

Eine Gewohnheit, die sich lohnt: Bevor du eine nicht triviale Änderung machst, erstelle eine zweiminütige Kopplungsinventur. Frag dich, was dieser Code aufruft, was ihn aufruft und was kaputtgeht, wenn eines davon langsam, ausgefallen oder abgekündigt ist. In der Vorher-Version hing der Installationspfad von zwei Identitätsdiensten ab, von denen er gar nichts wissen musste. In der Nachher-Version hängt er von einer Tabelle ab. Diese Anzahl von Abhängigkeiten, nicht die Zeilenzahl und nicht die zyklomatische Komplexität, sagt deine künftigen Vorfälle voraus. Dasselbe Muster sieht man bei AI-Coding-Assistenten, die auf vorhersehbare, testbare Weise scheitern: Die Ausgabe wirkt lokal plausibel und ist global gekoppelt.

ADRs vs. Stammeswissen: Wann was gewinnt

Ein Architecture Decision Record ist bewusst unspektakulär: eine Seite mit Kontext, Entscheidung, betrachteten Alternativen und akzeptierten Konsequenzen. Das war’s. Keine Zeremonie, kein Freigabeprozess, außer du willst einen. Dass ADRs im KI-Zeitalter von „nett zu haben“ zu Pflicht geworden sind, liegt am Gedächtnis. Das Modell hat keines. In sechs Monaten zeigt jemand einem Assistenten das Installationsmodul und bittet um eine Änderung, und die sorgfältige Begründung zu Einwilligung und Plattformrichtlinien ist verschwunden, es sei denn, sie steht dort, wo Menschen und Tools sie finden. Ein ADR im Repository wird von jedem gelesen, der den Code danach anfasst, egal ob Mensch oder Maschine.

Stammeswissen gewinnt in manchen Situationen tatsächlich, und so zu tun, als wäre das nicht so, ist der Grund, warum ADRs ihren bürokratischen Ruf haben. Ein Zweierteam, das einen Prototyp mit einer Lebensdauer von wenigen Wochen baut, braucht keine Entscheidungsprotokolle. Die Entscheider sitzen nebeneinander, und der Code wird ohnehin neu geschrieben. Mündlicher Kontext ist in dieser Größenordnung schneller, reicher und billiger. Das Problem ist, dass Teams den Moment selten bemerken, in dem sie die Schwelle überschreiten: der erste neue Kollege, das erste Team, das deine API nutzt, der erste Vorfall, bei dem auf die Frage „Warum machen wir es so?“ niemand eine Antwort hat.

  • Die Entscheidung ist teuer umzukehren: Schemaänderungen auf Live-Daten, öffentliche API-Verträge, Vendor-Lock-in.
  • Die Entscheidung überschreitet eine Teamgrenze, sodass die Betroffenen beim Treffen nicht dabei sind.
  • Du hörst die künftige Frage schon: „Warum um Himmels willen haben wir es so gemacht?“
  • Ein KI-Tool hat die Implementierung erzeugt, sodass nie ein Mensch die Begründung laut formulieren musste.
  • Der Trade-off ist nicht offensichtlich: Du akzeptierst bewusst echte Kosten (Latenz, Datenschutzfläche, operativer Aufwand).

Der vierte Punkt ist der neue. Wenn ein Mensch Code schreibt, hinterlässt die Begründung Spuren: Commit-Nachrichten, PR-Diskussionen, die Form des Versuchs selbst. Wenn ein Assistent den Code schreibt, existiert die Begründung nur kurz in deinem Kopf und dann nirgends mehr. Der ADR ist das Artefakt, das ein Review überhaupt möglich macht, denn er gibt Reviewern etwas, gegen das sie den Code prüfen können. Ohne ihn verkommt das Review zu Stilkommentaren, während die Architektur langsam abdriftet.

Notizbuch mit handgezeichneten Kästchen-und-Pfeile-Diagrammen und einem Füllfederhalter im weichen Fensterlicht.
Ein ADR ist eine Seite, die den Diff lange überdauert, den niemand mehr im Kopf hat.

Reversible vs. irreversible Entscheidungen im Systemdesign

Die nützlichste Frage im Werkzeugkasten des Architekten lautet: Wie teuer ist es, meine Meinung zu ändern? Manche Entscheidungen sind Türen mit zwei Richtungen. Ein Logformat, eine interne Funktionssignatur, ein Cache-TTL: Dafür kannst du an jedem Nachmittag zurückgehen. Andere sind Einbahntüren. Ein öffentlicher API-Vertrag, gegen den externe Clients integrieren. Ein Datenbankschema, das sechs Monate Produktivdaten angesammelt hat. Ein Einwilligungsprozess, auf dem deine rechtliche Position jetzt beruht. Sobald du durch eine Einbahntür gegangen bist, kostet die Revision nicht einen Refactor, sondern eine Migration, einen Abkündigungsplan und eine Entschuldigung.

Klassifiziere die Tür, bevor du baust, denn KI hat das Bauen billig gemacht, das Zurückbauen ist aber so teuer wie eh und je. Unbeschränkt entwirft ein Assistent dir gern dein Datenmodell, und der typische Fehler sind redundante Tabellen, doppelte Spalten und Migrationscode, der auf Migrationscode gestapelt wird, weil jeder Prompt eine Tabelle hinzufügt, statt das Modell zu überdenken. Eine Tabelle mit Live-Daten zu löschen, die drei Services lesen, gehört zu den unangenehmsten Operationen unserer Branche. Gerade weil das Erzeugen eines Schemas so billig ist, verdient das Schema teures Nachdenken. Investiere dein Abwägungsbudget proportional zur Unumkehrbarkeit und nicht proportional zur Schreibzeit des Codes. Dieses Verhältnis hat sich umgekehrt.

Meine Arbeitsregel: Wenn eine Entscheidung Daten berührt, die du nicht neu erzeugen kannst, oder eine Schnittstelle, auf die sich jemand außerhalb deines Teams verlassen wird, bekommt sie einen ADR und ein zweites Paar Augen, bevor die Implementierung beginnt. Alles andere wird ausgeliefert und iterativ verbessert. Diese Regel skaliert vom Solo-Projekt bis zum Plattformteam ohne Anpassung, und sie ist der Unterschied zwischen schnell vorankommen und schnell in eine Richtung vorankommen, aus der du nicht mehr heraukommst.

Anforderungen wie ein Architekt hinterfragen

Der unbequeme Kern des Architektenjobs ist, Leuten Nein zu sagen, die über dir stehen. „Log who installed“ klang nach einer Anforderung, war aber in Wahrheit eine Lösung, die sich jemand für das Ziel „Installationen messen und neue Nutzer nachfassen“ ausgedacht hatte. Architekten übersetzen Lösungen zurück in Ziele und bieten dann einen günstigeren Weg zum Ziel an. Genau diese Übersetzung ist der ganze Trick, und kein Tool beherrscht sie, weil das Design eines Tools auf Compliance ausgelegt ist. Manche Ingenieure füttern ihren Assistenten mit Nutzerkontext und bekommen damit brauchbares Urteilsvermögen heraus. Das hilft am Rand, aber das Modell wird nie in ein Meeting gehen und dem Marketing sagen, dass sein Follow-up-Mail beim Installationszeitpunkt nicht stattfindet.

  1. Formuliere das Ziel zurück, nicht die Lösung: „Wir wollen Installationen messen und neue Nutzer erreichen.“
  2. Biete den günstigeren Weg und sein Ergebnis an: Zeitstempel-Logging misst Installationen zuverlässig.
  3. Benenne, was der teure Weg tatsächlich kostet: Reibung bei der Einwilligung, ein gekoppelter Installationspfad, Zeilen, die das Marketing nicht nutzen kann.
  4. Gib ihnen eine echte Wahl: „Wenn die E-Mail-Adresse wichtig ist, fragen wir auf dem Willkommensbildschirm nach. Hier ist die Eintagesversion davon.“
  5. Halte fest, was entschieden wurde, damit die nächste Person es nicht von vorne diskutiert.

Jetzt zum ehrlichen Einwand, denn er verdient Aufmerksamkeit: Niemand wurde befördert. Wahrscheinlicher ist, dass du zur Haftungsfläche für Entscheidungen wirst, die ein Modell getroffen hat, bei gleichem Gehalt und mit weniger vom spaßigen Teil. Ich glaube nicht, dass das falsch ist. Ich halte es für einen Grund, die Dokumentationsgewohnheit ernst zu nehmen, statt sie auszulassen. Ein ADR-Verlauf ist auch ein Papierweg. Die Person zu sein, die entschieden hat, ist nur dann ein Risiko, wenn man die eigene Begründung nicht vorweisen kann. Wer festgehalten hat „Wir haben Zeitstempel statt E-Mail-Erfassung gewählt, weil die Plattform Identitätsdaten einschränkt“, ist abgesichert. Wer das gemergt hat, was der Assistent ausgespuckt hat, ist es nicht.

Entwickler vs. Architekt: Wann welche Rolle gewinnt

Das ist keine Rangliste, sondern ein Moduswechsel. Die Kunst besteht darin zu wissen, welchen Modus die anstehende Arbeit braucht. Ein paar konkrete Fälle aus meinem eigenen Backlog:

  • Gut spezifizierter Bugfix, bekannter Wirkungsradius: Der Entwicklermodus gewinnt. Reproduzieren, fixen, testen, ausliefern. Architektonisches Abwägen ist hier Prokrastination im Blazer.
  • Prototyp zur Validierung der Nachfrage: Entwicklermodus. Der Code wird neu geschrieben, wenn er funktioniert, und gelöscht, wenn nicht. ADRs für ein Wegwerfprojekt sind Verschwendung.
  • Greenfield-Feature mit unscharfen Anforderungen: Zuerst Architekturmodus, und sei es nur für eine Stunde. Unschärfe ist der Punkt, an dem KI-generiertes Tempo den größten Schaden anrichtet.
  • Alles, was Geld, Identität oder Einwilligung berührt: Architekturmodus, ohne Ausnahme. Die Kostenasymmetrie zwischen Bauen und Zurückbauen ist hier am schlimmsten.
  • Schemaänderungen auf Live-Daten oder Änderungen an öffentlichen APIs: Architekturmodus mit ADR, gemäß der Reversibilitätsregel.
  • Zweierteam, Codebasis jünger als sechs Monate: Entwicklermodus mit einer laufenden Notizdatei. Das volle Zeremoniell bringt noch nichts.
  • Regulierter Bereich oder mehrere konsumierende Teams: Architekturmodus mit Protokollen, denn das „Warum“ werden Prüfer und Fremde fragen, nicht Freunde.

Der Fehlermodus besteht in beiden Richtungen darin, in einem Modus stecken zu bleiben. Entwickler, die nie umschalten, liefern elegante Implementierungen der falschen Sache. Architekten, die nie herunterschalten, produzieren Diagramme für Systeme, die es nicht gibt. Die Leute, die ich im Team am wenigsten verlieren möchte, sind die, die beides am selben Nachmittag tun: um 10 Uhr über das Datenmodell streiten und um 14 Uhr den Off-by-one-Fehler fixen, ohne sich zu beschweren, dass das unter ihrer Würde ist. Wenn du deinen Review-Prozess um KI-Ausgaben herum aufbaust, lohnt es sich, nachzulesen, wie agentische Coding-Tools Schleifen, Kontext und Berechtigungen strukturieren, denn der Moduswechsel muss innerhalb dieser Schleife stattfinden, nicht danach.

KI wird für immer bereitwillig das Falsche in hohem Tempo bauen. Die Aufgabe des Architekten ist es, zu entscheiden, was das Richtige ist, und den Grund aufzuschreiben, bevor die Begründung verdunstet.

Ein Bauplan mit leuchtenden Verbindungslinien zwischen gezeichneten Formen, ausgebreitet neben einem Laptop.
Architektur heißt, vorab festzulegen, welche Linien überhaupt existieren dürfen, bevor jemand sie zeichnet.

Die Empfehlung: Nimm die Beförderung an

Hier meine Position, und sie lautet nicht „es kommt darauf an“: Standardmäßig in den Architekturmodus für alles, was dein Datenmodell, einen externen Vertrag oder deine Sicherheitslage berührt, und für alles Abgeschlossene im Entwicklermodus bleiben. Die Aufteilung wird nicht 50/50 sein. Für die meisten Ingenieure sind es 20 % Architektur und 80 % Bauen, wie immer. Was sich geändert hat: Das Bauen ist schnell geworden, und die Kosten fürs Überspringen der 20 % sind genau um den Geschwindigkeitsfaktor gestiegen. Je mehr vom Tippen du delegierst, desto stärker konzentriert sich dein Wert in dem Teil, den du nicht delegieren kannst.

Das Starterpaket besteht aus drei Gewohnheiten, und alle drei kannst du diese Woche einrichten. Erstens: Leg eine ADR-Vorlage in deinem Repository an, mit Kontext, Entscheidung, Alternativen, Konsequenzen, eine halbe Seite, und schreib einen, sobald du einen echten Trade-off akzeptierst. Zweitens: Füg jedem Epic eine zweiminütige Kopplungsinventur hinzu. Was ruft das auf, was ruft es auf, was bricht, wenn diese Aufrufe fehlschlagen. Drittens: Nimm die Reversibilitätsfrage in deine Ticketvorlage auf: „Wenn das falsch ist, was kostet es, unsere Meinung zu ändern?“ Lautet die Antwort „eine Migration und eine Entschuldigung“, bremse ab. Lautet sie „einen Nachmittag“, nicht.

Der Coding-Job verschwindet nicht, nur der Tipp-Job. Beides war nie dasselbe, und die Leute, die still in Panik geraten, sind die, deren Rolle still auf das Übersetzen von Tickets in Syntax geschrumpft ist. Wenn du Diffs liest und dich fragst „Warum ist das an eine Identitäts-API gekoppelt?“, hast du den Job des Architekten schon gemacht. Die einzige echte Veränderung ist, dass es jetzt offiziell, dokumentiert und deins ist. Nimm die Beförderung an.