Ein Ausflug ins Vibe Coding: Das SpaceCadetDeck

Ein Beispielprojekt um mir mal Agenten beim programmieren anzusehen

Aktuell stehe ich vor der Situation mich mit einer Menge neuer Technologien befassen zu müssen. Ich kann weder für Android noch in Webtechnologien wirklich flüssig programmieren und eine moderne Sprache wie C# steht auch auf der Tagesordnung. Dazu kommt noch das im Moment allgegenwärtige Thema KI. Dazu habe ich zwar eine Meinung, aber noch nicht wirklich viel Erfahrung. Daher habe ich beschlossen, ein Projekt zu starten um das zu ändern.

Das Projekt bot sich quasi von alleine an. Wir sind gerade umgezogen und bei dem Einrichten der Arbeitsumgebung auf meinem Schreibtisch, fiel mir natürlich wieder mein Stream Deck in die Hände, das zwar immer irgendwie einigermaßen lief, aber doch ständig seine Macken hatte. Die alte Software um die Oberfläche einzurichten, ist mittlerweile nicht mehr mit meinem System kompatibel. Die neue Software, die ich mir darauf hin herausgesucht habe, läuft zwar sauber, aber sobald mein Rechner längere Zeit in den Tiefschlaf geht, ist mein Stream Deck tot. Alles in allem kein tragbarer Zustand.

Also habe ich mich mal hingesetzt und mir überlegt, wie ich lernen, KI und mein Stream Deck Problem unter einen Hut bringe. Die Lösung war dann mein Projekt SpaceCadetDeck. Ich programmiere mir das Ganze einfach selbst.

mit dem Stream Deck wollte ich mich allerdings nicht weiter technisch beschäftigen. Denn ich habe ja bereits ein Deck, das ich quasi immer dabei habe. Mein Handy. Das ist ein ganz normales Fairphone 6 mit e/OS als Betriebssystem. Und ein Tastenfeld mit 4x8 Tasten sollte darauf sehr einfach darzustellen sein. Es hat Touch, ich kann die Tasten mit Bildern versehen, beschriften oder auch farbig gruppieren.

Das Handy als Stream Deck

Nun wie bereits erwähnt, beherrsche ich die Programmierung für Android überhaupt nicht. Ich habe mir das Ganze bereits mal angesehen und festgestellt, dass man dafür quasi zwingend Java können muss. Eine Sprache, die ich zwar lernen könnte, aber vom Stil nicht wirklich mag. Irgendwann habe ich dann gelesen, dass es eine Sprache namens Kotlin gibt. Der man das Ganze ebenfalls programmieren kann. Die habe ich mir mal etwas genauer angesehen. Als Sprache liegt sie mir eher und daher habe ich beschlossen, Kotlin zu lernen.

Aber bevor ich es lerne, lasse ich mich auf das größte der kleinen Einzel-Experimente ein. Ich möchte via KI ein Kotlin-Projekt erstellen, dass mir eine Art Stream Deck aufs Handy zaubert. Ohne dass ich auch nur eine einzige Zeile Kotlin selber schreiben könnte. Das heißt, ich kann die KI an dieser Stelle auch nicht kontrollieren und muss ihr einfach glauben, was sie tut. Ich gebe ihr dabei relativ freie Hand. Schau mir jeden Befehl, den sie ausführen möchte vorher an. Damit sie kein Mist auf meinem System baut. Aber inhaltlich weiß ich absolut nichts und kann nicht beurteilen, was sie da tut, außer indem ich mir das Ergebnis anschaue.

Das Programm, das auf dem Handy läuft, soll dabei einigermaßen dumm sein. Es empfängt von einem Server auf dem Rechner ein Tastenlayout für die 32 Tasten, die es darstellen soll, und meldet dem Server dann lediglich zurück, welche dieser Tasten gedrückt wurden. Also nur zwei Aufgaben. Layout empfangen, Tasten senden. Alles andere passiert auf dem Rechner, der damit gesteuert wird.

Die KI, meiner Wahl, war dabei Matrix-Vibe. Einfach weil sie im Gegensatz zu vielen anderen ein europäisches Produkt ist, und ich mir damit gleich einen Einblick in den Stand der Technik auf meinem Kontinent machen kann.

Der Linux Rechner als Server

Auf der Gegenseite wollte ich gerne ein Projekt erstellen in einer Sprache, in der ich mich auskenne, damit ich mir den erzeugten Code anschauen kann und beurteilen, wie er qualitativ zu dem steht, was ich per Hand schreiben würde. Daher habe ich mir für den Server Python ausgesucht und dieser Server namens DeckServer hat ein paar Aufgaben mehr.

Er stellt einen Websocket Server zur Verfügung, mit dem sich der Client auf dem Android System verbindet.
Er nimmt die Tastendrücke vom Android-Client entgegen und führt entsprechend dem zuvor gesendeten Layout, die passenden Aufgaben durch wie Programme starten, Layouts wechseln, zu Fenstern wechseln, die Lautstärke verändern, etc.
Und am wichtigsten natürlich, er muss die Layouts, die konfiguriert sind, zum Android Client schicken.

Die erste Vibe Coding Session

Ich habe beide Projekte parallel entwickelt, jeweils eines in einem getrennten Fenster.

