Vom Senior Developer zum AI-Native Developer: Wo ich nach 24 Jahren stehe

Ich bin seit 24 Jahren Softwareentwickler, fast die ganze Zeit in der Webentwicklung, die meiste davon mit PHP. Und ich schreibe heute kaum noch eine Zeile Code selbst.

Das klingt nach einem Widerspruch, und eine Weile hat es sich für mich auch so angefühlt. Mit diesem Beitrag fange ich an, den Weg dahin aufzuschreiben: wo ich herkomme, wo ich gerade stehe und warum ich glaube, dass die Frage „Was macht ein Senior Developer eigentlich noch?“ gerade neu beantwortet werden muss.

Januar 2023: kleine Funktionen und viel Copy & Paste

ChatGPT kam am 30. November 2022 heraus. Im Januar danach habe ich angefangen, es ernsthaft bei der Arbeit zu nutzen.

Am Anfang war das überschaubar. Ich habe mir kleine Funktionen schreiben lassen, meistens ein paar Zeilen: eine Hilfsfunktion, eine Umrechnung, ein regulärer Ausdruck, bei dem ich sonst zehn Minuten in der Dokumentation gesucht hätte. Den Code habe ich gelesen, selbst getestet und selbst eingebaut.

Die Rollen waren klar verteilt. Ich war der Entwickler, die KI war eine Art sehr schnelle Nachschlagehilfe. Wenn etwas nicht stimmte, habe ich es gesehen, weil ich jede Zeile ohnehin in der Hand hatte.

Dann wurde es mehr, und das Kopieren nervte

Mit der Zeit wurden die Aufgaben größer. Aus einer Funktion wurde eine Klasse, aus einer Klasse ein kleines Modul. Und damit wurde ein Teil der Arbeit lästig, der mit Programmieren wenig zu tun hat: Code hin und her kopieren.

Ich habe Dateien in den Chat kopiert, damit das Modell den Zusammenhang kennt. Die Antwort ging zurück in den Editor. Dann kam eine Fehlermeldung, und die wanderte wieder in den Chat. Irgendwann war der Engpass die Zwischenablage.

Agenten in der Konsole

Der nächste Schritt kam mit den Agenten, bei mir vor allem Claude Code von Anthropic. Der Unterschied ist grundsätzlich: So ein Agent arbeitet direkt im Projekt. Er liest die Dateien selbst, ändert sie selbst, startet die Tests selbst und liest die Fehlermeldungen selbst.

Das Kopieren fiel weg. Aber es fiel noch etwas anderes weg, und das habe ich erst später gemerkt: Ich hatte nicht mehr jede Zeile in der Hand. Der Agent ändert in einem Durchgang fünf Dateien. Ich lese den Diff hinterher, aber ich habe ihn nicht selbst getippt.

Wo ich heute stehe

Heute sieht ein normaler Arbeitstag bei mir so aus: Ich beschreibe, was passieren soll. Ein Agent plant und zerlegt die Aufgabe. Die eigentliche Umsetzung übernimmt oft ein lokales Modell, das auf einem eigenen Rechner im Netz läuft und nichts kostet. Am Ende läuft ein Prüfskript über alles: statische Analyse, Coding-Standard, Tests.

Ein Beispiel von heute, direkt aus diesem Blog: Antworten auf Kommentare standen bisher flach untereinander, statt eingerückt unter dem Kommentar, auf den sie sich beziehen. Programmiert habe ich die Lösung nicht. Ich habe nur den Auftrag dafür geschrieben, mit den vier Dateien, die sich ändern dürfen, einer genauen Beschreibung des Ergebnisses und dem Test, der am Ende beweisen muss, dass es funktioniert. Das lokale Modell hat gut zehn Minuten daran gearbeitet und sich dann mit „fertig“ zurückgemeldet.

Und es war tatsächlich fast fertig. Nur der Test hatte einen merkwürdigen Namen und prüfte umständlicher als nötig, das war in zwei Minuten korrigiert. Entscheidend war etwas anderes: Ich habe das Prüfskript danach selbst noch einmal laufen lassen, statt mich auf die Erfolgsmeldung des Modells zu verlassen.

Das ist inzwischen meine wichtigste Regel: Die KI darf nicht selbst sagen, dass sie fertig ist. Ein Modell meldet „alles grün“ auch dann, wenn es nicht stimmt. Diesen Satz schreibt es genauso flüssig wie den Code, ob er zutrifft oder nicht. Was zählt, ist der Exit-Code eines Prüflaufs, den ich selbst gestartet habe.

Und was macht dann noch der Senior?

Wenn ich nicht mehr tippe, was mache ich dann eigentlich? Diese Frage hat mich eine Weile beschäftigt, und meine Antwort ist im Moment diese:

Die Erfahrung ist nicht weniger wert geworden. Sie wird nur an einer anderen Stelle gebraucht. Früher steckte sie im Code, den ich geschrieben habe. Heute steckt sie in drei anderen Dingen:

• Im Auftrag. Ein Modell setzt ziemlich genau um, was ich beschreibe. Wer nach 24 Jahren weiß, welche Randfälle es gibt, schreibt sie in den Auftrag, bevor sie zum Fehler werden.
• In der Prüfung. Ich erkenne in einem Diff schneller als jedes Modell, wo etwas in einem halben Jahr wehtut: eine Abfrage ohne Grenze, ein Test, der nichts beweist, eine Stelle, an der jemand fremde Daten sehen könnte.
• In der Verantwortung. Wenn der Code in Produktion geht, steht mein Name dran, nicht der des Modells. Das ändert sich nicht dadurch, dass ich ihn nicht getippt habe.

Deshalb glaube ich nicht, dass Senior-Entwickler überflüssig werden. Aber ich glaube, dass „Senior“ bald etwas anderes heißt als bisher.

Was ich bisher mitnehme

• Der Engpass wandert. Erst war es das Wissen, dann das Tippen, dann die Zwischenablage. Jetzt ist es die Prüfung. Wer schneller Code erzeugt, braucht mehr Kontrolle.
• Gute Aufträge sind Handwerk. Zieldateien, Akzeptanzkriterien, ein Test als Beweis: Das schreibt sich nicht nebenbei. Es ist die Stelle, an der meine Erfahrung am meisten bringt.
• Lokale Modelle sind billig, aber nicht umsonst. Sie kosten kein Geld, aber Zeit: Sie sind langsamer und machen mehr Flüchtigkeitsfehler. Ohne eigene Prüfung würde ich ihnen nichts überlassen.
• Das ist mein Weg, nicht der einzige. Andere kommen mit anderen Werkzeugen und anderen Regeln zum Ziel. Ich zeige hier, was bei mir funktioniert und was nicht.

Wie es hier weitergeht

Auf diesem Blog und in kurzen Videos zeige ich, wie ich den Schritt vom Senior Developer zum AI-Native Developer gehe. Ganz praktisch, an meinen eigenen Projekten, mit den Aufträgen, den Prüfskripten und den Fehlern, die dabei passieren.

Als Nächstes schreibe ich darüber, wie so ein Auftrag an ein Modell konkret aussieht und warum er kürzer sein darf, als man denkt, aber nie ungenau.