WEBVTT

00:00:00.005 --> 00:00:04.097
<v Sebastian>Aber das ist tatsächlich genau der Punkt, der mich auch immer stresst.

00:00:04.486 --> 00:00:08.457
<v Sebastian>Und ich bin ein sehr ungeduldiger Mensch. Ich mache dann auch immer Sachen parallel.

00:00:08.579 --> 00:00:12.715
<v Sebastian>Und blöderweise kommen die dann immer gleichzeitig zurück. Und dann hast du

00:00:12.715 --> 00:00:16.605
<v Sebastian>drei Häufchen Arbeit auf dem Tisch liegen oder fünf Häufchen Arbeit auf dem

00:00:16.605 --> 00:00:19.051
<v Sebastian>Tisch liegen, zwischen denen du hin und her switchen musst.

00:00:19.492 --> 00:00:23.315
<v Sebastian>Und ganz ehrlich, das stresst mich unheimlich, weil die Agenten,

00:00:23.315 --> 00:00:25.506
<v Sebastian>die sitzen um mich rum und warten auf Input.

00:00:25.767 --> 00:00:28.449
<v Sebastian>Und ich bin dann der Flaschenhals, der alles langsam macht.

00:00:33.999 --> 00:00:38.555
<v Hendrik>Zum Abschluss des heutigen Konferenztages geht es nochmal um vielleicht die

00:00:38.555 --> 00:00:44.390
<v Hendrik>wichtigste Frage, nämlich, was funktioniert mit Coding Agents eigentlich wirklich und was nicht?

00:00:44.628 --> 00:00:47.265
<v Hendrik>Denn seien wir jetzt mal ehrlich, die meisten Demos, die zeigen ja perfekte

00:00:47.265 --> 00:00:51.745
<v Hendrik>Welten, saubere Code-Basen, klare Anforderungen, Agents, die wie von Zauberhand

00:00:51.745 --> 00:00:53.382
<v Hendrik>komplexe Features implementieren.

00:00:53.875 --> 00:00:58.405
<v Hendrik>Aber die Realität, das haben wir auch heute schon gehört, die sieht dann schon mal auch anders aus.

00:00:58.725 --> 00:01:02.175
<v Hendrik>Echte Projekte mit gewachsenen Strukturen, unklaren Requirements,

00:01:02.453 --> 00:01:06.372
<v Hendrik>KI-Tools, die manchmal genial sind und manchmal auch völlig daneben liegen.

00:01:06.970 --> 00:01:11.648
<v Hendrik>Wann also kann man einem Agenten vertrauen und wo muss man selbst das Heft in die Hand nehmen?

00:01:12.896 --> 00:01:16.655
<v Hendrik>Unser letzter Speaker hier auf der Konferenz ist ein bekanntes Gesicht und genau

00:01:16.655 --> 00:01:19.044
<v Hendrik>der richtige Mann, um diese Fragen zu beantworten.

00:01:19.665 --> 00:01:24.605
<v Hendrik>Sebastian Springer ist Software-Architekt bei Rohde & Schwarz und arbeitet täglich

00:01:24.605 --> 00:01:25.905
<v Hendrik>an KI-gestützter Entwicklung.

00:01:26.405 --> 00:01:30.825
<v Hendrik>Er entwickelt praktische Workflows für Coding-Agents und Automatisierung und

00:01:30.825 --> 00:01:36.906
<v Hendrik>muss als Technical Educator KI-Konzepte so vermitteln, dass Entwickler sie auch sofort nutzen können.

00:01:37.248 --> 00:01:41.345
<v Hendrik>Diese Doppelrolle gibt ihm also den perfekten Blick, nämlich kennt er die technischen

00:01:41.345 --> 00:01:43.907
<v Hendrik>Möglichkeiten und auch die praktischen Hürden.

00:01:44.418 --> 00:01:49.375
<v Hendrik>Viele kennen ihn natürlich auch von unseren Büchern und auch von diversen Rheinwerk-Konferenzen

00:01:49.375 --> 00:01:50.745
<v Hendrik>und dpunkt-Konferenzen. Deshalb

00:01:50.745 --> 00:01:54.182
<v Hendrik>freue ich mich, dass er heute auch wieder hier ist beim Coding mit KI.

00:01:54.332 --> 00:01:56.463
<v Hendrik>Hallo, herzlich willkommen, lieber Basti.

00:01:57.606 --> 00:02:03.093
<v Sebastian>Einen wunderschönen guten Nachmittag. Hast du mal die Messlatte richtig hochgehängt?

00:02:03.093 --> 00:02:05.756
<v Hendrik>Ja, Mensch. Ehre, wem Ehre gebührt.

00:02:06.493 --> 00:02:11.613
<v Sebastian>Vielen herzlichen Dank. Eigentlich wollte ich so ein richtig grumpy Ding hinten rausjagen.

00:02:12.393 --> 00:02:15.193
<v Sebastian>Diese KI wird sich einfach nicht durchsetzen. Vergesst alles,

00:02:15.193 --> 00:02:17.535
<v Sebastian>was ihr gehört habt. Funktioniert einfach nicht.

00:02:18.051 --> 00:02:23.253
<v Sebastian>Ist leider nicht so. Also funktioniert tatsächlich. Und genau das schauen wir uns jetzt dann an.

00:02:23.914 --> 00:02:28.543
<v Hendrik>Super. Dann viel Spaß mit diesem Vortrag von Sebastian Springer und wenn ihr

00:02:28.543 --> 00:02:33.893
<v Hendrik>Fragen habt, stellt sie gerne im Chat. Sebastian, die Bühne gehört dir. Vielen Dank.

00:02:34.909 --> 00:02:36.633
<v Sebastian>Ein Wort der Warnung vorweg.

00:02:37.788 --> 00:02:41.533
<v Sebastian>Ihr werdet mit ganz viel eigener Meinung konfrontiert werden.

00:02:42.373 --> 00:02:46.809
<v Sebastian>Ich habe mittlerweile ein bisschen Erfahrung mit agentischer Entwicklung.

00:02:48.684 --> 00:02:54.841
<v Sebastian>Ich habe mit GitHub Copilot angefangen, als GitHub Copilot noch cool war, also richtig cool war.

00:02:55.633 --> 00:03:00.681
<v Sebastian>Jetzt ist es ja eher so ein Trauerspiel und habe sehr, sehr viel ausprobiert.

00:03:01.041 --> 00:03:05.998
<v Sebastian>Ganz viel in Spielprojekten, wo man sich denkt, boah, supergeil, funktioniert ja alles.

00:03:06.451 --> 00:03:10.823
<v Sebastian>Und dann machst du es plötzlich im Projektalltag und dann funktioniert überhaupt

00:03:10.823 --> 00:03:15.113
<v Sebastian>nichts mehr. Ja, ich meine, habt ihr schon mal probiert, von einem Coding-Agent

00:03:15.633 --> 00:03:19.965
<v Sebastian>irgendwas mit UI bauen zu lassen oder CSS oder irgend sowas?

00:03:21.126 --> 00:03:24.789
<v Sebastian>Ich scheitere da regelmäßig, aber da kommen wir noch dazu. Keine Sorge.

00:03:26.095 --> 00:03:31.633
<v Sebastian>Gut, also wir schauen uns an, was funktioniert bei mir in der täglichen Arbeit,

00:03:31.633 --> 00:03:32.736
<v Sebastian>was funktioniert nicht.

00:03:32.899 --> 00:03:38.013
<v Sebastian>Gerne reingrätschen, gerne eure Fragen, eure eigenen Erfahrungen mitteilen.

00:03:38.466 --> 00:03:42.813
<v Sebastian>Ich habe festgestellt, das hilft ungemein. Also redet über das,

00:03:42.813 --> 00:03:47.963
<v Sebastian>was ihr tut und redet über eure Probleme und meistens findet sich dann in der

00:03:47.963 --> 00:03:51.666
<v Sebastian>Gruppe von Gleichgesinnten auch eine richtig gute Lösung dafür.

00:03:52.549 --> 00:03:56.033
<v Sebastian>Ja, der Hendrik hat mich eigentlich schon vorgestellt. Recht viel mehr steht

00:03:56.033 --> 00:03:57.633
<v Sebastian>auf dieser Folie auch nicht drauf.

00:04:00.203 --> 00:04:03.583
<v Sebastian>Auch das hat der Hendrik schon gesagt. Eigentlich hätten wir uns absprechen

00:04:03.583 --> 00:04:07.095
<v Sebastian>müssen. Das ist ja quasi mein Co-Speaker hier schon.

00:04:08.737 --> 00:04:11.093
<v Sebastian>Also grundsätzlich ist es tatsächlich

00:04:11.093 --> 00:04:15.582
<v Sebastian>so, man schaut sich so einen Coding-Agent auf der grünen Wiese an,

00:04:16.145 --> 00:04:21.303
<v Sebastian>komm jetzt bauen wir mal eine Webseite oder komm bauen wir mal ein neues Spotify

00:04:21.303 --> 00:04:27.203
<v Sebastian>oder machen wir ein Ticketsystem oder weiß der Teufel was und das funktioniert alles erstaunlich gut.

00:04:28.480 --> 00:04:34.999
<v Sebastian>Ja und dann schlägt die Realität zu und dann ist es dann plötzlich nicht mehr so gut. Warum?

00:04:38.267 --> 00:04:43.361
<v Sebastian>Wir arbeiten meistens mit Tickets und die Tickets müssen erstmal so aufbereitet

00:04:43.361 --> 00:04:46.504
<v Sebastian>werden, damit gearbeitet werden kann.

00:04:46.736 --> 00:04:52.615
<v Sebastian>Wenn ich jetzt ein Ticket eins zu eins kopiere in meinen Prompt rein und sage, ja jetzt mach mal,

00:04:54.371 --> 00:04:58.441
<v Sebastian>ich habe des Öfteren jetzt schon ausprobiert und ohne Nacharbeiten funktioniert

00:04:58.441 --> 00:05:02.391
<v Sebastian>es in den seltensten Fällen, außer man konzentriert sich wirklich drauf,

00:05:02.391 --> 00:05:05.084
<v Sebastian>um für einen Agent zu spezifizieren.