Der Android-Client ist von den Anforderungen sehr übersichtlich. Daher habe ich Ihnen kurz beschrieben: Ich hätte gerne 4x8 Tasten. Ich möchte das layout entgegennehmen und die Tastendrücke senden. das ganze per Websocket, den ich beim Start gerne einstellbar haben möchte, und diese Einstellungen möge er sich bitte zwischen den Programmstarts merken. Nach einer Nettozeit von etwa 45 Minuten war das so weit entwickelt, dass ich es auf meinem Handy installieren konnte und es auf Anhieb lief.

Die Anforderungen an dem Server sind natürlich etwas umfangreicher und ich habe mich auch deutlich mehr beraten lassen bei den einzelnen Punkten. Die Web Socket Verbindung wurde zu einer Secure Verbindung geändert. Zu die Debuggingzwecken habe ich dann noch eingebaut, dass ich das USR1-Signal an den Server senden kann, um ihn zu zwingen sein Layout noch einmal zu senden. Und ich habe mir überlegt, wie ich die Tasten-Layouts konfiguriere. Alles im allem hat das ganze etwa 4 Stunden benötigt.

Dann habe ich eine Nacht darüber geschlafen, wie ich das Tastenlayout wohl konfigurieren kann, bis mir die Idee kam, überhaupt kein Programm dafür zu schreiben, sondern alle Layouts einer Konfigurationsdatei zu hinterlegen. Und wenn ich diese Konfigurationsdatei im Org-mode schreibe, wie er in Emacs eingebaut ist, das ich ja sowieso benutze, dann kann ich das Tastaturlayout einfach als Tabelle direkt in die Konfigurationsdatei schreiben.

In der nächsten coding session habe ich also zusammen mit Matrix Weib das genauer Format dieser config.org Datei zusammengebaut. Zusätzlich habe ich mir den Code erzeugen lassen der benötigt wird um dieses Datei Format zu passen.

Die Datei sah dann etwa so aus:

* Global
:PROPERTIES:
:Port:: 8766    
:Host:: 0.0.0.0
:UseSSL:: True
:CertFile::
:KeyFile::
:GenerateCert:: True
:PingInterval:: 20
:PingTimeout:: 60
:END:

** Buttons

*** Home
:PROPERTIES:
:Label: Home    
:Image:    
:Actions: Layout, Dance,Execute  
:Parameters: Home,, Programname
:Color: #FF0000
:END:


*** Bäh
:PROPERTIES:
:Label:    
:Image:    
:Actions: Activate  
:Parameters: Terminal
:Color:
:END:


* Layouts
** Home                                         :default:

|------+------+---+------+-----+---+---+------|
| Home | Link |   | Helm |     |   |   |      |
|------+------+---+------+-----+---+---+------|
|      |      |   | Bumm |     |   |   |      |
|------+------+---+------+-----+---+---+------|
|      |      |   |      | Bäh |   |   |      |
|------+------+---+------+-----+---+---+------|
|      |      |   |      |     |   |   | Test |
|------+------+---+------+-----+---+---+------|

*** Link
:PROPERTIES:
:Label:    
:Image:    
:Actions:   
:Parameters:
:Color:
:END:

*** Helm
:PROPERTIES:
:Label:    
:Image:    
:Actions: Layout  
:Parameters: Emacs
:Color:
:END:

Man erkennt bereits, wie einfach hier ein Layout erstellt werden kann. Emacs unterstützt einen dabei die Tabelle immer in einem hübschen rechteckigen Format zu halten.

Nach zwei Coding sessions mit in summe circa 8 bis 10 Stunden waren sowohl Server als auch Client einsatzbereit.

Was kommt jetzt

Mal abgesehen davon, dass in den Server noch einige Funktionen eingebaut werden sollen, wie zum Beispiel die D-BUS Fähigkeit, damit ich Kontextwechsel im System erkennen und entsprechend andere Layouts anzeigen lassen kann, ist die Software weitgehend fertig.

Jetzt werde ich mich also hinsetzen und mir sowohl den erzeugten Python-Code als auch den erzeugten Kotlin-Code mal genauer anschauen. Den Python-Code im Wesentlichen auf Qualität, Stil und ähnliche Dinge, den Kotlin-Code um selbst zu lernen, wie solche Programme aufgebaut sind, wie sie funktionieren. Welche Dateien ich benötige und wie die alle zusammen spielen.

Ein unglaublicher Hilfe war der Agent auf jeden Fall bei der Dokumentation der ganzen Projekte. Für mein Git-Repository wurde mir automatisch die README erzeugt. Ich konnte die Commit-Messages erzeugen lassen und hatte alle Änderungen darin stehen ohne eine einzige zu vergessen.

Ich kann nur auf jeden Fall besser verstehen, was am Vibe-coding so verlockend ist. Schnelle Ergebnisse, wenn man in der Lage ist, sein Projekt exakt zu beschreiben. Aus Erfahrung, die ich bisher mit Projektleitern gemacht habe, muss ich allerdings sagen, genau das ist der Grund, warum man dafür ein Programmierer braucht.

Die technischen und sozialen Implikationen der KI sind mir natürlich bewusst und jede Einzelne davon ist geeignet, mich vom professionellen Einsatz abzuhalten. Langfristig glaube ich, wird sich das Problem allerdings wirtschaftlich erledigen. Und ob dann mein Talent als normaler Programmierer wieder gefragt ist, wird sich zeigen.

2026-07-29

Wenn Johnny.Decimal und mein Hirn sich ganz doll lieb haben << >> Eine Org Datei im Einsatz als Config-File