Transcript
Kai Ole Hartwig: Willkommen Daniel zu unserer dritten Folge Secrets Not Included.
Kai Ole Hartwig: Wir möchten heute über AI-Agentic Coding sprechen.
Kai Ole Hartwig: Ich finde eigentlich ein spannendes Thema, weil es sich ja in den letzten Jahren so ein bisschen entwickelt hat vom KI-Agenten, äh Assistenten, nicht Agenten, der mehr oder weniger sinnvolle Ergänzungen gebracht hat.
Daniel Langemann: Genau.
Kai Ole Hartwig: über Vibe Coding hin zu Agentic Coding.
Kai Ole Hartwig: Ich finde, das ist so ein bisschen die Evolution.
Kai Ole Hartwig: Wie siehst du das denn?
Daniel Langemann: Ja, also ich habe immer ein lachendes und ein weinendes Auge bei dem Thema, weil das Thema hatten wir, glaube ich auf LinkedIn hatte ich das schon ein paar Mal, was genau Programmieren betrifft, was Softwareentwicklung betrifft und da fällt es schon schwer, Sachen zu unterscheiden.
Daniel Langemann: Und wenn man jetzt noch guckt, wo ist das Ganze hergekommen, also mich triggert das Thema Vibecoding dabei, deswegen habe ich ja gerade angefangen,
Daniel Langemann: KI unterstützt dich definitiv und da sind wir auch hergekommen und ich habe es noch nicht oft genug genutzt, beziehungsweise bei mir kommt das jetzt auch immer mehr auf und ich fange gerade an, damit rumzuspielen mit Agentic Coding.
Daniel Langemann: Ich habe aber definitiv einiges an Wissenslücken oder
Daniel Langemann: irgendwie brodelt, macht auch jeder gerade so sein eigenes Süppchen.
Daniel Langemann: Es wird irgendwie, ich habe nirgendwo groß was gelesen, dass Leute teilen, wie sie ihr Setup haben oder wie sie das nutzen.
Daniel Langemann: Jeder versucht da so sein eigenes Süppchen zu kochen ein bisschen.
Daniel Langemann: Das finde ich schade.
Daniel Langemann: Und vielleicht hast du noch ein paar Ideen.
Kai Ole Hartwig: Es ist sehr wenig im Moment, was direkt geteilt wird, was gut funktioniert, was Best Practices sind und so.
Daniel Langemann: Ja.
Kai Ole Hartwig: Das stimmt schon.
Kai Ole Hartwig: Ich finde aber, es ist erstmal wichtig zu verstehen, wo der Unterschied, also für mich zumindest persönlich, zwischen Vibe Coding und Agentic Coding ist.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Weil in meiner Gedankenwelt ist Vibe Coding etwas, ich sage sehr unspezifisch eigentlich, was ich haben möchte und
Kai Ole Hartwig: Die Agenten laufen los und erstellen etwas.
Kai Ole Hartwig: Relativ ungesteuert, sehr MVP-mäßig und gar nicht so hart auf...
Kai Ole Hartwig: Qualität, Sicherheit gepolt, sondern es läuft erst mal irgendetwas.
Kai Ole Hartwig: Also das ist für mich Vibe-Coding-mäßig, also quasi erstell mir eine performante Website, die verkaufen soll und das ist noch das Thema so ungefähr.
Kai Ole Hartwig: Und ich finde, Agentic Coding ist sehr viel spezifischer, sehr viel runtergebrochener.
Kai Ole Hartwig: Ich habe mein System, meine Frameworks dort stehen und dann gebe ich quasi die Aufgabe, die ich sonst selber bearbeiten würde, diesem Agent oder dem System,
Kai Ole Hartwig: das sich dann den Agents bedient und die arbeiten dann diese Lösung aus.
Kai Ole Hartwig: Also so ein bisschen, ich gebe den Auftrag weiter, so als würde ich ein Junior-Dev oder irgendjemand aus dem Team, wir haben über die Aufgabe gesprochen und dann geht es jetzt quasi an den Agenten und der bearbeitet sie dann.
Kai Ole Hartwig: Meine Erfahrung ist auch auf jeden Fall,
Kai Ole Hartwig: Man sollte immer erst diesen Planungsmodus benutzen.
Kai Ole Hartwig: Also nie direkt eingehen und sagen, okay, jetzt bau das.
Daniel Langemann: Ja.
Daniel Langemann: Jetzt nochmal zu deinem Beispiel.
Kai Ole Hartwig: Vielleicht, ja.
Daniel Langemann: Was du beschreibst, sind eigentlich unterschiedliche Projektrollen.
Daniel Langemann: Also bevor es das Thema KI gab, gab es den Product Owner, sagen wir mal.
Daniel Langemann: Und das ist das, was auch Vibe Coding das beschreibt.
Daniel Langemann: Es wurden unspezifische Anforderungen ins Team weitergegeben und gesagt, wir brauchen Feature XY oder ich möchte gerne eine Internetseite haben mit dies, das und jenem.
Daniel Langemann: Und mit Agentic Coding habe ich vielmehr den Eindruck, dass das in Richtung Lead Development geht.
Daniel Langemann: Der eine sagt gerne, was er hätte und auf dem anderen oder in dem anderen Bereich, gerade bei Agentic Coding, ist das eher schon, dass ich ganz klar sage, wie möchte ich was haben.
Daniel Langemann: Da geht es nicht darum, ich möchte eine Internetseite haben, sondern ich möchte mit dieser Technologie in diesem Design Pattern zum Beispiel, also dass ich anfange, Regeln vorzugeben und das unterscheidet sich halt wie damals oder früher klassisch auch, Product Owner und halt Lead Developer.
Daniel Langemann: Also ich glaube, das sind so die zwei großen Unterschiede.
Kai Ole Hartwig: Ich weiß nicht, für mich ist Vibe Coding irgendwo eigentlich zwischen Product Owner und Stakeholder.
Kai Ole Hartwig: Also von der Genauigkeit.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Ich finde ein Product Owner oder in der Projektrolle hatte man eigentlich eine sehr genaue Vorstellung schon, in welche Richtung soll das gehen.
Kai Ole Hartwig: Nicht technisch, aber von der Produktidee.
Kai Ole Hartwig: Und von dem Weg auch, auf den man sich machen möchte oder auf den man sich schon gemacht hat.
Kai Ole Hartwig: Und ich weiß nicht, also so ein bisschen dazwischen ist mein Gefühl, hängt aber sicherlich auch einfach von der Charakteristik des Product Owners, den man da hat.
Kai Ole Hartwig: stark ab.
Kai Ole Hartwig: Und was jetzt natürlich bedeutet, wenn wir mit diesem Agentic Coding arbeiten oder allgemein mit KI Support, wie auch immer geartet und in welchem Umfang, dass man viel, viel mehr Dinge aufschreibt, fällt mir ganz stark auf.
Kai Ole Hartwig: Wir definieren auf einmal in Markdown-Dateien
Kai Ole Hartwig: was heißt auf einmal, aber wir definieren in Markdown-Dateien sehr spezifisch auf einmal den Projektaufbau.
Daniel Langemann: Das, wo man
Kai Ole Hartwig: und sehr spezifisch, welchen Code-Style wir wo verwenden, was man früher sehr implizit irgendwie im Team hatte.
Kai Ole Hartwig: Ja, so diese stillen Konventionen irgendwie, das Wissen, okay, wir besetzen zum Beispiel auf PSR 12 oder, oder, oder.
Kai Ole Hartwig: Und wir bevorzugen bestimmte Patterns eigentlich im Team, um Probleme zu lösen.
Kai Ole Hartwig: Und das schreibt man auf einmal auf, weil der Agent das sonst gar nicht weiß oder gar nicht so erfasst, weil der natürlich nicht vor dem Programmieren überall immer wieder durchschaut und sagt, ah ja, das hier ist ein Symfony-Projekt und hey, hier in diesem Team wird dieses Pattern häufig benutzt.
Kai Ole Hartwig: Also das ist alles sehr viel spezifischer, sehr viel textlastiger geworden.
Kai Ole Hartwig: Sehr viel mehr natürliche Sprache.
Daniel Langemann: Ja, früher haben wir das mehr in Tickets gemacht, glaube ich.
Daniel Langemann: Also wir hätten es viel mehr machen müssen, wenn man das vergleicht.
Daniel Langemann: Also die Definition of Ready bei vielen Tickets war nicht erreicht, weil genau solche Infos fehlten, weil die im Team irgendwo existierten.
Daniel Langemann: Jeder wusste das oder es gab Absprachen.
Daniel Langemann: wenn man ehrlich gewesen wäre, hätte solche Sachen dann ins Ticket gemusst.
Daniel Langemann: Also es tut man allen Projektbeteiligenden leid, wo ich das nicht gemacht habe früher.
Daniel Langemann: Es hätte ins Ticket gemusst, um das vergleichen zu können.
Daniel Langemann: Dann wäre das, oder ist jetzt genauso der Stand,
Daniel Langemann: Wenn du ein Ticket vernünftig ausgearbeitet hast, hast du eigentlich schon sehr gute Vorlage, um das der KI zu geben.
Daniel Langemann: Also als Entwickler natürlich werde ich dann hingehen und das noch anreichern mit Testfällen, sagen, welche Testfälle sollen wie funktionieren, sollen nicht funktionieren.
Daniel Langemann: Vielleicht schreibe ich die Testfälle auch selber, um das zu definieren, um sicherzustellen, dass Edge-Cases abgearbeitet werden.
Kai Ole Hartwig: Mhm.
Daniel Langemann: Aber grundlegend ist da schon sehr viel Ähnlichkeit zwischen einem vernünftigen Ticket und der Spec oder der Anforderung, die ich jetzt in Markdown mittlerweile schreibe.
Kai Ole Hartwig: Ja, aber in dem Ticket, also das Ticket kannst du ja weiter benutzen, also wenn ich mir zum Beispiel OpenCode AI anschaue, das kann ich auch mit GitLab benutzen auf unterschiedliche Art und Weise, aber da kann ich ja meine Tickets benutzen, also das muss ich ja gar nicht in Markdown-Fall schreiben, aber was ich ins Markdown-Fall ja schreiben muss, sind diese Rahmenbedingungen.
Kai Ole Hartwig: die Framework-Bedingungen und alles, was sich da abspielt, damit das Wissen immer präsent ist, immer wieder im Kontext ist, den man ja auch erstaunlicherweise sehr, sehr häufig lehren muss.
Kai Ole Hartwig: Das ist ja irgendwie schon ein bisschen komisch.
Kai Ole Hartwig: Also ein Junior-Dev habe ich beigebracht, hey, das Wissen,
Kai Ole Hartwig: Das sind hier so diese Rahmenbedingungen, das ist quasi der Kontext, den habe ich ja nicht jeden Morgen resettet und das neu reingekippt.
Daniel Langemann: Also mir hat man sowas gesagt in der Ausbildung, dass ich mich übers Wochenende resettet habe.
Kai Ole Hartwig: Ja, vielleicht nach dem Wochenende oder so, oder nach Phasen in der Berufsschule oder whatever, aber das eigentlich...
Kai Ole Hartwig: sollte es so gewesen sein, dass dieses Wissen, was einmal vorhanden war, im Projekt- oder im Produkt-Kontext, ja nicht direkt am nächsten Tag wieder weg war.
Kai Ole Hartwig: Und was ich halt beobachte, ist, man muss diesen Kontext in der Zusammenarbeit mit der KI sehr viel häufiger quasi nach jeder Aufgabe lehren.
Kai Ole Hartwig: Das finde ich eigentlich auch ganz interessant.
Kai Ole Hartwig: Ganz interessant, dass sich sonst halt auch die Ergebnisse verschlechtern.
Kai Ole Hartwig: Das ist etwas, was ich sehr spannend finde, weil wir ja als Menschen irgendwie anders funktionieren.
Daniel Langemann: Ja.
Kai Ole Hartwig: Wenn wir mehr Wissen und mehr Erfahrung ansammeln, werden ja nicht automatisch unsere Ergebnisse schlechter, die wir liefern.
Daniel Langemann: Ja, aber wir haben auch, sagen wir mal, ein beschränktes Fenster an Kontext, würde ich jetzt mal ganz simpel sagen.
Daniel Langemann: Also es gibt Metriken, oder habe ich zumindest auch gelesen, dass auch Entwickler nicht alles überblicken.
Kai Ole Hartwig: Natürlich nicht.
Daniel Langemann: Also Lines of Codes gibt es einfach ein gewisses Limit, was man erreichen kann, wo du dann auch Sachen nicht mehr im Kopf hast.
Daniel Langemann: Also das ist das eine.
Daniel Langemann: Da hast du auch schnell den Kontext oder dein Kontext Limit erreicht.
Daniel Langemann: Und also das ist das eine.
Daniel Langemann: Da will ich jetzt nicht sagen, dass der eine mehr oder andere weniger hat, aber bei KI habe ich jetzt auch einen Artikel gelesen, dass es sinnvoll ist, also je nach Model, so um die 50 Prozent meine ich waren das.
Daniel Langemann: Wenn du 50 Prozent erreichst vom Kontext oder genutzten Kontext, geht die Qualität wohl massiv nach unten.
Daniel Langemann: Also damit passiert genau das, was du gerade beschrieben hast, dass man dann Kontext immer resetten sollte.
Daniel Langemann: meine, du willst gerade auch auf die Agents MD so ein bisschen hinaus.
Daniel Langemann: Eine Möglichkeit ist ja so, oder der erste Berührungspunkt für mich war es zum Beispiel mit KI, genau dieses, ich möchte nicht immer wieder erwähnen, mit nutze diesen PSR, in diesem Ordner sollen die Dokumente, also die
Daniel Langemann: die Dokumentationen liegen, in diesem Ordner liegen die Source-Dateien.
Daniel Langemann: Solche Sachen möchte man nicht immer wieder schreiben.
Daniel Langemann: Und dann war es so der erste Moment, ne, und egal welche KI man nutzt.
Daniel Langemann: Also es gibt die AgentsMD, die kristallisiert sich, glaube ich, gerade so ein bisschen als Standard raus, dass man da vieles unterbringt.
Daniel Langemann: Oder zum Beispiel OpenAI sagt, dass er vernünftige Umlaute benutzen soll und den Schreibstil per Ich oder per Du.
Daniel Langemann: Also da kann man ganz viel unterbringen, was man im Projekt braucht.
Kai Ole Hartwig: Ja, genau.
Kai Ole Hartwig: Also die Agents-MD ist ja eins der Dinge.
Kai Ole Hartwig: Also ich glaube, das ist eigentlich der allgemeine Name, der sich so rauskristallisiert.
Kai Ole Hartwig: Cloud-MD gibt es auch noch, das ist dann wieder spezifischer.
Kai Ole Hartwig: Das ist so ein bisschen wie die Evolution bei Docker Compose.
Kai Ole Hartwig: Wir haben früher überall immer Docker Compose-YAML geschrieben.
Daniel Langemann: Vielen Dank.
Kai Ole Hartwig: Und jetzt haben wir zum Beispiel einfach gesagt, ah, wir wollen gar nicht Docker mehr so da drin haben, sondern es ist ja eigentlich ein Container und da gibt es halt die Compose-JAML.
Kai Ole Hartwig: Genauso, dass Docker-File jetzt Container-File heißt.
Kai Ole Hartwig: Und
Kai Ole Hartwig: Dann gibt es, glaube ich, auch noch Context-MD, was wieder das Gleiche ist wie Agent-MD und Cloud-MD, wobei da bin ich mir gar nicht so sicher mit der Context-MD.
Kai Ole Hartwig: Also ich finde, da ist noch sehr viel Bewegung und Ungenauigkeit und Veränderung drin.
Kai Ole Hartwig: Also man merkt, das entwickelt sich und...
Kai Ole Hartwig: es gibt noch keinen allgemeinen Standard.
Kai Ole Hartwig: Man hat sich irgendwie geeinigt darauf, es gibt eine Markdown-Datei und die wird halt gelesen und hoffentlich beachtet.
Daniel Langemann: Aber die meisten Agenten, also bei allem, was auf der Konsole läuft, habe ich jetzt den Init-Befehl gesehen und die erstellen so eine Datei.
Kai Ole Hartwig: Ja.
Daniel Langemann: Also CloudCode macht dann, glaube ich, seine CloudMD.
Daniel Langemann: Codex hat AgentsMD erstellt.
Daniel Langemann: Also die wissen da schon, was die nutzen.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Ja, du kannst aber ja auch bestehende Dateien noch reinholen, sowas wie eine Contribution MD oder Index MD, wenn du da die Informationen drin hast, dann kannst du die auch mitgeben, zumindest bei den meisten, glaube ich, also mit denen ich gearbeitet habe.
Daniel Langemann: Genau.
Kai Ole Hartwig: Keine Hand ins Feuer legen und jetzt behaupten, no, das geht überall.
Kai Ole Hartwig: Aber von dem, was ich mir angeschaut habe oder anschaue an Systemen, das sind ja vorwiegende Systeme, wo ich meine Modelle irgendwo selber hinlegen kann, entweder lokal oder auf dem Server und dann nutzen kann.
Kai Ole Hartwig: Ich bin ja nicht so der Freund davon, meine Daten durch die Weltgeschichte zu schicken.
Kai Ole Hartwig: Oder vielmehr die Projekt- und Kundendaten da irgendwo durch die Weltgeschichte schicken, immer so mit der
Kai Ole Hartwig: mit dem Gedanken dahinter, okay, wir filtern zwar eigentlich alles raus, es sollten keine persönlichen Daten da drin liegen und keine zu spezifischen Sachen.
Kai Ole Hartwig: Ach ja, und dann erstellt ihr halt trotzdem mal jemand ein Ticket, wo auf einmal Namen, E-Mail-Adressen, keine Ahnung was genannt sind.
Kai Ole Hartwig: Und wenn wir jetzt darüber nachdenken zu sagen, ah ja, wir machen mal so eine Pipeline und dann probiert,
Daniel Langemann: Mhm.
Kai Ole Hartwig: oder wir testen mal, ob dann so ein Agent nicht einfach die Tickets selbstständig triagiert und abarbeitet.
Kai Ole Hartwig: Dann kommen wir natürlich ganz schnell in die Bredouille, dass wir schützenswerte Daten durch die Weltgeschichte durchführen.
Kai Ole Hartwig: an Anbieter übermitteln und ja, ich, better safe than sorry, ne, an der Stelle so ein bisschen, lieber selber hosten und sagen, okay, dann haben wir vielleicht jetzt einfach ein anderes Modell, als da laufen würde, aber das macht auch die Aufgabe, es gibt ja gute Modelle, die man nutzen kann an der Stelle und ähm,
Kai Ole Hartwig: man ist ja gar nicht darauf angewiesen, die Daten Richtung Google oder OpenAI oder Ähnliches zu schicken.
Kai Ole Hartwig: Man kann ohne Probleme ja hingehen und sagen, okay, wir laden uns Modelle runter und wir betreiben die selber mit Olama und Ähnlichem und dann ist die Performance halt im Zweifelsfall einen Tacken schlechter,
Kai Ole Hartwig: was für das Ausprobieren erst mal aus meiner Sicht völlig okay ist.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Ich finde, das ist jetzt nicht unbedingt etwas, was wir so richtig aktiv einsetzen.
Kai Ole Hartwig: Also da bin ich eher beim assistierten Programmieren.
Kai Ole Hartwig: weil ich auch immer noch, also ich finde, das ist sehr aufwendig, ja, erst diesen Planungsmodus durchlaufen zu lassen, dann schaue ich die Ergebnisse an und review, die, dann lasse ich das Ganze nochmal durchlaufen und, ähm, schaue mir dann auch wieder die Ergebnisse an, mache dann irgendwie die Code Review tatsächlich und, ähm,
Kai Ole Hartwig: Also der Workflow fühlt sich einfach noch nicht so richtig gut an, was man jetzt irgendwie zweimal reviewer und dann wahrscheinlich noch eine Schleife nochmal dran hänge.
Kai Ole Hartwig: Ich hatte nämlich jetzt auch den Fall,
Kai Ole Hartwig: da hat der Agent eigentlich eine total, also eine Straightforward-Aufgabe aus meiner Sicht bekommen.
Kai Ole Hartwig: Da sollte einfach im Secret-Management was umgeschrieben werden, Dateinamen vereinheitlicht werden.
Kai Ole Hartwig: Wir hatten irgendwie historisch gewachsen, wie das manchmal so ist, einige mit Bindestrich-Dateinamen und einige mit Underscore.
Kai Ole Hartwig: So, das Klassische.
Daniel Langemann: Ja, easy.
Daniel Langemann: Ja.
Kai Ole Hartwig: Und
Kai Ole Hartwig: dann war halt die Aufgabe, hey, okay, vereinheitliche das bitte, es soll jetzt immer mit Underscore sein.
Kai Ole Hartwig: Ja, easy going, search and replace, würde man denken.
Kai Ole Hartwig: Naja, das End vom Lead ist, in der einen Datei haben wir jetzt alles mit Underscore.
Kai Ole Hartwig: Im Make-File steht jetzt alles mit Bindestrich.
Kai Ole Hartwig: Ja, da ist irgendwo was in der Kommunikation, glaube ich, schief gelaufen.
Kai Ole Hartwig: Ja.
Daniel Langemann: Aber das ist genau der Punkt, an dem ich auch immer wieder hänge.
Daniel Langemann: Also wo man sagt, das sind einfache Aufgaben, also bisschen weitere Aufgaben als so ein Refactoring mit der IDE, wo man drauf drückt und Methoden Namen ändert und dann läuft das Ding los und macht Sachen, wo du sagst, Alter, das verstehe ich nicht.
Daniel Langemann: Wie kommst du da drauf?
Daniel Langemann: Und das ist
Daniel Langemann: finde ich noch immer wieder schwer, also das einzufangen.
Daniel Langemann: Ich habe letztens noch den Tipp bekommen, also ich habe es noch nicht exzessiv benutzt, aber Specs-Driven Development, wo du wirklich noch genauer hingehst und wirklich Specs definierst und sagst, das sind die Sachen, da ist Logik.
Kai Ole Hartwig: Mhm.
Daniel Langemann: Das hat sich sehr interessant angehört und
Daniel Langemann: Ich wollte es auch ausprobieren, bin bis jetzt noch nicht ausgiebig dazu gekommen.
Daniel Langemann: Also ich denke mal, das werden wir bestimmt in der nächsten Folge irgendwann mal angehen.
Daniel Langemann: Das war nämlich sehr interessant.
Daniel Langemann: Aber für mich war es, also zumindest bis jetzt, ist mein Arbeitsstil so gewesen, dass ich zum Beispiel...
Daniel Langemann: gefühlte Code-Reviews wie früher auch mache.
Kai Ole Hartwig: Hm.
Kai Ole Hartwig: Hm.
Daniel Langemann: Also, dass ich zum Beispiel sage, ich habe einen Quelltext vor mir und sehe, oh mein Gott, eine Eindrückung ist, also, ach, was habe ich, Eindrückung, keine Ahnung, da wird irgendwie ein String exploded, weil wir brauchen die ersten zwei Zeichen, aber du brauchst keinen Explode, sondern lies einfach die ersten zwei Zeichen.
Daniel Langemann: Solche Sachen.
Daniel Langemann: Dann ist das jetzt so, dass ich hingehe und einfach mal einen schnellen Kommentar dran schmeiße, so ein To-Do.
Daniel Langemann: früher eigentlich für mich, mittlerweile mache ich das nur noch für die KI, weil ich dann durchgucke und sage, guck mal, da ist was, da ist was, da ist was, weil ansonsten prompte ich mich ja tot, wenn ich sage, in Datei XY aufzeile, so und so, hast du das, das habe ich schneller selbst geschrieben, den Code als den Prompt geschrieben und bis jetzt bin ich, also das ist so der Modus, in dem ich gerade bin, wo ich viele Kommentare reinschreibe und dann sage ich, guck mal, in der Datei habe ich Kommentare geschrieben,
Kai Ole Hartwig: Ja.
Daniel Langemann: Oder was schlägst du vor, wie würdest du das ändern?
Daniel Langemann: Dann sind wir in diesem Planungsmodus, von dem du gesprochen hast.
Daniel Langemann: Dann sagt er einmal, okay, dann mache ich das so und so.
Daniel Langemann: Dann sagt er einmal Daumen hoch.
Daniel Langemann: Er produziert das.
Daniel Langemann: Ich gucke einmal kurz drauf.
Daniel Langemann: Sage ja, passt oder passt nicht.
Daniel Langemann: Und dann kommt das ins Projekt.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Spannender Ansatz.
Kai Ole Hartwig: Ich mache das tatsächlich anders.
Kai Ole Hartwig: Also ich schreibe mehr in Tickets.
Kai Ole Hartwig: Und meine Feststellung ist tatsächlich bei so Standardaufgaben, die es eigentlich wie Sand am Meer gibt, ja, keine Ahnung, wir brauchen ein neues Inhaltselement und das soll dann wie eine Lightbox funktionieren oder irgendwie so ein Mist.
Kai Ole Hartwig: Gibt es eine Million Mal als fertige Lösung nichts Besonderes.
Kai Ole Hartwig: Und das funktioniert über die Tickets erstaunlich gut.
Kai Ole Hartwig: Die Ergebnisse sind auch
Kai Ole Hartwig: auch sehr passend.
Kai Ole Hartwig: Also da sind dann wirklich nur so Kleinigkeiten und ich stelle aber fest, bei sehr spezifischen Dingen
Kai Ole Hartwig: ist er manchmal einfach verwirrt.
Kai Ole Hartwig: Also irgendwie so, wie wenn man morgens um vier auf einmal anfängt, irgendwas zu programmieren, ohne Kaffee, noch halb schlafend und denkt, jetzt produziere ich den geilsten Code der Welt.
Kai Ole Hartwig: So kommt mir das manchmal auch so vor.
Kai Ole Hartwig: Also ich weiß nicht so genau.
Kai Ole Hartwig: Vielleicht liegt das auch an meinem Schreibstil bei so Aufgaben, dass der einfach nicht verständlich ist.
Daniel Langemann: Also ich habe auch mit dem geredet, aber nicht nett.
Kai Ole Hartwig: Ich habe auch bei einigen gelesen, dass sie jetzt mehr mit ihrem Computer reden.
Kai Ole Hartwig: und darüber tatsächlich quasi die Aufgaben definieren, was ich auch sehr spannend finde.
Kai Ole Hartwig: Eigentlich finde ich das sympathischer, aber ich meine jetzt wirklich mit dem Agent quasi die Aufgaben sprechend zu definieren, das finde ich eigentlich fast sympathischer, als die Sachen runterzuschreiben.
Kai Ole Hartwig: Ja, ich sage jetzt mal, labern kann ich ganz gut, manchmal.
Kai Ole Hartwig: Da finde ich Schreiben und gleichzeitig Denken und Definieren fast schwieriger.
Kai Ole Hartwig: als wenn ich dem System erzähle, was ich möchte.
Kai Ole Hartwig: Ich glaube, das muss ich vielleicht auch noch mal intensiver ausprobieren und sagen, okay,
Kai Ole Hartwig: ich schreibe quasi die Spezifikationen meiner Tickets oder meiner Aufgaben, indem ich dem Computer oder der KI das erzähle, die transkriptet das dann in das Ticket vielleicht rein und dann wird das Ticket abgearbeitet.
Kai Ole Hartwig: Vielleicht ist das ein Workflow, den ich mal ausprobieren sollte.
Kai Ole Hartwig: Wenn ich so jetzt darüber nachdenke, während ich darüber erzähle.
Daniel Langemann: Oh mein Gott, wie viele Metaebenen haben wir gleich?
Kai Ole Hartwig: Weiß ich nicht, aber ich habe jetzt auch festgestellt, in einem Projekt, in einem Produkt, das ich baue, bin ich jetzt tatsächlich hingegangen und habe mittlerweile das dritte Modell eingeführt, weil ich festgestellt habe, dass sehr spezifische Modelle
Kai Ole Hartwig: viel, viel geiler funktionieren als unspezifisch.
Kai Ole Hartwig: Ich habe ja zum Beispiel ein kleines visuelles Modell, das die Texterkennung macht bei Dateien und diesen Text dann halt rausschreibt, dass ein anderes Modell klassifiziert dann den Text und welche Inhalte da drin sind.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Und ein drittes Modell verwende ich dann, um bestimmte Texte zu generieren, weil die einen bestimmten Sprachstil und eine gewisse Genauigkeit haben und deswegen einfach nochmal extra feingetunt sind.
Kai Ole Hartwig: Ähm,
Kai Ole Hartwig: Und die Gesamtzeit, das ist das eigentlich Witzigste daran, die Gesamtzeit, die ich jetzt an KI-Minuten irgendwie verbrauche für diese Aufgabe, also abarbeiten über drei Schritte mit nochmal Q und so weiter und so fort, ist geringer, als wenn ich das in ein großes Modell, das alle Fähigkeiten hat, schmeiße.
Kai Ole Hartwig: Also das ist sehr, sehr spannend.
Kai Ole Hartwig: Ich finde auch Modelle,
Kai Ole Hartwig: die speziell auf PHP-Programmierung abgestimmt sind, funktionieren meistens noch besser als Modelle, die nur auf Programmierung abgestimmt sind.
Daniel Langemann: Welche meinst du genau?
Daniel Langemann: Also mir fallen da gar keine Namen ein.
Kai Ole Hartwig: Wow, muss ich jetzt nachschauen.
Daniel Langemann: Okay, also ich habe zum Beispiel...
Kai Ole Hartwig: Ich bin da total schlecht im Namen.
Kai Ole Hartwig: Also ich liefere dir das gerne nochmal nach.
Kai Ole Hartwig: Ich muss zugeben, ich habe jetzt den Modellnamen einfach leider nicht vorher rausgeschrieben.
Daniel Langemann: Aber wir sind Experten auf dem Gebiet.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Aber zum Beispiel halt DevStrawl ist etwas, was ich gerne zum Testen nutze in Projekten, wo Verschiedenes vorkommt.
Kai Ole Hartwig: JavaScript und PHP in einem Projekt, dann bin ich immer ein bisschen faul und sage, ja, jetzt benutze das einfach mal, was ich hier habe.
Kai Ole Hartwig: Nimm ein Ding, liefere mir das Ergebnis,
Daniel Langemann: Mhm.
Kai Ole Hartwig: Ähm, gerade wenn ich auch so ein bisschen zwischen den Aufgaben hin und her wechsle, was ja irgendwie vorkommt, dann habe ich hier HTML-Dateien, da JavaScript, hier PHP und dann doch wieder irgendwie so ein Container und Markdown und hast du nicht gesehen?
Kai Ole Hartwig: Ähm, und
Kai Ole Hartwig: Dann aber, wenn ich halt sage, ah ja, ich mache jetzt halt nur spezifische PHP-Sachen, zum Beispiel, ich weiß, GitLab liefert da auch in deren KI-Produkten extra Modelle und ich glaube, meine Lieblings-IDE hier, das gute alte PHP-Store macht das auch sehr spezifisch.
Kai Ole Hartwig: Ich setze das halt nur nicht mit Agents gerade an, weil da fehlt mir einfach so dieser Ansatz, wie
Kai Ole Hartwig: wie gehe ich hin und mache das so spezifisch, dass das sagt jetzt, ah, ich habe hier PHP-Dateien und jetzt nehme ich ein anderes Modell dafür.
Kai Ole Hartwig: Ich bin jetzt aber auch ehrlich gesagt noch nicht so durchgestiegen, wie zum Beispiel diese Language-Server-Protokoll-Integration bei OpenCode funktioniert.
Kai Ole Hartwig: Also wie viel Einfluss das zum Beispiel hat, da bin ich einfach noch dran, das rauszufinden.
Daniel Langemann: Was meinst du damit genau?
Daniel Langemann: Weil ich habe OpenCode jetzt auch diese Woche angefangen zu nutzen, außer dass ich sehr begeistert bin davon, bin ich glaube ich noch gar nicht so tief drin wie du.
Kai Ole Hartwig: Ich weiß gar nicht, ob ich tief drin bin, ja.
Kai Ole Hartwig: Ich probiere halt rum und und
Kai Ole Hartwig: gehe halt auch begeistert durch die Dokumentation durch, ja, so ganz altmodisch und sage, oh, ich habe eine Dokumentation und da steht ein Feature drin und jetzt, wie probiere ich das denn jetzt aus, ja, also OpenCode kommt ja irgendwie mit dieser Language-Server-Protokoll-Integration und kommt mit, also hat halt zum Beispiel auch für PHP oder für
Kai Ole Hartwig: TypeScript mit eslint und so Sachen, Integration, um das halt zu nutzen.
Kai Ole Hartwig: Aber welche Auswirkung das so hat, wenn ich die zum Beispiel ausschalte, ob das das jetzt schlechter macht, besser macht, da bin ich noch nicht hinter.
Kai Ole Hartwig: Also das ist etwas, wo ich sage,
Kai Ole Hartwig: Da muss ich nochmal mehr rein.
Kai Ole Hartwig: Was macht dieser Language Server Protokoll?
Daniel Langemann: Und ist das nur gefühlte Verbesserung?
Daniel Langemann: Weil bei mir war das so, ich habe vorher Codex genutzt und dann Open den neuen benutzt.
Daniel Langemann: Und das ist natürlich so, es fühlt sich alles neu an, alles toll, aber eigentlich das gleiche Modell dahinter.
Daniel Langemann: Also ich habe OpenAI weiter genutzt, weil ich genau diesen Effekt nicht haben wollte.
Daniel Langemann: Trotzdem habe ich das Gefühl gehabt, das Model macht viel bessere Sachen.
Daniel Langemann: Also das ist so diese gefühlte Wahrheit erstmal.
Daniel Langemann: Das ist...
Kai Ole Hartwig: Ja, ich möchte eigentlich halt auch noch den mal unser GitLab via MCP anbinden, dass ich nicht unbedingt sagen muss, ich habe jetzt eine Pipeline, wo Open Code drin läuft und selbstständig da zyklusmäßig arbeitet.
Daniel Langemann: Sachen besser werden.
Daniel Langemann: Aber jetzt, wenn du sagst, muss ich mal ausprobieren, diese ganzen Plugins.
Daniel Langemann: Vielleicht hilft das ja.
Kai Ole Hartwig: Oder vielleicht wäre es auch noch eine Idee, das über andere Systeme zu automatisieren.
Kai Ole Hartwig: Egal, zu viele Ideen.
Kai Ole Hartwig: Aber eigentlich möchte ich halt auch, dass das GitLab per MCP angebunden ist, damit ich da lokal besser mit interagieren kann.
Kai Ole Hartwig: Dass ich meinen Open Code in dem Fall ja lokal laufen lassen kann und irgendwie noch mit dem GitLab mehr interagiere.
Daniel Langemann: Mhm.
Kai Ole Hartwig: automatisiert.
Kai Ole Hartwig: Aber das sind halt alles noch so Sachen, wo ich sage, das probiere ich gerade aus, das ruckelt noch so vor sich hin, also es ist noch nicht so, dass ich sage, ich habe jetzt den Workflow, wo ich sage, ah, perfekt, wir haben damit
Kai Ole Hartwig: gehe ich jetzt hin, ich arbeite nur noch in meiner CLI, ich mache gar nichts mehr anderes auf.
Kai Ole Hartwig: Und die KI, wenn ich da eine Aufgabe gebe, dann programmiert die das, ich review nur noch und eigentlich bin ich der glücklichste Mensch auf der Erde, weil ich nie wieder wirklich arbeite oder so.
Kai Ole Hartwig: Weil ich auch sagen muss, ich mag einfach programmieren selber zu sehr.
Daniel Langemann: Ja.
Kai Ole Hartwig: Das ist vielleicht auch ein Problem, dass ich mich sehr wohl fühle in diesem ganzen, ach, ich schreibe, ich programmiere das mal eben.
Kai Ole Hartwig: Das ist ja so ein Prozess.
Kai Ole Hartwig: Ich fühle mich da furchtbar wohl drin.
Kai Ole Hartwig: Aber ich finde es spannend, was heute möglich ist.
Kai Ole Hartwig: Und es gibt ja noch tausend Konfigurationen irgendwie, wo ich mit Regeln arbeiten kann, nochmal unterschiedliche Tools anbinden kann.
Kai Ole Hartwig: Und das ist halt einfach nochmal ein...
Kai Ole Hartwig: sehr, sehr mächtiges Ding, was man irgendwie hat, wo man sich auch, also was man komplett lernen muss.
Kai Ole Hartwig: Also es ist ja nicht mehr irgendwie, dass man jetzt sagt, das ist ganz klassisches DevSecOps oder DevOps oder Dev oder Ops oder so, sondern es ist ja wirklich eine fast eigene Disziplin zu sagen, hier, das ist
Kai Ole Hartwig: gutes Agentic Coding.
Kai Ole Hartwig: Also ich finde das eine sehr, sehr steile Lernkurve, wobei sich so viel so schnell verändert.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Und eigentlich würde ich
Kai Ole Hartwig: gerne viel mehr darüber lesen, was sind die Best Practices, die andere nutzen und zwar in realen Projekten.
Kai Ole Hartwig: Also nicht in Projekten, die ich jetzt gerade auf der grünen Wiese angefangen habe, sondern wirklich in bestehenden Projekten hingehen und das als Tooling einzuführen.
Kai Ole Hartwig: Und
Kai Ole Hartwig: weil er bestehen, also ich finde, bestehende Projekte sind immer eine ganz andere Herausforderung, als zu sagen, wir fangen jetzt neu mit einem Projekt an.
Kai Ole Hartwig: Ja, in einem neuen Projekt starte ich auf der grünen Wiese, da kann ich von Anfang an natürlich alles so definieren, dass das total schön ist, dass alles aufgeschrieben ist, dass alles explizit da ist und klar, das Innet zum Beispiel von OpenCode ist natürlich echt nice, das schreibt viele Dinge nieder, ähm,
Kai Ole Hartwig: Und das ist auch echt hilfreich.
Kai Ole Hartwig: Aber ich frage mich, ob es da nicht noch bessere Wege gibt, zu besseren Ergebnissen zu führen.
Kai Ole Hartwig: Und da vermisse ich das gerade.
Daniel Langemann: Mm.
Daniel Langemann: Mm.
Kai Ole Hartwig: Also im Moment ist ja sowieso die Stimmung entweder völlig gegen KI,
Kai Ole Hartwig: Oder völlig überzogen, hey, das kann das alles und ich finde, das Mittelmaß fehlt.
Kai Ole Hartwig: Also ich finde es auch ganz spannend, dass mittlerweile hingegangen wird und gezielt KI-Systeme gestört werden mit Prompts, die quasi auf einer Seite integriert sind.
Kai Ole Hartwig: Ja, so, und der Mittelweg, wie bekommt man das Ding jetzt wirklich in der realen Welt produktiv, sodass es sich auch gut anfühlt, dass man einen vernünftigen Workflow hat?
Kai Ole Hartwig: Da würde ich wirklich gerne mehr drüber lesen oder auch hören.
Kai Ole Hartwig: Also gerne einfach auch Podcast.
Kai Ole Hartwig: Kommt zu uns in den Podcast und erzählt uns, zeigt uns, wie das richtig geht.
Daniel Langemann: Oh ja.
Kai Ole Hartwig: Feel free.
Kai Ole Hartwig: Aber ich finde es immer ein bisschen...
Kai Ole Hartwig: bin so ein bisschen skeptisch mittlerweile bei den Leuten, die immer schreiben, ja, das funktioniert alles, ihr macht das nur nicht richtig.
Kai Ole Hartwig: Okay, dann zeigt mir, was ich falsch mache.
Kai Ole Hartwig: Bitte.
Kai Ole Hartwig: Ja.
Daniel Langemann: Ja, also es gibt, glaube ich, viele Technologien, die entweder, wo wir selber noch nicht von gehört haben.
Daniel Langemann: Also es fing mit der AgentsMD an.
Daniel Langemann: Irgendwann hat man mitgekriegt, das ist so das Ding.
Daniel Langemann: Jetzt habe ich hier von GitHub SpecKit, heißt das Ding, auch gelesen.
Daniel Langemann: Finde ich super interessant, wo man halt so genauer Specs definieren kann.
Daniel Langemann: Wir haben gemerkt, dass wir zum Beispiel unsere Arbeitsweise komplett ändern.
Kai Ole Hartwig: Vielen Dank.
Daniel Langemann: Also ich genauso.
Daniel Langemann: Es gibt mittlerweile immer zu jedem Feature, was ich mache, eine Markdown-Datei, weil ich dieses Ping-Pong, so wie du es beschrieben hast, mit ich spreche mit dem Computer, das habe ich bis jetzt, finde ich eine coole Idee, aber bis jetzt hat sich das, oder habe ich da...
Daniel Langemann: das so gehabt, dass ich den Spec erstmal definiert habe in der Markdown-Datei, dann KI gefragt habe, hast du alles, brauchst du noch was, was fehlt, dann habe ich mir das nochmal durchgelesen, habe meinen Senf dazugegeben, weil ich gesagt habe, guck mal, das könnte ein Problem sein, die Entity braucht noch diese Felder, zum Beispiel mit PlantUML habe ich super Erfahrungen gemacht,
Daniel Langemann: Datenbank-Entities definieren.
Daniel Langemann: Mit einem Kollegen zusammen, er macht Frontend, ich mache Backend.
Daniel Langemann: Wir saßen zusammen und haben diskutiert, für dieses Feature brauchen wir zum Beispiel, weiß ich nicht, fünf Input-Felder mit diesem, das und jedem.
Daniel Langemann: Die plant-UML-Datei angepasst, Felder reingepackt und nachher dann zu den Specs das dazugenommen und gesagt, erstell mir PHP-Entities basierend auf diesem Diagramm zum Beispiel.
Daniel Langemann: Super easy, was hinten rauspurzelt, mit Zugriffen, mit allem drum und dran, mit API-Plattformen.
Daniel Langemann: Hast du dann ganz schnell, sagen wir mal, eine rudimentäre API.
Daniel Langemann: Auf der grünen Wiese alles super, geht schnell.
Kai Ole Hartwig: Ja.
Daniel Langemann: Später im Projekt war es dann aber so, natürlich die guten Entwickler vernachlässigen sowas nicht.
Daniel Langemann: Irgendwann war die Dokumentation nicht mehr so wie die Programmierung.
Daniel Langemann: Und es war super easy zu sagen, guck mal, da sind die Entities, pass mal das Diagramm wieder an.
Daniel Langemann: Und dann konnte ich mit dem Diagramm weiterarbeiten mit dem Kollegen und sagen, guck mal, das ist jetzt der Stand.
Daniel Langemann: Dann haben wir da wieder drin rumgefummelt.
Daniel Langemann: Dann habe ich gesagt, ihr packt das mal wieder zurück.
Daniel Langemann: Und dann wurde da ganz schnell ein Schuh draus.
Daniel Langemann: Also am Anfang Markdowns definieren, Code generieren, von einer anderen KI, also ich lasse gerne auch eine andere KI dann nochmal drüber laufen, reviewen.
Kai Ole Hartwig: Ja.
Daniel Langemann: Guck mal, was deine Konkurrenz besser oder schlechter macht.
Daniel Langemann: Dann schaue ich nochmal drüber und
Daniel Langemann: erst dann ist das für mich eigentlich fertig.
Daniel Langemann: Also ich bin schon schneller geworden, aber so arbeitstechnisch hat sich viel verändert in den letzten halben, dreiviertel Jahren für mich.
Kai Ole Hartwig: Aber die Frage, die sich mir eigentlich stellt, ist, werden wir nicht alle von Softwareentwicklern zu Softwarearchitekten damit?
Kai Ole Hartwig: Ja, wir bewegen uns ja immer mehr in Definitionen und in Architektur.
Kai Ole Hartwig: Ich finde, wir bewegen uns, also die Disziplin verändert sich aus meiner Sicht mehr hin zu einem Senior-Architekten, der Coding-Erfahrung hat, ja, nicht jemand, der einfach irgendwo hingekommen ist und jetzt Software-Architekt ist, sondern jemand, der auch vorher programmiert hat und selber programmieren kann.
Kai Ole Hartwig: Und ich finde, wir entwickeln uns etwas in diese Richtung, dass wir weggehen tatsächlich von dieser reinen Entwicklerrolle, wo man ja auch immer so ein bisschen Architektur auf einem gewissen Level mitgemacht hat, hin zu einer sehr architekturlastigen Rolle mit Programmierungserfahrung, die auch Code-Reviews macht.
Daniel Langemann: Ja.
Kai Ole Hartwig: Ja, so, okay.
Kai Ole Hartwig: Finden wir das gut?
Daniel Langemann: Die Antwort passt nicht für ein Podcast, aber ja.
Daniel Langemann: Also, ja, also irgendwie sowas in die Richtung definitiv.
Daniel Langemann: Also, es verändert sich extrem.
Daniel Langemann: Und ich bin
Daniel Langemann: Wenn du mich morgens fragst, ja, abends, nein.
Daniel Langemann: Also ich weiß es nicht.
Daniel Langemann: Ich bin auch so, ich weiß nicht, wo die Reise hingeht.
Daniel Langemann: Also es gibt viele Sachen, die finde ich gut.
Daniel Langemann: Also ganz grob gesagt, KI macht mich nicht schneller, sondern nimmt mir Arbeiten ab.
Daniel Langemann: Lieblingsbeispiel sind so Übersetzungen in einem Projekt.
Daniel Langemann: Du hast E-Mails, die müssen übersetzt werden in drei Sprachen oder Kunde kommt zwei Stunden später an, ach, da sind noch ein paar andere Sprachen dazugekommen, kannst du mal eben.
Daniel Langemann: Ja, dann nehme ich die CSV-Datei, schmeiße die KI an den Kopf und gehe mir einen Kaffee holen, dann ist das fertig, wenn ich wiederkomme.
Daniel Langemann: Das ist cool.
Daniel Langemann: Es gibt...
Kai Ole Hartwig: Aber macht es dann, also ja, ich verstehe das, dass ich grundsätzlich finde ich das ja auch cool.
Kai Ole Hartwig: Aber ich stelle mir halt so die Frage, also ich kann jetzt halt schlecht zehnmal am Tag Kaffee trinken gehen.
Kai Ole Hartwig: Also das verkraftet meinen Kreislauf nicht so gut.
Kai Ole Hartwig: Dann wäre ich ein bisschen zu himmlich Richtung Abend.
Kai Ole Hartwig: Die Frage ist ja immer, die ich mir stelle, was mache ich denn aus dieser Zeit, die ich eigentlich gewinnen müsste?
Kai Ole Hartwig: Und das fühlt sich im Moment nicht so gut an, weißt du?
Daniel Langemann: mehr Architektur.
Daniel Langemann: Mhm.
Kai Ole Hartwig: Ich sage mir jetzt mal, häufig erwische ich mich, sage ich jetzt mal, dabei, dass ich diese Zeit einfach nicht sinnvoll genutzt bekomme.
Kai Ole Hartwig: Ich habe dann so diese, ich sage jetzt mal 20, 30 Minuten oder so, vielleicht sind meine Aufgaben auch zu klein geschnitten, aber wo dann die KI rödelt, ich dann diesen Planungsmodus zu Ende habe und sage, ah ja, jetzt schaue ich mir das an und dann läuft die weiter, aber gleichzeitig bin ich zu schlechter drin, sage ich jetzt mal, zu sagen, okay, ich mache jetzt auf dem zweiten Bildschirm ein anderes Projekt, lasse da auch ein Agent laufen und der macht eine andere Aufgabe.
Daniel Langemann: Nein.
Daniel Langemann: Echt?
Daniel Langemann: Nee.
Kai Ole Hartwig: Also das ist
Kai Ole Hartwig: Ich habe bei einigen Leuten gelesen, die machen das so.
Kai Ole Hartwig: Aber den Kontext-Switch bekomme ich jetzt ehrlich gesagt nicht hin.
Kai Ole Hartwig: Ich müsste dann auch ehrlicherweise einen zweiten Rechner nutzen, weil dann brauche ich doch mal irgendwie leistungsstärkere Systeme, um das machen zu können.
Kai Ole Hartwig: Also ich... Ja, die Arbeit verändert sich.
Kai Ole Hartwig: Ja, ich mag es teilweise.
Kai Ole Hartwig: Besonders an Tagen, wo ich aus unterschiedlichsten Gründen ein Schlafdefizit habe.
Kai Ole Hartwig: Aber es fühlt sich halt nicht so an, als wäre es tatsächlich eine Produktivitätssteigerung.
Kai Ole Hartwig: Und das finde ich schade, wenn ich ein neues Werkzeug benutze.
Kai Ole Hartwig: Dann...
Kai Ole Hartwig: möchte ich da auch immer irgendwie schneller, mehr Effizienz reinbringen, mehr schaffen können, bessere Ergebnisse liefern.
Kai Ole Hartwig: Und ich finde, das fühlt sich
Kai Ole Hartwig: noch nicht immer so an.
Kai Ole Hartwig: Da fand ich den Sprung mit der Integration von KI als smartere Codeergänzung, als smarteres Autocomplete, fand ich den Sprung in der Produktivität viel spürbarer und viel messbarer.
Daniel Langemann: Vielen Dank.
Kai Ole Hartwig: Also da bin ich wirklich mit schneller gewordenen
Kai Ole Hartwig: Und ich finde, das habe ich jetzt beim Einsatz von Agenten einfach noch gar nicht so das Gefühl.
Daniel Langemann: Das, was du gerade beschrieben hast, das passiert mir auch.
Daniel Langemann: Ich schaffe es nicht in dieser Hyperfokus-Phase, sage ich mal.
Daniel Langemann: Beim Programmieren war das so, du warst irgendwann ganz tief in dem drin, was du gerade gemacht hast.
Daniel Langemann: Du hast in Methoden, Abhängigkeiten und Zuständigkeiten gedacht und hast gesagt, guck mal, ich habe jetzt hier zum fünften Mal diesen Fall geschaffen.
Daniel Langemann: Ich möchte das Design-Pattern benutzen.
Daniel Langemann: Da ist es noch Security-technisch was zu berücksichtigen.
Daniel Langemann: Und da war ich dann drin oder in solchen Phasen konnte man schon mal so zwei, drei Stunden irgendwie so verschwinden lassen.
Kai Ole Hartwig: Ja.
Daniel Langemann: Hast du nichts mitgekriegt.
Daniel Langemann: Und ich war auch hoch fokussiert.
Daniel Langemann: Einen Tag später hättest du mich fragen können.
Daniel Langemann: Ich wusste alles.
Daniel Langemann: Jetzt mit KI passiert genau das.
Daniel Langemann: Ich lasse die Sachen generieren.
Daniel Langemann: Ich habe nicht gemessen, ob das schneller ist.
Daniel Langemann: Also jetzt zeitmäßig... 5 Minuten.
Kai Ole Hartwig: ist ja auch nur so ein Bauchgefühl.
Kai Ole Hartwig: Ich sitze da jetzt auch mit der Stoppuhr und sage, na, das hätte ich in der gleichen Zeit programmiert.
Kai Ole Hartwig: So nicht verstehen.
Kai Ole Hartwig: Das ist jetzt so eine gefühlte Wahrheit.
Daniel Langemann: Ja.
Daniel Langemann: Also mir fehlt das.
Daniel Langemann: Aber... Also wenn ich mit KI was generiere, bin ich nicht mehr so tief drin in dem Thema.
Daniel Langemann: Ich mache zwar die Reviews, aber...
Daniel Langemann: das, was ich vorher beim Schreiben die Tiefe erreicht habe, muss ich jetzt später mir das zurückerarbeiten, wenn ich die Reviews mache, weil dann sehe ich den Code und frage, warum ist die Methode da?
Daniel Langemann: Hat das, also das brauche ich immer noch, weil ich möchte immer noch wissen, zum Beispiel die Dateien, die ich ablege, liegen die irgendwo im Public, sind die öffentlich zugänglich oder sind der S3-Bucket einfach so nicht gesichert?
Kai Ole Hartwig: Ja.
Kai Ole Hartwig: Ja.
Daniel Langemann: Das sind ja Sachen, die kann die KI bauen.
Daniel Langemann: Aber ich habe dann, also ich weiß es nicht, kein anderer weiß es.
Daniel Langemann: Das finde ich problematisch.
Daniel Langemann: Und gerade das, was du beschrieben hattest, dieses, dadurch, dass ich nicht das programmiere, verliere ich schnell den Fokus.
Daniel Langemann: Und bin dann so alle 20 Minuten mit, okay, jetzt haben wir das gemacht.
Daniel Langemann: Machst du das Nächste und das Nächste.
Daniel Langemann: Also das fehlt mir gerade noch so, dass ich da irgendwie einen Modus finde, wo ich kontinuierlich tief in ein Thema einsteige.
Daniel Langemann: wo ich das dann auch nachher wirklich abgeschlossen markieren kann.
Daniel Langemann: Also ich kratze oben an vielen Themen, kann mich nachträglich hinsetzen oder wenn ich Reviews mache, setze ich mich hin und erarbeite das wieder zurück.
Daniel Langemann: Also die Zeit, die ich vorne spare, brauche ich länger.
Kai Ole Hartwig: Ja.
Daniel Langemann: Deswegen ist so gefühlt das gleiche Thema oder die Zeit, der gleiche Aufwand, weiß ich nicht.
Kai Ole Hartwig: Ja, weißt du, mich erinnert das so ein bisschen an Uniklausuren früher.
Daniel Langemann: Hm.
Kai Ole Hartwig: Schauen Sie sich den Code an und sagen Sie, welcher Compilerfehler auftritt.
Daniel Langemann: Boah.
Kai Ole Hartwig: Ich finde, die Kategorie ist das jetzt.
Kai Ole Hartwig: Nach der Klausur wusste ich auch nicht mehr, was war denn jetzt dieser Code, der da steht.
Kai Ole Hartwig: Und, also das ist halt so dieses Ding.
Kai Ole Hartwig: Ich finde, das ist es irgendwie.
Kai Ole Hartwig: Das beschreibt es für mich so ein bisschen.
Kai Ole Hartwig: Aber vielleicht brauche ich auch einfach so einen schrottigen Workflow wieder so ein bisschen mit, ich habe 15 Minuten Pause, in der Zeit kann ich den Agent anschmeißen, dann habe ich eine halbe Stunde Besprechung und dann wieder.
Kai Ole Hartwig: Ja, also vielleicht, in der Zeit,
Daniel Langemann: Aber dann komme ich wieder zurück aus der Besprechung und weiß gar nicht mehr, was mit dem Agent war und was ich ihm gesagt habe.
Daniel Langemann: Hm.
Kai Ole Hartwig: Naja, das kann man ja, wenn es so eine Besprechung ist, wo man nicht in, also so ein Videocall ist, dann kann man das ja auf dem einen Bildschirm laufen lassen und sieht ja, was passiert, weißt du?
Kai Ole Hartwig: Vielleicht ist das auch so ein Arbeitsmodus, in den ich wieder zurück muss.
Kai Ole Hartwig: Nicht, dass ich das möchte.
Kai Ole Hartwig: Ja, bitte.
Kai Ole Hartwig: Also, das soll jetzt keine Aufforderung dazu sein, dass das in den Modus wieder zurückgehen soll.
Kai Ole Hartwig: Aber ich finde, so ein bisschen...
Kai Ole Hartwig: die Arbeitstiefe hat das irgendwie für mich.
Daniel Langemann: Ja, also...
Kai Ole Hartwig: Irgendwo zwischen komischer Frage in der Klausur und eigentlich programmiert man zwischen Besprechungen.
Kai Ole Hartwig: Also programmiert.
Kai Ole Hartwig: Wo man genau wusste, wenn man so einen Tag mit Besprechungen hat, wo irgendwie sechs Stunden Besprechungen geplant sind, die zwei Stunden sind eh für die Töne.
Kai Ole Hartwig: Da machst du keine einzige Aufgabe wirklich.
Kai Ole Hartwig: Ja.
Daniel Langemann: Das war Smalltalk.
Daniel Langemann: Also das hatten wir sogar.
Daniel Langemann: Bei einem Kunden hatten wir das echt, wo wir gesagt haben, die Stunde dazwischen, es ist keine Pause, aber das ist Smalltalk.
Daniel Langemann: Und dann haben wir uns hingesetzt und keine Ahnung.
Kai Ole Hartwig: Ja, ganz schlimm finde ich dann, wenn dann irgendjemand auf die Idee gekommen ist, ihr müsst alles auf Tickets buchen.
Daniel Langemann: Jeder hat so sein Herz ausgeschüttet.
Daniel Langemann: Oh ja.
Kai Ole Hartwig: Und ich dachte mir so, ja, fuck.
Kai Ole Hartwig: Wo buche ich das denn jetzt hin?
Kai Ole Hartwig: Aber gut.
Kai Ole Hartwig: Jetzt.
Kai Ole Hartwig: Ja.
Daniel Langemann: Ja, aber zu dem Thema zurück, was ich mag an dem Programmieren oder wo KI mich besser macht.
Daniel Langemann: Das ist ja so, die Headline schlechthin, damit kriegst du auf LinkedIn aktuell immer noch gut Reichweite generiert.
Daniel Langemann: KI macht mich besser.
Daniel Langemann: Also gerade dieses, ich habe nur vier Stunden nachts geschlafen.
Daniel Langemann: Also
Kai Ole Hartwig: Definitiv, ja.
Daniel Langemann: die Tickets vorbereite, ist das so ein Pingpong.
Daniel Langemann: Und natürlich habe ich schon eine Idee, wie ich etwas bauen will.
Daniel Langemann: Aber ich bin ja hin und her.
Daniel Langemann: Und es ist mir schon ein paar Mal passiert, wo dann so zurückkam, willst du A oder B?
Daniel Langemann: Wo ich sage, hm,
Daniel Langemann: Stimmt, B gibt es auch noch.
Daniel Langemann: Hatte ich vorher schon instinktiv ausgeschlossen, weil es hat nie gepasst und habe mittlerweile die Lösung vergessen.
Daniel Langemann: Aber in diesem Fall hat B, dann habe ich darüber nachgedacht, geguckt, habe gesagt, okay, passt immer noch nicht, aber ich hätte es gar nicht auf dem Schirm gehabt.
Daniel Langemann: Und wenn mich nachträglich jemand gefragt hätte, hätte ich gesagt, cool, ich habe A und B evaluiert.
Daniel Langemann: Also die Entscheidung war bewusster.
Kai Ole Hartwig: Ja, definitiv.
Kai Ole Hartwig: Ach so, ich schon.
Kai Ole Hartwig: Aber wir haben auch Induktion jetzt.
Daniel Langemann: mir passiert leider oft oder öfter, dass man gewisse Sachen schon auswendig kann.
Daniel Langemann: Hast du fünfmal auf die Herdplatte gefasst, machst das beim sechsten Mal instinktiv nicht mehr und
Daniel Langemann: Okay.
Daniel Langemann: Und viele Sachen mache ich mittlerweile unbewusst, wo ich dann sage, die Lösung nehmen wir und dann ist es das Gleiche, wenn ein Junior oder ein neuer Team ist.
Daniel Langemann: Dann kommen die Fragen, warum machst du das?
Daniel Langemann: Darum haben wir schon immer so gemacht.
Daniel Langemann: Das ist so die schlechteste Antwort.
Kai Ole Hartwig: War die letzten Male auch gut.
Daniel Langemann: Ja, ja, genau.
Kai Ole Hartwig: Was ich tatsächlich auch gerne zwischendrin mache, ist, gerade bei komplexeren Algorithmen irgendwo oder komplexeren Funktionsabläufen, die KI einfach mal fragen, kann man das effizienter machen?
Daniel Langemann: Mhm.
Kai Ole Hartwig: Und da kommen erstaunlich häufig echt schöne Lösungen bei rum.
Kai Ole Hartwig: Also das darf man gar nicht so unterschätzen, wenn man so sehr in bestimmten erlernten Abläufen ist.
Kai Ole Hartwig: Da ist es total schön, einfach mal einen Schritt zurückzugehen und zu sagen, wie sieht denn jemand anderes aus?
Kai Ole Hartwig: aufgrund des trainierten Wissens der Allgemeinheit, das und gibt es da vielleicht einfach einen besseren Ablauf.
Kai Ole Hartwig: So, und ich glaube, wir können festhalten, wir finden das eigentlich relativ spannend.
Kai Ole Hartwig: Uns fehlen so ein bisschen Best Practices.
Kai Ole Hartwig: Ja, und da...
Daniel Langemann: Einfach, weil es noch nicht alt genug ist.
Daniel Langemann: Hm.
Kai Ole Hartwig: Ja, und es ist auf jeden Fall ein Thema, das sich entwickelt.
Kai Ole Hartwig: Ich bin auch gespannt, wo die Reise damit hingeht.
Daniel Langemann: Ich auch.
Daniel Langemann: Ich glaube, ich werde mich da nochmal hinsetzen und gerade so dieses GitHub-Spec-Kit und andere Sachen mal ausprobieren und ich glaube, wir machen eine Folge mal genau über solche Sachen.
Daniel Langemann: Dass wir da so ein bisschen mal, ein bisschen tiefer zeigen, was wir nutzen, wie wir nutzen, was wir damit gelernt oder gesehen haben.
Kai Ole Hartwig: Ja, und vielleicht auch, wie wir das Ganze absichern.
Kai Ole Hartwig: Ich finde, das darf man nicht vergessen.
Kai Ole Hartwig: Immer.
Kai Ole Hartwig: So, so, so.
Kai Ole Hartwig: Dieses selbstständige Schreiben lassen, dieses Gottvertrauen, dass jetzt nichts schief geht nach dem Planen und dass er das tatsächlich macht.
Kai Ole Hartwig: Manchmal wünsche ich mir da
Kai Ole Hartwig: dass das besser abgesichert ist.
Kai Ole Hartwig: Oder dass ich vielleicht lerne, wie ich es besser absichern kann.
Kai Ole Hartwig: Oder schon, dass das System das selber besser abgesichert ist.
Kai Ole Hartwig: Ich weiß es nicht.
Kai Ole Hartwig: Ich finde, die ganzen Sicherheitssachen, die werden mir auch zu wenig diskutiert an der Stelle.
Daniel Langemann: Ja, die sind ja hinderlich, deswegen die passen auf keine tollen Slides.
Kai Ole Hartwig: Gut, das war jetzt das Schlusswort.
Kai Ole Hartwig: Und dann hören wir uns in zwei Wochen wieder.
Daniel Langemann: Ja, bis in zwei Wochen.
Kai Ole Hartwig: Und lassen uns überraschen, welches Thema es dann wird.
Daniel Langemann: Wir sehen uns.
Kai Ole Hartwig: Das war die dritte Folge Secrets Not Included.
Kai Ole Hartwig: Vielen Dank fürs Einschalten.
Kai Ole Hartwig: Und folgt uns, dass ihr nichts verpasst.
Kai Ole Hartwig: Ciao.