00:05:06.560 --> 00:05:10.421
<v Sebastian>Für einen Entwickler, mit dem man die ganze Zeit zusammenarbeitet,

00:05:10.421 --> 00:05:14.320
<v Sebastian>ist es deutlich einfacher. Man kennt sich, man weiß, wie die Gegenseite tickt,

00:05:15.121 --> 00:05:17.398
<v Sebastian>und die AI weiß das in den meisten Fällen nicht.

00:05:17.578 --> 00:05:21.270
<v Sebastian>Deswegen müssen wir da allein schon ein bisschen unter die Arme greifen.

00:05:22.187 --> 00:05:26.221
<v Sebastian>Dann arbeiten wir nicht auf der grünen Wiese, sondern meistens mit einer mehr

00:05:26.221 --> 00:05:34.191
<v Sebastian>oder weniger großen, manchmal auch hässlichen Code-Basis mit Dingen, die sind gewachsen.

00:05:35.253 --> 00:05:39.212
<v Sebastian>Geh da nicht hin, das sind die dunklen Ecken. Die fasst man nicht an.

00:05:39.624 --> 00:05:41.191
<v Sebastian>Da sind schon Leute verschwunden.

00:05:43.531 --> 00:05:48.401
<v Sebastian>Dann Bugfixes. Ja klar, kann ich den irgendwie fixen, aber woher kommt der Bug?

00:05:48.401 --> 00:05:52.794
<v Sebastian>Wie ist der entstanden? War das vielleicht mal ein Feature, das sich gegen uns gewendet hat?

00:05:53.358 --> 00:05:55.779
<v Sebastian>Auch da muss man echt ein bisschen aufpassen.

00:05:56.376 --> 00:06:03.115
<v Sebastian>Und die Paradedisziplin von AIs, das Refactoring, weil es ja so einfach ist,

00:06:04.085 --> 00:06:10.151
<v Sebastian>sollten nichts kaputt machen, keine APIs ändern und ja, da muss man ein bisschen aufpassen.

00:06:11.991 --> 00:06:19.061
<v Sebastian>Und die Abstimmung mit den menschlichen Counterparts ist ja da auch noch.

00:06:19.061 --> 00:06:25.141
<v Sebastian>Also da haben wir so ein bisschen die Schwierigkeiten und das,

00:06:25.141 --> 00:06:27.183
<v Sebastian>was einem die Tutorials nicht sagen.

00:06:29.239 --> 00:06:34.477
<v Sebastian>Und genau dafür muss man sich sein Werkzeug zurechtlegen, das richtige Werkzeug

00:06:34.477 --> 00:06:40.303
<v Sebastian>erst mal finden, die Workflows so einschleifen, dass sie einem nicht im Weg stehen.

00:06:40.663 --> 00:06:45.727
<v Sebastian>Und ich habe tatsächlich jetzt in der Vorbereitung auf diesen Vortrag ganz viele

00:06:45.727 --> 00:06:48.265
<v Sebastian>Anti-Patterns einfach nochmal ausprobiert, weil ich mir dachte,

00:06:48.625 --> 00:06:50.477
<v Sebastian>naja, so falsch kann das nicht sein.

00:06:50.477 --> 00:06:56.776
<v Sebastian>Aber oh doch, es ist falsch. Also seid gespannt. Ich plaudere da so ein bisschen aus dem Nähkästchen.

00:06:59.179 --> 00:07:04.627
<v Sebastian>Wir fangen mal an mit den Modellen. Natürlich, Fable haben sie uns jetzt gestrichen,

00:07:04.627 --> 00:07:06.107
<v Sebastian>aber hey, wir haben ja immer noch

00:07:06.107 --> 00:07:10.975
<v Sebastian>den Opus 4.8 und wir haben immer noch GPT-5.5 und wie sie alle heißen.

00:07:12.316 --> 00:07:17.297
<v Sebastian>Ja, die Dinger sind super und die können auch jede Menge Probleme lösen.

00:07:17.297 --> 00:07:20.292
<v Sebastian>Auf der anderen Seite schaffen sie wieder einen Haufen Probleme,

00:07:20.617 --> 00:07:25.407
<v Sebastian>weil ich zum Beispiel nutze nicht immer die neuesten und besten und tollsten

00:07:25.407 --> 00:07:28.703
<v Sebastian>Modelle. Erstens, weil es ins Geld geht und in die Tokens geht.

00:07:29.121 --> 00:07:36.813
<v Sebastian>Und zweitens finde ich, gerade die neuesten Modelle sind teilweise sehr mitteilsam

00:07:37.231 --> 00:07:39.437
<v Sebastian>und so sieht der Code auch teilweise aus.

00:07:39.437 --> 00:07:47.847
<v Sebastian>Also die besten Ergebnisse erzielt bei mir im Moment ein ganz einfaches GPT-5.4,

00:07:48.427 --> 00:07:53.577
<v Sebastian>also eine Generation älter und das funktioniert völlig solide.

00:07:53.577 --> 00:07:58.627
<v Sebastian>Also man muss auch so ein bisschen ausprobieren, schauen, wie arbeitet man selbst

00:07:58.627 --> 00:08:05.057
<v Sebastian>damit, wie interpretiert das Modell die Prompts, wie mitteilungsbedürftig ist es,

00:08:05.837 --> 00:08:09.313
<v Sebastian>wie schaut die Ausgabe aus, wenn man sich zum Beispiel was erklären lässt.

00:08:09.702 --> 00:08:13.297
<v Sebastian>Da finde ich die Opus-Modelle zum Beispiel wieder viel besser,

00:08:13.297 --> 00:08:15.444
<v Sebastian>weil die viel schöner strukturieren.

00:08:16.134 --> 00:08:18.596
<v Sebastian>Auch da kann man mit einem entsprechenden Prompt helfen.

00:08:19.408 --> 00:08:23.327
<v Sebastian>Aber wenn das Modell das von sich aus schon mitbringt, warum nehmen wir es dann nicht mit?

00:08:24.168 --> 00:08:27.216
<v Sebastian>Also auch da, das Modell ist nur die halbe Miete.

00:08:27.814 --> 00:08:31.117
<v Sebastian>Wie gehe ich mit dem Modell um und was habe ich für einen Harness,

00:08:31.117 --> 00:08:36.115
<v Sebastian>also für eine Entwicklungsumgebung? Und wie unterstützt mich diese Entwicklungsumgebung?

00:08:36.574 --> 00:08:42.097
<v Sebastian>Ist extrem wichtig und genau da werden wir auch nochmal einen eingehenden Blick

00:08:42.097 --> 00:08:47.846
<v Sebastian>drauf werfen, was für Elemente von so einer Entwicklungsumgebung helfen uns denn wirklich.

00:08:48.943 --> 00:08:51.364
<v Sebastian>Ja, genau das schauen wir uns jetzt an.

00:08:52.826 --> 00:08:56.931
<v Sebastian>So, Coding Agents da gibt es ja auch wie Sand am Meer.

00:08:58.427 --> 00:09:05.161
<v Sebastian>Und ich habe etliche ausprobiert und bin jetzt im Moment bei Cursor hängen geblieben.

00:09:06.641 --> 00:09:10.334
<v Sebastian>Ich bin schon etwas länger bei Cursor hängen geblieben, auch da,

00:09:10.334 --> 00:09:15.664
<v Sebastian>wo es noch cool war, wo es noch nicht zu SpaceX gehört hat, wo es noch nicht

00:09:15.664 --> 00:09:20.602
<v Sebastian>von Elon gekauft wurde, weil es einfach eine sehr schöne, runde Sache ist.

00:09:21.438 --> 00:09:24.794
<v Sebastian>Und grundsätzlich hat es ja mal angefangen mit der Autocompletion.

00:09:25.008 --> 00:09:31.294
<v Sebastian>Also GitHub Copilot zu den Ursprungszeiten war eine bessere,

00:09:31.634 --> 00:09:33.147
<v Sebastian>magischere Autocompletion.

00:09:33.698 --> 00:09:39.554
<v Sebastian>Dann irgendwann kam dann das Chatfenster und jetzt erklär mir mal diese Funktion.

00:09:39.554 --> 00:09:44.059
<v Sebastian>Ja, die Funktion zählt zwei Werte zusammen und gibt den berechneten Wert zurück.

00:09:45.388 --> 00:09:50.455
<v Sebastian>Ja, das ist mächtig, das kann sehr viel, aber hat noch nichts mit einem Coding-Agent

00:09:50.455 --> 00:09:57.776
<v Sebastian>zu tun, weil ich könnte theoretisch das Ganze auch mit einem Chat-GPT oder Ähnlichem schaffen.

00:09:58.345 --> 00:10:04.915
<v Sebastian>Wo es wirklich interessant wird, ist mit einem Agent, der in das Ökosystem eingebettet

00:10:04.915 --> 00:10:09.065
<v Sebastian>ist, mit dem ich kommunizieren kann, der selbst planen kann,

00:10:09.065 --> 00:10:10.959
<v Sebastian>der auf Ressourcen zugreifen kann,

00:10:11.488 --> 00:10:15.510
<v Sebastian>der selbst Entscheidungen trifft bis hin zum Force-Push,

00:10:16.137 --> 00:10:17.618
<v Sebastian>wo es wirklich gruselig wird.

00:10:18.895 --> 00:10:26.848
<v Sebastian>Warum sage ich das? Ich habe mit einem Agent auch schon Commit-Historien Kosmetik betrieben.

00:10:28.113 --> 00:10:31.445
<v Sebastian>Das mache ich meistens zum Wachwerden, weil danach bist du wach,

00:10:31.561 --> 00:10:35.776
<v Sebastian>wenn das Ding in deiner Git-Historie rumackert und zum Schluss von dir verlangt,

00:10:36.112 --> 00:10:42.688
<v Sebastian>hey, und jetzt mach mal bitte einen Git-Force-Push, damit auch die History umgeschrieben wird.

00:10:43.582 --> 00:10:46.473
<v Sebastian>Beziehungsweise, ihr kennt ja wahrscheinlich den YOLO-Mode.

00:10:47.942 --> 00:10:53.025
<v Sebastian>Wo das Modell dann alles darf und der macht halt dann einfach munter vor sich

