Unsere Eltern als „Citizen Developer“ – und wie wir den Code bereinigen können

Wenn ich mit Klient:innen über ihre Herkunftsfamilie spreche, taucht früher oder später diese leise, manchmal bittere Frage auf:

„Warum haben meine Eltern das nicht besser gemacht?“

Ich möchte dir heute ein Bild anbieten, das entlastet – ohne zu beschönigen.

Eltern als Citizen Developer

In der IT-Welt gibt es sogenannte „Citizen Developer“. Das sind Menschen, die keine ausgebildeten Softwareentwickler sind, aber trotzdem Anwendungen bauen. Mit Low-Code- oder No-Code-Tools probieren sie aus, testen, verwerfen, starten neu – solange, bis es irgendwie funktioniert.

Das Ziel: Eine Lösung, die im Alltag hilft.

Und jetzt stell dir vor: Unsere Eltern sind genau das. Citizen Developer im Projekt „Kind großziehen“.

• Keine Ausbildung.
• Kein Handbuch.
• Keine Dokumentation.

Nur ein neues, hochkomplexes „System“, das plötzlich live geht – mit Schlafmangel als Dauerzustand.

Kein Clean Code, keine Doku – nur Versuch und Irrtum

Professionelle Entwickler achten auf klare Strukturen, saubere Architektur und nachvollziehbare Dokumentation. Citizen Developer? Die wollen erstmal, dass es läuft.

Und so ist es auch bei Eltern.

Sie probieren:

• „Wenn ich streng bin, hört es vielleicht.“
• „Wenn ich nachgebe, gibt es weniger Stress.“
• „Wenn ich viel arbeite, ist zumindest finanziell Sicherheit da.“

Sie entwickeln Lösungen für akute Probleme – aber selten mit Blick auf die langfristige Systemarchitektur.

Und dabei haben sie noch ihren „Hauptjob“: Ihr eigenes Leben auf die Kette zu kriegen. Beziehung. Arbeit. Eigene Verletzungen. Eigene unerfüllte Träume.

Das Ergebnis? Ein funktionierendes System – aber oft mit verschachteltem Code.

Warum wir uns manchmal selbst nicht verstehen

Viele erwachsene Kinder erleben genau das: Reaktionen, die sie sich selbst nicht erklären können. Beziehungsmuster, die immer wieder auftauchen. Emotionale „Bugs“.

Wie in einer schlecht dokumentierten Software weiß niemand so genau:

• Wo wurde diese Schleife eingebaut?
• Warum springt das System hier immer wieder an?
• Was genau löst diesen Fehler aus?

Und irgendwann braucht es Expert:innen.

In der IT sind das professionelle Entwickler, die sich durch fremden Code arbeiten. Im menschlichen System sind es Psychotherapeut:innen, Coaches oder Supervisor:innen.

Ich erlebe meine Arbeit als systemischer Coach oft genau so: Gemeinsam schauen wir uns Sequenzen an. Wir lesen zwischen den Zeilen. Wir versuchen zu verstehen: Wie wurde dieser Code eigentlich geschrieben?

Umschreiben statt neu programmieren

Wenn eine Code-Sequenz verstanden ist, kann sie umgeschrieben werden. Aber – und das ist entscheidend – in komplexen Systemen hängt alles mit allem zusammen.

Eine kleine Veränderung kann an anderer Stelle neue Effekte erzeugen.

Und hier liegt der große Unterschied zu Software: Menschen lassen sich nicht komplett neu programmieren.

Manchmal wäre das vermeintlich einfacher. Stattdessen arbeiten wir mit dem, was da ist. Mit gewachsenen Strukturen. Mit alten Abhängigkeiten. Mit emotionaler Historie.

Das braucht Geduld. Und oft mehrere Anläufe.

Warum sind dann die jüngsten Kinder nicht perfekt erzogen?

„Beim fünften Kind müssten Eltern es doch raus haben, oder?“

Theoretisch ja. Praktisch nein.

Denn jedes weitere Familienmitglied erhöht die Systemkomplexität. Familien funktionieren wie dynamische Software-Ökosysteme.

Jede neue „Instanz“ verändert das ganze Gefüge. Rollen verschieben sich. Allianzen entstehen. Alte Muster reagieren auf neue Konstellationen.

Wie in einem komplexen Softwaresystem kann eine Änderung in Modul A plötzlich einen Bug in Modul D auslösen – obwohl dort niemand bewusst etwas verändert hat.

Mehr Erfahrung heißt nicht weniger Komplexität. Oft heißt es: mehr Variablen.

Was dieses Bild bewirken kann

Dieses Bild von Eltern als Citizen Developer soll nicht relativieren, was wehgetan hat. Schmerz bleibt Schmerz.

Aber es kann helfen, zwei Dinge gleichzeitig zu halten:

1. Ja, manches was meine Eltern getan haben war nicht hilfreich.
2. Und gleichzeitig haben sie – nach ihren Möglichkeiten – ihr Bestes gegeben.

Sie haben gebaut, was sie bauen konnten. Mit dem Wissen, das sie hatten. Mit den Tools, die ihnen zur Verfügung standen.

Und wir?

Wir dürfen heute unseren eigenen Code lesen. Verstehen. Refaktorieren. Neue Funktionen hinzufügen.

Nicht perfekt. Aber bewusster.

Und vielleicht ist genau das die Weiterentwicklung, die jede Generation leisten darf: Ein Stück klareren Code schreiben als die davor.