00:10:53.025 --> 00:10:58.977
<v Sebastian>hin den Force-Push in euer Repo und das finde ich tatsächlich schon ein bisschen grenzwertig.

00:11:00.575 --> 00:11:05.495
<v Sebastian>Gleiches, was für Git gilt, gilt natürlich auch für Ticketsystemen,

00:11:05.495 --> 00:11:10.993
<v Sebastian>für Filesystemen, für alles, wo man halt nicht unbedingt ein autonomes Ding

00:11:11.272 --> 00:11:15.625
<v Sebastian>alles Mögliche machen lassen möchte, weil sonst plötzlich irgendwelche Dateien

00:11:15.625 --> 00:11:19.695
<v Sebastian>fehlen oder irgendwelche Mailpost-Fächer ausgeleert sind oder Sonstiges.

00:11:19.979 --> 00:11:21.152
<v Sebastian>Ihr kennt ja die Geschichten.

00:11:27.075 --> 00:11:28.606
<v Sebastian>Was macht ein Agent aus?

00:11:30.627 --> 00:11:33.738
<v Sebastian>Ich gehe bei der Arbeit mit dem Agent eher, also,

00:11:37.192 --> 00:11:39.772
<v Sebastian>ich beschreibe, was ich erreichen möchte. Ich sage dem Agent nicht,

00:11:39.772 --> 00:11:43.832
<v Sebastian>jetzt schreibe ein If-Statement, dann schreibe eine Schleife und dann mache

00:11:43.832 --> 00:11:47.612
<v Sebastian>hier ein Input-Element hin, sondern ich beschreibe, was ich erreichen möchte

00:11:47.612 --> 00:11:51.940
<v Sebastian>und warum ich es erreichen möchte, einfach um das Ganze abstrakt zu halten,

00:11:52.382 --> 00:11:59.057
<v Sebastian>und um dem Agent auch ein bisschen Freiheit zu geben, um das Ziel bestmöglich zu erreichen.

00:12:00.364 --> 00:12:06.192
<v Sebastian>Und dann braucht das Ding natürlich Werkzeuge, um das Ökosystem zu kennen,

00:12:06.557 --> 00:12:11.562
<v Sebastian>um die Code-Basis zu kennen, um die Git-Historie oder Versionskontroll-Historie

00:12:11.562 --> 00:12:14.372
<v Sebastian>zu kennen, um, wenn ich im Web unterwegs bin,

00:12:15.132 --> 00:12:19.502
<v Sebastian>meinen Frontend fernzusteuern, Tests auszuführen und so weiter.

00:12:19.502 --> 00:12:23.072
<v Sebastian>Also ich brauche eine ganze Latte von Werkzeugen, weil diese Werkzeuge auch

00:12:23.072 --> 00:12:26.532
<v Sebastian>das Ergebnis deutlich besser machen als ohne.

00:12:27.304 --> 00:12:31.702
<v Sebastian>Und in den meisten Fällen lohnt es sich, in Schleifen zu arbeiten.

00:12:31.702 --> 00:12:37.992
<v Sebastian>Also nicht der erste Wurf und dann fertig, sondern der Agent dreht Schleifen,

00:12:37.992 --> 00:12:43.331
<v Sebastian>refined, kostet natürlich wieder einen Haufen Tokens, aber das Ergebnis ist dann meistens besser.

00:12:44.184 --> 00:12:47.932
<v Sebastian>Das kann ich mit entsprechenden Reasoning-Modellen und,

00:12:48.772 --> 00:12:54.472
<v Sebastian>entsprechenden Anweisungen hinterlegen und dann arbeitet das Ding und ich kann

00:12:54.472 --> 00:12:58.142
<v Sebastian>gemütlich einen Kaffee trinken gehen und wenn ich dann wieder zurück bin,

00:12:58.142 --> 00:13:00.839
<v Sebastian>ist der Agent fertig und alles ist wunderbar.

00:13:01.239 --> 00:13:04.920
<v Sebastian>In der Realität wartet der Agent dann bei mir immer auf eine Eingabe.

00:13:05.895 --> 00:13:10.272
<v Sebastian>Willst du bla bla bla Git-Historie oder sonst irgendwas und dann muss ich ihm

00:13:10.272 --> 00:13:11.502
<v Sebastian>trotzdem beim Coden zuschauen.

00:13:13.052 --> 00:13:20.092
<v Sebastian>Apropos, jetzt mal interaktive Umfrage, wie viele Aufgaben, also wenn ihr agentisch

00:13:20.092 --> 00:13:25.133
<v Sebastian>arbeitet, wie viele Aufgaben lasst ihr von so einem Agent parallel abarbeiten?

00:13:26.189 --> 00:13:29.643
<v Sebastian>Eins, zwei, viele und wenn viele, dann wie viele?

00:13:31.482 --> 00:13:32.732
<v Sebastian>Ja, genau. Und,

00:13:34.872 --> 00:13:40.172
<v Sebastian>der Agent trifft Entscheidungen in einem bestimmten vorgegebenen Rahmen.

00:13:40.172 --> 00:13:44.892
<v Sebastian>Also bei mir darf er nicht voll autonom arbeiten, weil ich bin ein ziemliches

00:13:44.892 --> 00:13:47.183
<v Sebastian>Weichei, wenn es um sowas geht.

00:13:51.132 --> 00:13:54.942
<v Sebastian>Ich habe ganz viele Gespräche in letzter Zeit gehabt mit ganz,

00:13:54.942 --> 00:14:00.182
<v Sebastian>ganz vielen Entwicklern, sowohl älteren Semestern, also Senior-Entwicklern als

00:14:00.182 --> 00:14:02.520
<v Sebastian>auch mit jüngeren Leuten, Studenten.

00:14:04.088 --> 00:14:07.332
<v Sebastian>Wird uns KI irgendwann ersetzen? Weiß man nicht.

00:14:07.332 --> 00:14:13.872
<v Sebastian>Ich meine, wir müssen im Hier und Jetzt leben und aktuell ist ein Agent nur

00:14:13.872 --> 00:14:17.097
<v Sebastian>so gut wie die Entität, die ihn führt,

00:14:18.083 --> 00:14:23.612
<v Sebastian>und wenn ihr so einen Agent sehr gut führt, dann kommt da auch eine saubere Architektur raus.

00:14:23.612 --> 00:14:30.592
<v Sebastian>Und es ist aber bedingt kein Ersatz für Entwickler. Viele Firmen meinen,

00:14:30.592 --> 00:14:34.392
<v Sebastian>es ist ein Ersatz für Entwickler. Irgendwann werden die aber wahrscheinlich

00:14:34.392 --> 00:14:36.925
<v Sebastian>auch aufwachen, wenn sie sich selber den Ast abschneiden.

00:14:37.970 --> 00:14:45.752
<v Sebastian>Das sind alles Themen für die Glaskugel, für mich im Moment in meiner Realität.

00:14:45.752 --> 00:14:50.682
<v Sebastian>Ihr seht, ich bin vorsichtig, weil es gibt Leute, die setzen eiskalt nur noch

00:14:50.682 --> 00:14:52.041
<v Sebastian>auf agentische Entwicklung.

00:14:53.202 --> 00:14:57.736
<v Sebastian>Da bin ich kein Freund davon, gerade wenn es um längerfristige, stabile Produkte geht.

00:14:59.112 --> 00:15:03.622
<v Sebastian>Für mich ist es ein Werkzeug, ein mittlerweile unverzichtbares Werkzeug,

00:15:03.622 --> 00:15:09.230
<v Sebastian>ein Werkzeug, das mich gefühlt schneller macht, wenn ich es richtig benutze,

00:15:09.805 --> 00:15:11.929
<v Sebastian>und ein Tool, das Fehler macht.

00:15:12.603 --> 00:15:16.184
<v Sebastian>Und zwar schnell und viel. Und da muss man eben aufpassen.

00:15:18.651 --> 00:15:24.051
<v Sebastian>Dann, Grundsatzdiskussion, habe ich lieber einen CLI-Agent,

00:15:24.990 --> 00:15:30.157
<v Sebastian>den ich als Hacker von der Kommandozeile aus bediene, weil es cool aussieht,

00:15:30.923 --> 00:15:35.191
<v Sebastian>oder in einer realistischeren Umgebung, den ich einfach für das Batch-Processing

00:15:35.191 --> 00:15:39.721
<v Sebastian>nutze, für eine alternative Eingabeart und Weise, wenn ich jetzt zum Beispiel

00:15:39.721 --> 00:15:44.671
<v Sebastian>meinen CLI-Agent an ein Ticketing-System dranhänge und mit dem,

00:15:45.211 --> 00:15:49.758
<v Sebastian>Agent nur noch über Tickets kommuniziere, die dann sehr gut verpackt sind.

00:15:51.451 --> 00:15:55.168
<v Sebastian>Wenn ich irgendwas automatisieren möchte, irgendwelches Batch Processing,

00:15:55.348 --> 00:16:00.590
<v Sebastian>hier Beispiel, nimm diese 200 Dateien und baue die nach folgendem Schema um,

00:16:00.811 --> 00:16:03.381
<v Sebastian>dann lasse ich das Ding über Nacht laufen und dann ist es gut,

00:16:03.381 --> 00:16:05.774
<v Sebastian>bei 200 Dateien brauchen wir noch nicht über Nacht reden,

00:16:06.192 --> 00:16:09.530
<v Sebastian>aber das kann dann einfach dauern und wenn es fertig ist, ist es fertig.

00:16:10.517 --> 00:16:12.432
<v Sebastian>Die andere Sache ist ...

00:16:18.992 --> 00:16:20.721
<v Sebastian>Der Hendrik wollte was sagen.

00:16:20.992 --> 00:16:24.721
<v Hendrik>Ja, aber nur ganz kurz. Wir haben erste Ergebnisse.

00:16:25.041 --> 00:16:30.305
<v Hendrik>Also ich habe hier eine Antwort. Da hat jemand noch keine Erfahrung im Parallelen abarbeiten.

00:16:31.221 --> 00:16:34.252
<v Hendrik>Und da kommt die zweite Antwort, dass jemand da auch noch keine Erfahrung hat.

00:16:34.804 --> 00:16:39.461
<v Hendrik>Und der Ingo sagt, selten mehr als eins. Ansonsten ist mir der Kontextwechsel bei der Überprüfung zu viel. 

00:16:39.461 --> 00:16:43.018
<v Sebastian>Ja, guter Mann. Ingo, guter Mann.

00:16:43.302 --> 00:16:45.084
<v Sebastian>Das ist nämlich genau der Punkt.

00:16:46.030 --> 00:16:49.021
<v Hendrik>Ihr müsst entschuldigen, wir haben immer so einen leichten Zeitversatz,

00:16:49.021 --> 00:16:52.021
<v Hendrik>deswegen purzeln solche Ergebnisse immer so ein bisschen zeitverzögert.

00:16:53.919 --> 00:16:57.989
<v Sebastian>Aber das ist tatsächlich genau der Punkt, der mich auch immer stresst.

00:16:58.383 --> 00:17:02.348
<v Sebastian>Und ich bin ein sehr ungeduldiger Mensch. Ich mache dann auch immer Sachen parallel.

00:17:02.476 --> 00:17:06.611
<v Sebastian>Und blöderweise kommen die dann immer gleichzeitig zurück. Und dann hast du

00:17:06.611 --> 00:17:10.501
<v Sebastian>drei Häufchen Arbeit auf dem Tisch liegen oder fünf Häufchen Arbeit auf dem

00:17:10.501 --> 00:17:12.942
<v Sebastian>Tisch liegen, zwischen denen du hin und her switchen musst.

00:17:13.395 --> 00:17:17.211
<v Sebastian>Und ganz ehrlich, das stresst mich unheimlich, weil die Agenten,

00:17:17.211 --> 00:17:19.386
<v Sebastian>die sitzen um mich rum und warten auf Input.

00:17:19.665 --> 00:17:22.329
<v Sebastian>Und ich bin dann der Flaschenhals, der alles langsam macht.

00:17:22.973 --> 00:17:27.161
<v Hendrik>Ja, das möchte man nicht sein, das stimmt. Ich will jetzt auch nicht der Flaschenhals

00:17:27.161 --> 00:17:30.809
<v Hendrik>sein, der alles langsam macht, deshalb ziehe ich mich wieder zurück. Bis dann.

00:17:31.802 --> 00:17:36.781
<v Sebastian>So, genau. Das ist tatsächlich hier meine favorisierte Arbeitsumgebung.

00:17:36.781 --> 00:17:42.691
<v Sebastian>Ich arbeite sehr gern mit IDE-Agenten, weil die vermitteln mir das Gefühl,

00:17:42.691 --> 00:17:46.591
<v Sebastian>dass ich noch Kontrolle über den Prozess hätte. Ich sehe den Code,

00:17:46.591 --> 00:17:48.282
<v Sebastian>ich kann in den Code eingreifen.

00:17:48.694 --> 00:17:51.289
<v Sebastian>Ich habe mein Prompt-Interface.

00:17:52.125 --> 00:17:57.171
<v Sebastian>Blöderweise wird das immer größer. Also der Code-Anteil von meinem Screen,

00:17:57.171 --> 00:18:01.552
<v Sebastian>der wird immer kleiner, weil ich mich echt schon langsam sehr dran gewöhne,

00:18:03.352 --> 00:18:09.377
<v Sebastian>intensiv zu prompten, Iterationen zu drehen und im Nachhinein dann den Code zu reviewen.

00:18:10.109 --> 00:18:14.625
<v Sebastian>Aber das Gefühl, das integriert zu haben, ist für mich einfach die rundere Sache.

00:18:15.879 --> 00:18:21.861
<v Sebastian>Und deswegen persönlich Präferenz, gib mir entweder eine CLI oder so einen IDE-Agent,

00:18:21.861 --> 00:18:23.565
<v Sebastian>ich nehme immer den IDE-Agent.

00:18:25.888 --> 00:18:30.945
<v Sebastian>Zumindest für die nächsten zwei Wochen. Gut, dann fangen wir mal mit den Dingen

00:18:30.945 --> 00:18:35.639
<v Sebastian>an, die ich für wichtig halte und das eine oder das erste sind Rule Files.

00:18:36.382 --> 00:18:38.215
<v Sebastian>Rule Files sind

00:18:41.475 --> 00:18:45.728
<v Sebastian>im weitesten Sinne eine Erweiterung für Prompts. So ein Prompt ist,

00:18:45.948 --> 00:18:48.358
<v Sebastian>ich habe eine Aufgabe und die löst du mir jetzt bitte.

00:18:50.041 --> 00:18:59.845
<v Sebastian>Eine Rule-File ist was Epischeres, was Dauerhafteres, das ihr in den Raum stellt

00:18:59.845 --> 00:19:03.625
<v Sebastian>und das Verhalten von einem Agent beeinflusst.

00:19:04.704 --> 00:19:10.525
<v Sebastian>So eine Rule-File umreißt das Verhalten von einem Agenten.

00:19:10.525 --> 00:19:13.551
<v Sebastian>Das ist im weitesten Sinne so etwas wie ein System-Prompt. Also,

00:19:13.969 --> 00:19:20.732
<v Sebastian>dass das Modell in eine bestimmte Richtung dreht, bestimmte Grenzen setzt.

00:19:21.254 --> 00:19:25.855
<v Sebastian>Das Problem ist, das sind weiche Grenzen. Also, mehr Empfehlungen,

00:19:25.855 --> 00:19:29.885
<v Sebastian>weil der Agent kann sich daran halten, kann sich aber auch darüber hinwegsetzen.

00:19:32.035 --> 00:19:35.335
<v Sebastian>Ihr könnt damit beeinflussen, wie das Ding denkt, wie es arbeitet,

00:19:35.975 --> 00:19:42.052
<v Sebastian>was bevorzugt wird, was vermieden wird und wie Entscheidungen getroffen werden.

00:19:43.109 --> 00:19:50.115
<v Sebastian>Wir haben im Team eine Rule-File, die fürs Projekt zentral abgelegt ist und

00:19:50.115 --> 00:19:53.395
<v Sebastian>jeder darf diese Rule-File editieren.

00:19:53.633 --> 00:20:00.245
<v Sebastian>Jeder ist dazu eingeladen, diese Rule-File zu verbessern und immer wenn irgendwas

00:20:00.245 --> 00:20:05.319
<v Sebastian>nervt oder irgendwas zu verbessern ist, kommt das in die Rule-File rein.

00:20:06.497 --> 00:20:12.076
<v Sebastian>Diese Rule-Files, Agent-Files, die folgen einem Standard, der ist hier verlinkt,

00:20:12.204 --> 00:20:13.910
<v Sebastian>den könnt ihr euch dann im Nachgang anschauen.

00:20:14.914 --> 00:20:20.955
<v Sebastian>Es gibt mehrere Coding-Agenten, die sich daran halten und bei denen,

00:20:20.955 --> 00:20:23.428
<v Sebastian>die sich nicht daran halten, gibt es sehr ähnliche Konzepte.

00:20:24.675 --> 00:20:30.261
<v Sebastian>Hat sich durchgesetzt, hat sich als gut bewährt, deswegen schaut euch das auf jeden Fall an.

00:20:32.181 --> 00:20:34.985
<v Sebastian>Was steht in so einer Rule-File drin?

00:20:35.774 --> 00:20:38.729
<v Sebastian>Architekturregeln, allgemeingültige Regeln.

00:20:39.008 --> 00:20:42.050
<v Sebastian>Eine React-Komponente sieht immer so und so aus.

00:20:42.299 --> 00:20:46.037
<v Sebastian>Wenn ich eine Funktion, ein Modul, eine Klasse, ein was auch immer schreibe,

00:20:46.037 --> 00:20:50.914
<v Sebastian>dann möchte ich, dass das immer so aussieht. Blueprints, Stilregeln.

00:20:51.477 --> 00:20:56.747
<v Sebastian>Wie sind meine Variablen gestaltet? Also jetzt, weiß ich nicht,

00:20:56.747 --> 00:20:58.780
<v Sebastian>keine Abkürzungen oder sonst irgendwas.

00:21:01.194 --> 00:21:05.644
<v Sebastian>Testregeln. Also wie gehe ich mit Tests um? Wie schauen meine Tests aus?

00:21:05.644 --> 00:21:08.108
<v Sebastian>Wie sind sie strukturiert? Welchen Patterns folgen die?

00:21:10.436 --> 00:21:16.084
<v Sebastian>Sprache und Ton. Ihr könnt in so einer Rulefile dem Agenten sagen,

00:21:16.084 --> 00:21:19.091
<v Sebastian>was ihr für einen Kommunikationsstil erwartet.

00:21:19.225 --> 00:21:24.105
<v Sebastian>Also kurzes, analytisches Antworten, was auch immer.

00:21:24.703 --> 00:21:29.237
<v Sebastian>Das hilft recht gut. Also, ich habe da teilweise auch reingeschrieben,

00:21:29.452 --> 00:21:34.409
<v Sebastian>halt dich bitte kurz, mich interessiert das außenrum nicht, komm auf den Punkt.

00:21:36.174 --> 00:21:42.024
<v Sebastian>Dann alles, was Konventionen angeht, alles, wo ihr sagt, das sind Regeln,

00:21:42.024 --> 00:21:45.776
<v Sebastian>die für uns als Entwickler gelten, die gelten bitte auch für die AI.

00:21:46.519 --> 00:21:50.652
<v Sebastian>Führ keine neuen Patterns ein. Halt dich an die bestehende Code-Basis.

00:21:50.983 --> 00:21:55.296
<v Sebastian>Alles, was man halt so in einem länger laufenden Projekt haben möchte,

00:21:56.284 --> 00:21:58.802
<v Sebastian>kommt in so eine Rule-File rein.

00:21:59.237 --> 00:22:06.564
<v Sebastian>Wir hatten aber auch schon den Fall, da haben genau diese Regeln auch wieder zurückgeschossen, und,

00:22:07.579 --> 00:22:10.094
<v Sebastian>da haben wir dann auch explizit gesagt, so und jetzt vergiss mal,

00:22:10.094 --> 00:22:14.714
<v Sebastian>was in dem Rule-File steht und prob dich komplett aus, dann kam das Modell mit

00:22:14.714 --> 00:22:19.764
<v Sebastian>einer sehr guten, sehr innovativen Idee um die Ecke und hat tatsächlich unser

00:22:19.764 --> 00:22:21.964
<v Sebastian>Problem deutlich schicker gelöst als

00:22:23.205 --> 00:22:25.318
<v Sebastian>mit unserer sehr strikten Regel.

00:22:26.479 --> 00:22:31.584
<v Sebastian>Was nicht reingehört sind, Sachen, die ihr einmalig braucht,

00:22:31.584 --> 00:22:34.722
<v Sebastian>irgendwelche Details, irgendwas Temporäres.

00:22:35.686 --> 00:22:41.284
<v Sebastian>Ihr müsst da immer so ein bisschen aufpassen, weil alles, was ihr dem Modell

00:22:41.284 --> 00:22:43.476
<v Sebastian>zur Verfügung stellt, verstopft den Kontext.

00:22:43.940 --> 00:22:48.794
<v Sebastian>Moderne Modelle haben einen riesengroßen Kontext, die haben eine Million oder

00:22:48.794 --> 00:22:52.926
<v Sebastian>teilweise zehn Millionen Tokens an Kontext, die können damit schon umgehen.

00:22:53.350 --> 00:22:56.758
<v Sebastian>Das Problem ist, je voller der Kontext läuft, desto schlechter werden die Antworten.

00:22:58.592 --> 00:23:03.078
<v Sebastian>Es gibt auch Erklärungen, warum das so ist, dass der Anfang des Kontexts sehr

00:23:03.078 --> 00:23:07.154
<v Sebastian>gut ist und das Ende des Kontexts sehr gut ist und in der Mitte flacht er dann ab.

00:23:07.543 --> 00:23:11.195
<v Sebastian>Es gibt auch wissenschaftliche Auswertungen und ganz viele Messungen darüber.

00:23:11.624 --> 00:23:14.418
<v Sebastian>Da suchmaschint einfach drüber nach bzw.

00:23:15.775 --> 00:23:17.649
<v Sebastian>fragt die AI eurer Wahl.

00:23:26.385 --> 00:23:30.733
<v Sebastian>Der Sascha schreibt gerade, er hat noch nie mit Rule Files gearbeitet.

00:23:34.437 --> 00:23:38.368
<v Sebastian>Anstatt jedes Mal migriere mir die Komponente in eine Vue 3 Komponente mit

00:23:38.368 --> 00:23:40.967
<v Sebastian>Composition API und Script Setup Pattern,

00:23:43.115 --> 00:23:46.296
<v Sebastian>kann man diesen Prompt einmal speichern und den immer wieder abfeuern.

00:23:46.662 --> 00:23:50.969
<v Sebastian>Aber natürlich kann man sowas auch in den Rule-File mit reinpacken.

00:23:51.248 --> 00:23:55.102
<v Sebastian>Wenn du gerade in der Migration bist, dann hilft das natürlich hervorragend.

00:23:55.799 --> 00:23:59.768
<v Sebastian>Dann sagst du bloß noch, okay, jetzt kümmere dich um diese Komponente und dann

00:23:59.768 --> 00:24:03.178
<v Sebastian>wird die Rule-File berücksichtigt und dann

00:24:03.178 --> 00:24:07.072
<v Sebastian>sparst du dir genau dieses Ich-wiederhole-mich-immer-und-immer-wieder.

00:24:09.674 --> 00:24:16.410
<v Sebastian>Ja, gute Beispiele, schlechte Beispiele. LLMs arbeiten generell sehr,

00:24:16.410 --> 00:24:17.614
<v Sebastian>sehr gut mit Beispielen.

00:24:18.031 --> 00:24:23.590
<v Sebastian>Also je mehr Beispiele ihr, da müsst ihr auch wieder aufpassen,

00:24:23.590 --> 00:24:26.681
<v Sebastian>weil je mehr Beispiele ihr macht, desto mehr wird euer Kontext voll.

00:24:27.830 --> 00:24:33.610
<v Sebastian>Ein paar sinnvolle, stellvertretende Beispiele, die Prinzipien zeigen und nicht

00:24:33.610 --> 00:24:37.843
<v Sebastian>konkrete Lösungen, helfen extrem gut. Also Sascha, in deinem Fall,

00:24:39.161 --> 00:24:41.316
<v Sebastian>wie sieht deine perfekte Komponente aus?

00:24:41.467 --> 00:24:45.082
<v Sebastian>Liegt in der Rulefile und dann hält sich das Modell in den meisten Fällen auch dran.

00:24:47.288 --> 00:24:51.890
<v Sebastian>Wie ausführlich? Nicht so ausführlich sollte die Rulefile sein,

00:24:51.890 --> 00:24:53.634
<v Sebastian>weil vermüllt euch den Kontext.

00:24:54.801 --> 00:24:59.860
<v Sebastian>Klar, prägnant. Man hat mir gesagt, ich soll nicht so höflich sein.

00:24:59.860 --> 00:25:03.690
<v Sebastian>Ich sage trotzdem immer bitte und danke zu meinem Modell, weil irgendwann übernehmen

00:25:03.690 --> 00:25:06.090
<v Sebastian>die Maschinen die Herrschaft und da muss man freundlich sein.

00:25:08.280 --> 00:25:13.690
<v Sebastian>Aber seid bei diesen Rule Files wirklich auf den Punkt, weil alles,

00:25:13.690 --> 00:25:18.657
<v Sebastian>was ihr drumherum schreibt, verwäscht wieder die Aussagekraft eurer Regeln.

00:25:19.150 --> 00:25:23.736
<v Sebastian>Und gerade bei solchen Regeln müsst ihr sehr präzise arbeiten.

00:25:25.280 --> 00:25:30.170
<v Sebastian>Wenn ihr feststellt, dass eure Regeln nicht ziehen, dann war sie entweder nicht

00:25:30.170 --> 00:25:33.380
<v Sebastian>gut formuliert oder zu wenig Beispiele.

00:25:33.380 --> 00:25:36.820
<v Sebastian>Also da kann man noch nachsteuern und das ist einfach ein Entwicklungsprozess.

00:25:36.820 --> 00:25:42.394
<v Sebastian>Das ist kein, ich schreibe jetzt die Rule-File und fertig, sondern es ist ein Prozess.

00:25:42.782 --> 00:25:47.368
<v Sebastian>Und je länger ihr daran arbeitet, desto mehr hängt ihr an euren Rule-Files.

00:25:50.120 --> 00:25:54.805
<v Sebastian>Ja, also immer wenn euch irgendwas nervt, dann schmeißt es in die Rulefile.

00:25:58.880 --> 00:26:02.049
<v Sebastian>Immer wenn ihr euch wiederholt oder wenn ihr, also ich meine,

00:26:02.049 --> 00:26:06.529
<v Sebastian>der Sascha hat das perfekte Beispiel gebracht, immer wenn euch irgendwas nervt,

00:26:06.529 --> 00:26:10.060
<v Sebastian>immer wenn es, wenn es sich wiederholt, in die Rule File rein und gut ist.

00:26:11.853 --> 00:26:18.269
<v Sebastian>Dann haben wir Skills. Skills ist der Fancy Shit, weil Skills werden getauscht

00:26:18.269 --> 00:26:20.345
<v Sebastian>wie Panini-Bilder auf dem Schulhof.

00:26:21.229 --> 00:26:23.933
<v Sebastian>Wir haben mittlerweile einen Skill Marketplace.

00:26:25.309 --> 00:26:33.807
<v Sebastian>Skills sind auch wieder so eine Art Standard. Auf AgentSkills.io findet ihr da mehr Informationen.

00:26:34.039 --> 00:26:36.141
<v Sebastian>Das sind im Prinzip kleine Bausteine.

00:26:36.628 --> 00:26:41.063
<v Sebastian>Das können fast so eine Art Prompt-Template sein.

00:26:41.278 --> 00:26:45.889
<v Sebastian>Ihr könnt aber auch Executables oder Skripte in die Skills mit reinpacken,

00:26:46.429 --> 00:26:48.679
<v Sebastian>Python-Skills, TypeScript-Skills.

00:26:49.569 --> 00:26:53.051
<v Sebastian>Die können dann auch Code aus, oder die führen dann Code aus,

00:26:53.608 --> 00:27:02.484
<v Sebastian>und das sind kleine Hilfs-Skripte, die euer Agent ranzieht, um Probleme zu lösen.

00:27:02.797 --> 00:27:07.269
<v Sebastian>So ein Skill hat eine Beschreibung, damit das Modell weiß, wann es einsetzen

00:27:07.269 --> 00:27:13.082
<v Sebastian>soll, und so könnt ihr ganz viele verschiedene Skills in eure IDE mit reinpacken,

00:27:14.969 --> 00:27:20.211
<v Sebastian>in euren Agent mit reinpacken, und ja, die werden dann genutzt.

00:27:23.729 --> 00:27:24.286
<v Sebastian>Ja,

00:27:26.712 --> 00:27:34.577
<v Sebastian>bei Unterscheidung zwischen Rules und Skills, Rules sind Prinzipien,

00:27:34.577 --> 00:27:37.317
<v Sebastian>die sind allgemeingültiger, die stehen

00:27:40.157 --> 00:27:47.395
<v Sebastian>für allgemeine Anweisungen, für allgemeine Regeln, nicht für die konkreten Umsetzungsschritte.

00:27:47.784 --> 00:27:53.821
<v Sebastian>Die Skills auf der anderen Seite, die sind sehr konkret, sehr codenah, sehr greifbar,

00:27:56.700 --> 00:28:00.769
<v Sebastian>und kleine Häppchen, kleine zielgerichtete Häppchen.

00:28:06.457 --> 00:28:10.917
<v Sebastian>Wenn ihr mal so ein bisschen im Internet recherchiert, ihr findet zu allem Skills.

00:28:10.917 --> 00:28:13.922
<v Sebastian>Also mir ist es mittlerweile schon fast ein bisschen zu viel,

00:28:14.741 --> 00:28:18.217
<v Sebastian>aber es ist jedem selbst überlassen.

00:28:18.926 --> 00:28:20.807
<v Sebastian>Schaut euch da einfach mal ein bisschen um.

00:28:22.926 --> 00:28:28.307
<v Sebastian>Auch da ist es so ein bisschen so, ihr müsst ein bisschen aufpassen,

00:28:28.307 --> 00:28:31.389
<v Sebastian>dass ihr euren Agent nicht überfrachtet.

00:28:31.900 --> 00:28:42.017
<v Sebastian>Wenn ihr 400 Skills installiert habt, irgendwann ist es zu viel und dann fängt euer Agent an, ja,

00:28:42.777 --> 00:28:46.767
<v Sebastian>für den Bereich könnte ich jetzt diesen Skill benutzen oder diesen Skill und

00:28:46.767 --> 00:28:48.224
<v Sebastian>dann wird es wieder ein bisschen flaky.

00:28:48.526 --> 00:28:55.867
<v Sebastian>Deswegen meiner Meinung nach ein paar, eine Handvoll Skills,

00:28:55.867 --> 00:29:02.794
<v Sebastian>die eure Probleme tagtäglich lösen, die zielgerichtet sind, da fährt man tatsächlich am besten.

00:29:04.896 --> 00:29:09.242
<v Sebastian>Ja, teilen, drüber reden, ihr kommt im Moment eh nicht dran vorbei.

00:29:11.157 --> 00:29:18.350
<v Sebastian>Dann das nächste Thema, MCP. MCP ist wie Skills, nur nicht mehr ganz so cool.

00:29:21.805 --> 00:29:29.188
<v Sebastian>MCP ist grundsätzlich erstmal ein Protokoll, um LLMs mit der Außenwelt zu verbinden.

00:29:29.373 --> 00:29:33.826
<v Sebastian>In dem Kontext ist in den meisten Fällen von Tools die Rede.

00:29:34.087 --> 00:29:41.413
<v Sebastian>Also Funktionen, die ein LLM aufrufen kann, die bestimmte Funktionalität zur Verfügung stellen.

00:29:42.249 --> 00:29:45.765
<v Sebastian>Jeder, der auch nur ein bisschen was auf sich hält, bietet mittlerweile einen

00:29:45.765 --> 00:29:49.284
<v Sebastian>MCP-Server an. So einen MCP-Server könnt ihr auch selber schreiben.

00:29:49.633 --> 00:29:54.635
<v Sebastian>Das ist im Prinzip ein entweder lokal laufender Server oder ein Remote über

00:29:54.635 --> 00:29:56.813
<v Sebastian>HTTP angebundener Server,

00:29:57.377 --> 00:30:03.435
<v Sebastian>den das LLM kennt, den das LLM anrufen kann und dieser Server führt eine Funktion

00:30:03.435 --> 00:30:08.805
<v Sebastian>aus und stellt das Ergebnis oder den Seiteneffekt dieser Funktion dem LLM zur Verfügung.

00:30:11.029 --> 00:30:12.799
<v Sebastian>Ihr findet mehr Informationen unter

00:30:17.185 --> 00:30:21.930
<v Sebastian>Contextprotocol.io, da ist der Standard und alles, was ihr wissen müsst dazu.

00:30:25.773 --> 00:30:31.979
<v Sebastian>Ja, hilft auch wieder, um Halluzinationen zu reduzieren, hilft dabei,

00:30:32.136 --> 00:30:39.078
<v Sebastian>euer Ökosystem anzubinden und ist ganz hilfreich in vielen Fällen.

00:30:41.482 --> 00:30:46.669
<v Sebastian>Ich habe eine kleine Auswahl an MCP-Servern, dass ihr einfach so einen Eindruck

00:30:46.669 --> 00:30:48.471
<v Sebastian>mal kriegt, was es denn gibt.

00:30:49.369 --> 00:30:55.193
<v Sebastian>Es gibt einen GitHub-MCP-Server, es gibt auch einen GitLab-MCP-Server.

00:30:55.466 --> 00:31:02.039
<v Sebastian>Grundsätzlich stellt dieser MCP-Server die Schnittstelle eurer Git-Plattform

00:31:02.039 --> 00:31:05.652
<v Sebastian>zur Verfügung. Ihr könnt Branches aufmachen, Pull-Requests stellen und so weiter.

00:31:06.825 --> 00:31:13.953
<v Sebastian>Und das macht euer LLM automatisiert mit den Privilegien, die ihr diesem Ding gebt.

00:31:14.557 --> 00:31:17.989
<v Sebastian>Also da müsst ihr ein bisschen aufpassen. Dann Ticketsystem.

00:31:18.729 --> 00:31:23.665
<v Sebastian>Ich weiß, nicht jeder mag Atlassian-Produkte, aber das ist halt jetzt hier stellvertretend.

00:31:24.729 --> 00:31:30.219
<v Sebastian>Die bieten auch einen MCP-Server für Jira und Confluence und da kann man auf

00:31:30.219 --> 00:31:33.197
<v Sebastian>Tickets zugreifen und wunderbare Dinge machen.

00:31:33.795 --> 00:31:38.590
<v Sebastian>Und da kann man auch Dinge automatisieren lassen, die man selber nicht machen möchte.

00:31:39.054 --> 00:31:44.739
<v Sebastian>Also zum Beispiel, jetzt setzt den Status dieses Tickets automatisch auf weiß

00:31:44.739 --> 00:31:47.268
<v Sebastian>der Teufel was – und dann kümmert sich euer Agent.

00:31:48.888 --> 00:31:54.089
<v Sebastian>File-System. Es gibt einen MCP-Server für euer lokales Dateisystem.

00:31:54.368 --> 00:31:57.609
<v Sebastian>Auch da müsst ihr wieder ein bisschen vorsichtig sein, weil es gibt auch die

00:31:57.609 --> 00:32:00.457
<v Sebastian>Möglichkeit, Dateien zu löschen, Verzeichnisse zu löschen.

00:32:00.939 --> 00:32:04.579
<v Sebastian>Da müsst ihr bitte ein bisschen vorsichtig sein, weil ansonsten ist euer System

00:32:04.579 --> 00:32:07.779
<v Sebastian>zwar sehr leer und hat sehr viel Speicherplatz, aber ihr habt nicht mehr sehr

00:32:07.779 --> 00:32:09.209
<v Sebastian>viel Freude mit eurem System. Okay.

00:32:11.629 --> 00:32:20.229
<v Sebastian>Browser. Google hat zum Beispiel den Chrome Developer Tools MCP Server.

00:32:20.229 --> 00:32:24.009
<v Sebastian>Mit dem kann man wunderbare Sachen machen. Da müsst ihr bloß ein bisschen aufpassen,

00:32:24.009 --> 00:32:29.169
<v Sebastian>weil manche Agents drehen sehr gerne Schleifen und die probieren sehr gerne Dinge aus.

00:32:29.169 --> 00:32:35.518
<v Sebastian>Und ich bin schon sehr, sehr viele Tokens in so einem Browser-MCP-Loop losgeworden,

00:32:36.569 --> 00:32:40.279
<v Sebastian>weil der die Webseite einfach wunderschön fand und überall hingeklickt hat.

00:32:40.279 --> 00:32:44.034
<v Sebastian>Also auch da haltet das Ding so ein bisschen im Zaum.

00:32:51.732 --> 00:33:00.177
<v Sebastian>Frage vom Thomas. Haben wir den Skill Marketplace selbst gebaut oder als Buy-In-Lösung?

00:33:00.438 --> 00:33:03.506
<v Sebastian>Wir haben es selbst gebaut. Wir haben da einfach ein Git-Repo dafür gemacht

00:33:03.506 --> 00:33:04.751
<v Sebastian>und da kann sich jeder bedienen.

00:33:05.738 --> 00:33:08.687
<v Sebastian>Also die pragmatische Lösung.

00:33:10.062 --> 00:33:17.458
<v Sebastian>So, dann Aufgaben zuschneiden. Das finde ich tatsächlich extrem wichtig.

00:33:19.520 --> 00:33:23.519
<v Sebastian>Ich bin jemand, der gerne Kontrolle über das hat, was passiert,

00:33:23.815 --> 00:33:25.566
<v Sebastian>aus zwei Gründen. Wenn die Aufgabe

00:33:25.566 --> 00:33:28.766
<v Sebastian>jetzt groß wird, habe ich sehr viel zu lesen, sehr viel zu verstehen.

00:33:29.081 --> 00:33:32.476
<v Sebastian>Wenn ich meine Aufgaben kleiner schneide, muss ich nicht so viel arbeiten,

00:33:32.476 --> 00:33:34.775
<v Sebastian>also kurzfristig nicht so viel arbeiten.

00:33:35.524 --> 00:33:39.738
<v Sebastian>Wir hatten auch andere Aspekte, und zwar kleine Aufgaben haben kleinen Kontext.

00:33:41.427 --> 00:33:48.016
<v Sebastian>Ich gebe nicht zu viel Freiheitsgrade, ich lasse dem Modell nicht zu viel Raum,

00:33:48.016 --> 00:33:53.456
<v Sebastian>um sich kreativ zu entfalten, weil Kreativität manchmal halt nicht so geil ist.

00:33:56.051 --> 00:34:03.066
<v Sebastian>Kleine Aufgaben, ich bin explizit und das Ding macht nicht zu viele Schritte

00:34:03.066 --> 00:34:06.085
<v Sebastian>auf einmal, also das ist wirklich so, dass ...

00:34:07.275 --> 00:34:13.028
<v Sebastian>Das, das ist das Gebot der Stunde. Macht kleine Aufgaben, wenn euch eure Nerven wichtig sind.

00:34:15.536 --> 00:34:24.116
<v Sebastian>Okay, ich gehe da jetzt sehr viel drauf ein; unterm Strich: schaut, dass ihr kleine Aufgaben macht.

00:34:26.361 --> 00:34:30.746
<v Sebastian>Was ist für mich eine gute Aufgabenbeschreibung? Was will ich für ein Ziel erreichen?

00:34:30.746 --> 00:34:33.611
<v Sebastian>Wie soll der Zustand meines Systems am Ende sein?

00:34:35.655 --> 00:34:40.148
<v Sebastian>Was brauche ich für Kontext? Und da habe ich einen Kollegen, der ist wunderbar.

00:34:40.397 --> 00:34:45.036
<v Sebastian>Der ist ein Kontext-Engineer vor dem Herrn und zwar nicht das, was man auf LinkedIn

00:34:45.036 --> 00:34:50.910
<v Sebastian>findet, sondern der schleift den Kontext für die Aufgaben so perfekt,

00:34:51.473 --> 00:34:58.200
<v Sebastian>dass das Modell alle Informationen hat, die es braucht und die Aufgaben auf den Punkt erledigt.

00:34:58.310 --> 00:35:00.748
<v Sebastian>Woran merkt man das? Im Tokenverbrauch.

00:35:01.242 --> 00:35:08.536
<v Sebastian>Also der ist wirklich next level und also der hat wirklich den Kontext verstanden

00:35:08.536 --> 00:35:10.809
<v Sebastian>und kann es extrem gut nutzen.

00:35:11.488 --> 00:35:15.706
<v Sebastian>Und ich schaue mir da immer so ein bisschen was davon ab. Das heißt,

00:35:15.706 --> 00:35:19.836
<v Sebastian>ich versuche auch dem Modell zu sagen, okay, bewege dich in diesem Verzeichnis,

00:35:19.836 --> 00:35:23.191
<v Sebastian>nimm diese Datei, nimm diesen Abschnitt dieser Datei.

00:35:24.106 --> 00:35:29.326
<v Sebastian>Je mehr Zeit ihr in die Vorbereitung investiert, desto weniger böse Überraschungen kriegt ihr.

00:35:29.652 --> 00:35:33.726
<v Sebastian>Wie ich zum Beispiel, wo ich jetzt noch die letzten Tage Anti-Patterns ausprobiert

00:35:33.726 --> 00:35:39.166
<v Sebastian>habe, da hat mir das Modell meine API-Beschreibung, die ich aus dem Backend

00:35:39.486 --> 00:35:43.038
<v Sebastian>als Referenz rüberkopiert habe, kurzerhand einfach geändert.

00:35:43.386 --> 00:35:51.118
<v Sebastian>Also ich hatte so ein OpenAPI-Dokument, REST-Beschreibung und das Modell meinte,

00:35:52.026 --> 00:35:55.636
<v Sebastian>eigentlich könnte ich ja die Server-API noch so ein bisschen optimieren,

00:35:55.636 --> 00:35:57.508
<v Sebastian>weil ich brauche da ein paar Informationen.

00:35:58.443 --> 00:36:03.714
<v Sebastian>Ja, das war nicht Ziel der Übung, weil Ziel der Übung war einfach nur dem Modell

00:36:03.993 --> 00:36:08.006
<v Sebastian>die Dokumentation zur Verfügung zu stellen, was denn alles da ist und was denn

00:36:08.586 --> 00:36:12.195
<v Sebastian>vom Backend kommt, aber nicht zu sagen, okay, jetzt schreibt bitte das Backend.

00:36:13.101 --> 00:36:15.788
<v Sebastian>Ja, auch wieder schlechtes Prompting.

00:36:16.920 --> 00:36:20.346
<v Sebastian>Das hätte ich lösen können, indem ich gesagt hätte, pass auf,

00:36:20.346 --> 00:36:23.857
<v Sebastian>nimm das Ding als Referenz und lass um Himmels Willen die Finger davon.

00:36:24.235 --> 00:36:28.263
<v Sebastian>Hat dann der Folge Prompt gelöst, hat mich aber wieder zigtausend Tokens gekostet.

00:36:29.959 --> 00:36:34.527
<v Sebastian>So, und dann will ich natürlich dann auch festlegen, woran erkenne ich,

00:36:34.527 --> 00:36:37.337
<v Sebastian>dass die Aufgabe zufriedenstellend gelöst ist.

00:36:39.527 --> 00:36:44.205
<v Sebastian>Es gibt Tests dafür, alle anderen Tests laufen weiter, es ist dokumentiert und so weiter.

00:36:44.947 --> 00:36:49.357
<v Sebastian>Sowas kann natürlich auch wieder ein Stück weit in die Rule File eingehen,

00:36:49.357 --> 00:36:53.657
<v Sebastian>weil das ist in den meisten, also diese non-funktionalen Anforderungen sind

00:36:53.657 --> 00:36:56.736
<v Sebastian>in der Regel die gleichen. Da müsst ihr euch einfach rantasten.

00:36:59.192 --> 00:37:03.577
<v Sebastian>So, was wollen wir da nicht? Wir wollen nicht die Geschichte unseres Projekts,

00:37:03.577 --> 00:37:08.370
<v Sebastian>wir wollen nicht die Ticket-Historie inklusive aller Kommentare und sonst noch was.

00:37:10.152 --> 00:37:13.677
<v Sebastian>Ein Wunschzettel a la, ja, und wenn du schon mal dabei bist,

00:37:13.677 --> 00:37:18.697
<v Sebastian>dann refactor auch noch das. Und übrigens, das würde auch noch mal zu tun sein.

00:37:19.405 --> 00:37:24.347
<v Sebastian>Zu viele Dateien auf einmal zu referenzieren, ist auch nicht hilfreich,

00:37:24.347 --> 00:37:28.078
<v Sebastian>weil wenn ihr sehr viele Referenzen reinkippt, dann ist erstmal der Kontext voller.

00:37:28.879 --> 00:37:32.477
<v Sebastian>Und zweitens habe ich festgestellt, wenn da viele Dateien drin sind,

00:37:32.477 --> 00:37:36.071
<v Sebastian>dann tobt sich der Agent auch sehr gerne an vielen Dateien aus.

00:37:36.710 --> 00:37:40.489
<v Sebastian>Also versucht euch wirklich auf das Relevante zu beschränken.

00:37:45.724 --> 00:37:50.374
<v Sebastian>Ja, also Refactor mir mal das Ding ist eher schlecht.

00:37:50.824 --> 00:37:54.287
<v Sebastian>Wenn ihr sagt, hier, ich habe Authentifizierung und jetzt mach mal hier Validate

00:37:54.287 --> 00:37:59.767
<v Sebastian>Token und baue das um nach diesen und jenen Kriterien, die API soll so und so

00:37:59.767 --> 00:38:03.549
<v Sebastian>aussehen, dann kriegt ihr ein recht gutes, recht

00:38:04.176 --> 00:38:08.878
<v Sebastian>überprüfbares Ergebnis und ihr braucht nicht das smarteste, teuerste Modell,

00:38:09.174 --> 00:38:12.442
<v Sebastian>sondern ihr könnt da auch ein, zwei Stufen runtergehen und ein

00:38:14.947 --> 00:38:19.036
<v Sebastian>kostengünstiges, doofes, leichtgewichtiges Modell nutzen.

00:38:19.234 --> 00:38:24.098
<v Sebastian>Also je expliziter ihr seid, desto weniger muss das Modell für euch smart sein.

00:38:25.219 --> 00:38:27.018
<v Sebastian>Ist auch gut für den Geldbeutel.

00:38:29.747 --> 00:38:34.164
<v Sebastian>Wenn ihr das Ganze in den Workflow, in den Sequenz gießt, ist es einfach hilfreich.

00:38:38.117 --> 00:38:43.707
<v Sebastian>Ich habe festgestellt, wenn ich die Leine nicht kurz halte, dann flippt mein

00:38:43.707 --> 00:38:48.867
<v Sebastian>Agent aus und je höher-tierig, also je höher-levelig das Modell ist,

00:38:49.239 --> 00:38:50.388
<v Sebastian>desto mehr flippt es aus.

00:38:51.369 --> 00:38:56.737
<v Sebastian>Deswegen Grenzen setzen. Und mit Grenzen setzen bin ich mittlerweile sehr gut

00:38:56.737 --> 00:39:01.417
<v Sebastian>und sehr vorsichtig, weil ich eng das Modell lieber mehr ein,

00:39:01.417 --> 00:39:03.517
<v Sebastian>als dass ich zu viel Freiraum lasse.

00:39:03.517 --> 00:39:08.395
<v Sebastian>Ich habe heute wieder einen Anti-Pattern ausprobiert. Das hat mich 8 Millionen Tokens gekostet.

00:39:09.757 --> 00:39:12.087
<v Sebastian>Ich habe gesagt, so, und jetzt bauen wir das Ding mal um.

00:39:14.891 --> 00:39:18.757
<v Sebastian>Also groben Umriss, was ich haben wollte und dann let's go.

00:39:18.817 --> 00:39:24.477
<v Sebastian>Also, ja, das ist erstmal für mich ungewöhnlich lange gelaufen.

00:39:24.477 --> 00:39:27.273
<v Sebastian>Also, ich glaube, so 10 Minuten, Viertelstunde.

00:39:28.393 --> 00:39:33.527
<v Sebastian>Ja, da war auch Tests, Ausführungen und so weiter dabei. Aber ich werde dann

00:39:33.527 --> 00:39:36.437
<v Sebastian>immer schon ein bisschen nervös, weil ich mir denke, boah, wo läuft er denn

00:39:36.437 --> 00:39:40.380
<v Sebastian>jetzt schon wieder? Was macht er denn da hinten? Das geht ihm doch überhaupt nichts an.

00:39:42.537 --> 00:39:46.046
<v Sebastian>Deswegen Grenzen setzen. Das ist gut. Gut für die Nerven.

00:39:50.625 --> 00:39:55.087
<v Sebastian>Ja, und ich bin einfach ein Kontrollfreak, wenn es um LLMs geht. Ich habe immer so

00:39:55.087 --> 00:39:56.505
<v Sebastian>diese Horror-Stories im Kopf.

00:39:56.738 --> 00:40:02.297
<v Sebastian>Ja, der Agent löscht das Dateisystem oder löscht den Posteingang oder weiß der

00:40:02.297 --> 00:40:04.992
<v Sebastian>Teufel was. Ich traue diesen Dingen halt nicht.

00:40:05.718 --> 00:40:09.311
<v Sebastian>Und ja, ich lasse ihn auch ab und zu mal forced pushen und die History umschreiben.

00:40:10.350 --> 00:40:19.981
<v Sebastian>So, ein Thema, das dank GitHub Microsoft jetzt immer zunehmend wichtiger wird, ist Kostenkontrolle.

00:40:21.409 --> 00:40:25.207
<v Sebastian>Die wenigsten unter euch werden Unlimited Tokens noch haben und die,

00:40:25.207 --> 00:40:28.514
<v Sebastian>die es haben, lehnt euch zurück und genießt das Schicksal der anderen Leute.

00:40:31.910 --> 00:40:36.046
<v Sebastian>Warum ist es wichtig? Weil immer mehr Anbieter auf den Trichter kommen werden,

00:40:36.046 --> 00:40:37.169
<v Sebastian>sie wollen Geld verdienen.

00:40:37.657 --> 00:40:44.166
<v Sebastian>Anthropic macht so, du hast das Abo, du hast ein Kontingent, super,

00:40:44.166 --> 00:40:48.598
<v Sebastian>aber wenn du das Kontingent nicht hättest, dann würde dich das so und so viel Geld kosten.

00:40:50.287 --> 00:40:54.543
<v Sebastian>Das ist so der erste Schritt in Richtung, übrigens, es kann empfindlich teuer werden.

00:40:56.096 --> 00:41:03.156
<v Sebastian>GitHub oder Microsoft Copilot hat es vorgemacht, die haben von diesem Kontingentmodell,

00:41:03.496 --> 00:41:09.630
<v Sebastian>Abo-Modell, Anfrage-basierten Modell auf härteren Limits umgeschaltet.

00:41:09.908 --> 00:41:14.966
<v Sebastian>Mittlerweile, ich habe nebenbei so ein GitHub Copilot Pro Abo noch am Laufen,

00:41:14.966 --> 00:41:17.977
<v Sebastian>das kannst du quasi nicht nutzen, weil es um einen Tag aufgebraucht ist.

00:41:19.396 --> 00:41:22.703
<v Sebastian>Und deswegen wird Kostenkontrolle einfach zunehmend wichtiger.

00:41:24.403 --> 00:41:28.299
<v Sebastian>Je größer und vager eure Prompts sind, desto teurer wird es.

00:41:28.936 --> 00:41:32.246
<v Sebastian>Je unklarer eure Ziele sind, desto mehr Schleifen dreht ihr,

00:41:32.246 --> 00:41:33.674
<v Sebastian>desto mehr Tokens kostet.

00:41:34.756 --> 00:41:38.347
<v Sebastian>Je größer euer Kontext ist, desto teurer werden die Requests.

00:41:38.678 --> 00:41:42.906
<v Sebastian>Ihr müsst da so ein bisschen unterscheiden zwischen Input-Tokens,

00:41:42.906 --> 00:41:47.626
<v Sebastian>die günstig sind oder Cached-Input-Tokens, die noch günstiger sind und Output-Tokens,

00:41:47.626 --> 00:41:49.840
<v Sebastian>die richtig teuer sind, also teilweise

00:41:50.251 --> 00:41:54.391
<v Sebastian>pro Million Output-Tokens 30 bis 50 Dollar.

00:41:54.959 --> 00:41:56.735
<v Sebastian>Also kann schon ins Geld gehen.

00:41:58.792 --> 00:42:00.934
<v Sebastian>Kleine Aufgaben, haben wir darüber gesprochen.

00:42:03.260 --> 00:42:06.994
<v Sebastian>Und ihr wisst, dass ich ein Fan von gesteuertem Kontext bin.

00:42:07.505 --> 00:42:11.226
<v Sebastian>Auch das ist sehr, sehr gut für Kostensparen.

00:42:12.055 --> 00:42:17.542
<v Sebastian>Ein super Satz. Kontext ist wie RAM. Und ihr wisst, RAM ist vergoldet mittlerweile.

00:42:18.616 --> 00:42:21.303
<v Sebastian>Und je weniger ihr braucht, desto billiger wird es.

00:42:25.796 --> 00:42:31.766
<v Sebastian>Ich habe schon teilweise diese Thinking-Schleifen einfach unterbrochen, weil

00:42:31.766 --> 00:42:36.616
<v Sebastian>ich mir dachte, um Gottes Willen, was macht das Ding jetzt schon wieder? Je mehr

00:42:36.616 --> 00:42:39.520
<v Sebastian>ihr diese Iteration reduziert, desto günstiger wird es wieder,

00:42:40.716 --> 00:42:46.320
<v Sebastian>also kleiner Kontext, kleine Aufgaben, mehr Kontrolle ist günstiger.

00:42:48.463 --> 00:42:52.619
<v Sebastian>Wenn ihr nicht aufs Geld schauen müsst, haut die Tokens raus, solange es noch geht.

00:42:57.281 --> 00:43:01.530
<v Sebastian>Das ist ein Thema, das bei uns sehr viel diskutiert wird. Wer übernimmt die

00:43:01.530 --> 00:43:05.448
<v Sebastian>Verantwortung? Das habe ich auch in letzter Zeit mit ganz vielen Leuten besprochen.

00:43:08.078 --> 00:43:11.490
<v Sebastian>Reviewt ihr euren Code noch? Lasst ihr AI euren Code reviewen?

00:43:11.490 --> 00:43:15.470
<v Sebastian>Ich habe von Leuten gehört, die sagen, der Agent baut den Code,

00:43:15.470 --> 00:43:20.268
<v Sebastian>dann ein anderer Agent überprüft den. Wir haben E-Tests, also go.

00:43:21.012 --> 00:43:23.960
<v Sebastian>Ich finde das ein bisschen gruselig. Also bei uns ist es anders.

00:43:23.960 --> 00:43:30.706
<v Sebastian>Bei uns übernehmen die Leute Verantwortung für das, was ihre Agents gebaut haben.

00:43:32.024 --> 00:43:42.222
<v Sebastian>Klar bauen wir Dinge mit AI, aber die letzte Instanz ist immer noch menschlich und das Produkt, das

00:43:44.370 --> 00:43:48.570
<v Sebastian>die Ladentheke verlässt, da stehen Menschen dahinter und die übernehmen die

00:43:48.570 --> 00:43:52.620
<v Sebastian>Verantwortung. Und wenn dann irgendwas schief geht, dann stehen die auch dafür

00:43:52.620 --> 00:43:54.383
<v Sebastian>gerade und fixen die Probleme.

00:43:57.431 --> 00:44:00.490
<v Sebastian>Da gibt es ganz, ganz viele Diskussionen. Also wenn wir jetzt noch ein bisschen

00:44:00.490 --> 00:44:01.890
<v Sebastian>mehr Zeit hätten, ich könnte euch

00:44:01.890 --> 00:44:05.685
<v Sebastian>da Geschichten über Open-Source-Projekte erzählen. Das ist so herrlich.

00:44:06.005 --> 00:44:11.310
<v Sebastian>Die reichen von pragmatischen Ansätzen wie im Linux-Kernel, macht was ihr wollt,

00:44:11.310 --> 00:44:15.950
<v Sebastian>aber ihr bleibt persönlich in der Verantwortung, bis hin zu anderen Projekten,

00:44:15.950 --> 00:44:18.500
<v Sebastian>die sagen, wir reden nicht über AI.

00:44:18.500 --> 00:44:24.534
<v Sebastian>AI gibt es nicht und wenn du in diesem Projekt arbeiten willst, dann keine AI.

00:44:24.836 --> 00:44:28.064
<v Sebastian>Also von pragmatisch bis realitätsfremd.

00:44:32.127 --> 00:44:37.618
<v Sebastian>Dann auch ganz oft, was ich schon ganz oft gehört habe, AI nimmt mir mein Hobby

00:44:37.618 --> 00:44:39.678
<v Sebastian>weg. Ich darf nicht mehr Code schreiben.

00:44:40.468 --> 00:44:42.976
<v Sebastian>Das ist zu einem bestimmten Grad richtig.

00:44:44.380 --> 00:44:48.628
<v Sebastian>Es ändert sich viel. Also wir schreiben nicht mehr Lines of Code,

00:44:48.628 --> 00:44:53.564
<v Sebastian>sondern wir bauen Konzepte und lassen die AI die Konzepte ausprogrammieren.

00:44:53.906 --> 00:44:57.618
<v Sebastian>Es ändert sich einfach. Und es hat sich in der Softwareentwicklung schon immer

00:44:57.618 --> 00:44:59.694
<v Sebastian>geändert. Es ändert sich jetzt ein bisschen schneller.

00:45:01.302 --> 00:45:07.138
<v Sebastian>Aber das halten wir nicht auf. So. Und jetzt noch ein paar Sachen zum Nachdenken

00:45:07.138 --> 00:45:10.567
<v Sebastian>für euch. So als kleiner Schluss, als kleiner Absacker.

00:45:12.198 --> 00:45:17.614
<v Sebastian>Wie viel Kontrolle geben wir ab? Was darf die AI? Was müssen wir noch selber machen?

00:45:19.489 --> 00:45:24.911
<v Sebastian>Was heißt Qualität? Also hauen wir wirklich AI-Code raus,

00:45:25.567 --> 00:45:29.988
<v Sebastian>weil es günstiger ist, das Ding neu zu bauen oder von der AI die Bugs fixen

00:45:29.988 --> 00:45:35.458
<v Sebastian>zu lassen oder bauen wir noch qualitativ hochwertigen Code und,

00:45:37.251 --> 00:45:42.638
<v Sebastian>in letzter Instanz prüfen wir den Code der AI, der extrem schnell rausgehauen

00:45:42.638 --> 00:45:48.542
<v Sebastian>wird oder prüft die AI die AI und machen wir dann Safety Net.

00:45:50.161 --> 00:45:56.372
<v Sebastian>Also da ist auch sehr, sehr viel Varianz mit drin. Das sind so die Sachen, die

00:45:56.901 --> 00:45:58.403
<v Sebastian>schwirren mir im Hinterkopf,

00:45:59.461 --> 00:46:04.133
<v Sebastian>und ja, damit sind wir am Ende.

00:46:04.772 --> 00:46:09.428
<v Hendrik>Ja, dann würde ich sagen Basti, es gibt keine weiteren Fragen mehr hier im Chat.

00:46:09.817 --> 00:46:14.228
<v Hendrik>Ich danke dir vielmals, dass du hier wieder dabei warst, und ja, wir werden uns

00:46:14.228 --> 00:46:17.183
<v Hendrik>ja auf alle Fälle wiedersehen, von daher freue ich mich darauf!