Bei einem gescheiterten Cron-Job oder einem Problem in der RAID-Konfiguration sollte eigentlich sofort eine Mail an den Admin gehen. Wenn auf dem Server ein Mailserver installiert ist, funktioniert das mehr oder weniger auf Anhieb: Sie müssen maximal einen Mail-Alias angeben oder die gewünschte Empfängeradresse in /etc/crontab eintragen.

Aber nicht jeder Server braucht auch einen Mail-Server! Dessen Administration verursacht selbst jede Menge Arbeit. Bei »kleinen« Servern ohne richtigen MTA (Mail Transfer Agent) ist msmtp eine gute Alternative. Das Programm übergibt die zu sendenden Nachrichten einfach an einen externen SMTP-Server.

Ich habe msmtp vor ein paar Tagen auf einem frisch installierten Virtualisierungs-Host (Ubuntu 26.04) eingerichtet. Dieser Beitrag fasst die Konfiguration zusammen.

Funktionsweise

msmtp ist kein Mail-Server. Das Programm nimmt keine Mails von außen entgegen, hat keine Warteschlange und kümmert sich auch nicht um die Zustellung an den Ziel-Server. Es macht nur eines: Es reicht eine Nachricht per SMTP an einen externen Mail-Server weiter, bei dem Sie ein Konto haben, z.B. bei Ihrem Mail-Provider (mailbox, Gmail etc.). Dieser Server erledigt dann den Rest.

Für Cron & Co. ist das ideal: Diese Programme rufen zum Mail-Versand traditionell /usr/sbin/sendmail auf. Das Paket msmtp-mta stellt genau dieses Kommando zur Verfügung (als Link auf msmtp). Damit funktioniert der Mail-Versand für alle Programme, die einen lokalen Mail-Server erwarten.

Der Preis für die Einfachheit: Ist der SMTP-Server gerade nicht erreichbar, scheitert der Versand, und die Mail ist verloren. Es gibt keinen zweiten Versuch eine Stunde später.

Installation

Unter Debian und Ubuntu installieren Sie drei Pakete:

apt install msmtp msmtp-mta bsd-mailx

msmtp ist das eigentliche Programm, msmtp-mta richtet /usr/sbin/sendmail ein, und bsd-mailx stellt das Kommando mail zur Verfügung, mit dem Sie im Terminal oder in Scripts unkompliziert Mails versenden können.

Während der Installation fragt ein Dialog, ob Sie das AppArmor-Profil für msmtp aktivieren möchten. Die Defaulteinstellung lautet Nein, und dabei habe ich es belassen. Wenn Sie AppArmor aktivieren, darf passwordeval (siehe unten) nur einige ausgewählte Hilfsprogramme aufrufen (cat, gpg, pass, secret-tool usw.). Details können Sie in /usr/share/doc/msmtp/README.Debian nachlesen.

Konfiguration

Die systemweite Konfiguration befindet sich in /etc/msmtprc. Meine Datei sieht (mit anonymisierten Adressen) so aus:

# Datei /etc/msmtprc
# Default-Werte für alle weiteren Accounts
defaults
auth            on
tls             on
tls_starttls    on
tls_trust_file  /etc/ssl/certs/ca-certificates.crt
logfile         /var/log/msmtp.log
aliases         /etc/aliases

# erster Account
account         myfirstaccount
host            smtp.example.com
port            587
user            admin@example.com
passwordeval    "cat /etc/msmtp-password"
from            server1@example.com

# optional: weitere Accounts
account         myotheraccount
...

# welcher Account gilt per Default
account default : myfirstaccount

Der Abschnitt defaults enthält Einstellungen, die für alle Konten gelten: Authentifizierung, TLS (hier mit STARTTLS auf Port 587), die Datei mit den CA-Zertifikaten, eine Logging-Datei und die Alias-Datei. Darauf folgt die Definition des eigentlichen Kontos. Sie können mehrere Konten definieren, für einen Server reicht aber eines. account default : ... legt fest, welches Konto msmtp verwendet.

Zu einigen Details:

• user und from: Oft stimmen user (zur Authentifizierung) und from (die Absenderadresse) überein. Auf jeden Fall muss Ihr Provider die Absenderadresse für das angegebene Konto akzeptieren. Einige Provider erlauben Aliasse. Ich verwende für jeden Server eine eigene Alias-Adresse. Auf diese Weise sehe ich im Posteingang sofort, woher eine Nachricht kommt.

• passwordeval: Das Passwort könnten Sie mit password direkt in msmtprc angeben. Ich habe es stattdessen in die Datei /etc/msmtp-password ausgelagert. passwordeval führt das angegebene Kommando aus und verwendet dessen Ausgabe als Passwort.

• aliases: msmtp wertet /etc/aliases aus. Damit landen Mails an lokale Empfänger wie root bei einer »richtigen« Adresse (siehe unten).

Manche Provider bieten anstelle von (oder zusätzlich zu) STARTTLS auf Port 587 eine von Anfang an verschlüsselte Verbindung auf Port 465 an (SMTPS). Wichtig ist tls_starttls off, weil msmtp per Default STARTTLS verwendet:

# Datei /etc/msmtprc (Variante mit Port 465, nur die geänderten Zeilen)
defaults
tls_starttls    off
...
account         myfirstaccount
port            465
...

Welche Variante Sie wählen, ist letztlich egal, solange Ihr Provider sie unterstützt. Wenn Sie tls_starttls und port nicht zusammenpassend einstellen, hängt msmtp beim Verbindungsaufbau bzw. scheitert mit einer TLS-Fehlermeldung.

Die Passwortdatei darf nur root lesen:

touch /etc/msmtp-password
chmod 600 /etc/msmtp-password
nano /etc/msmtp-password      # Passwort eintragen

Hinweis: Wenn Ihr Provider es anbietet, verwenden Sie anstelle des Passworts für Ihr Mail-Konto ein eigenes App-Passwort. Bei Gmail ist das zwingend erforderlich. Ein Server, der Status-Mails versendet, braucht keinen Zugriff auf Ihr gesamtes Konto.

Logging

Die Logging-Datei richtet msmtp beim ersten Versand selbst ein. Für jede Mail kommt eine Zeile hinzu:

Nov 05 14:07:01 host=smtp.example.com tls=on auth=on user=admin@example.com from=server1@example.com recipients=server1@example.com mailsize=452 smtpstatus=250 smtpmsg='250 2.0.0 Ok: queued as ...' exitcode=EX_OK

Die Datei wächst nur langsam. Eine Logrotate-Konfiguration richtet das Paket nicht ein. Wer Ordnung haben will, legt /etc/logrotate.d/msmtp selbst an:

# Datei /etc/logrotate.d/msmtp
/var/log/msmtp.log {
    monthly
    rotate 12
    compress
    missingok
    notifempty
}

Eine Alternative zur eigenen msmtp-Logging-Datei ist das Journal: Ersetzen Sie in msmtprc die Zeile logfile ... durch syslog on (oder syslog LOG_MAIL, wenn die Einträge in die Mail-Kategorie gehören sollen). msmtp protokolliert dann jeden Versand mit dem Kennzeichen msmtp. Zum Lesen verwenden Sie journalctl -t msmtp (t wie tag). journalctl -u msmtp funktioniert dagegen nicht, weil msmtp kein systemd-Dienst ist, sondern bei jedem Versand neu gestartet wird.

journalctl -t msmtp -n 20     # die letzten 20 Einträge
journalctl -t msmtp -f        # laufend verfolgen

Aliasse am Server und Cron

Viele Systemprogramme senden ihre Mails an root. Damit diese Mails nicht im Nirwana verschwinden, braucht es einen Eintrag in /etc/aliases:

# Datei /etc/aliases
root: server1@example.com

Anders als bei Postfix oder Exim ist hier kein newaliases erforderlich: msmtp liest die Datei bei jedem Aufruf. Wenn Sie alle lokalen Empfänger (also nicht nur root) umleiten möchten, hilft eine zusätzliche Zeile default: server1@example.com.

Für Cron-Jobs in /etc/crontab habe ich außerdem MAILTO eingestellt:

# Datei /etc/crontab
SHELL=/bin/sh
MAILTO=server1@example.com
...

Mit der obigen Alias-Datei ist MAILTO nicht notwendig. MAILTO erlaubt aber bei Bedarf eine von /etc/aliases abweichende Einstellung. Bei mir ist der Absender aller Server-Mails gleichzeitig auch der Empfänger. Damit landet alles, was der Server zu berichten hat, in einem Postfach.

Ausprobieren

Für einen ersten Test senden Sie eine Mail an eine externe Adresse und an root. Führen Sie die Kommandos als root aus (z.B. nach sudo -s), weil nur root die Passwortdatei lesen darf (siehe auch den letzten Abschnitt).

echo "Test 1" | mail -s "msmtp-Test" ich@example.com
echo "Test 2" | mail -s "msmtp-Test an root" root

Wenn etwas nicht klappt, hilft msmtp -v bzw. sendmail -v beim Debugging. tail /var/log/msmtp.log zeigt, was zuletzt passiert ist.

echo "Test 3" | sendmail -v ich@example.com

Um die Mails von Cron zu testen, habe ich vorübergehend einen Cron-Job eingerichtet, der jede Minute läuft und eine Ausgabe liefert (und den ich danach natürlich wieder gelöscht habe):

# Datei /etc/cron.d/mailtest
* * * * * root echo "Hallo von Cron"

Kommt die Cron-Mail nicht an, lohnt sich ein Blick ins Journal. msmtp selbst schreibt in der obigen Konfiguration nur in seine eigene Logging-Datei, Cron protokolliert aber jeden Job und meldet auch, wenn die Übergabe an sendmail scheitert:

journalctl -u cron --since "10 min ago"

  ... CRON[4711]: (root) CMD (echo "Hallo von Cron")
  ... CRON[4710]: (root) MAIL (mailed 15 bytes of output but got status 0x004e from MTA)

Die Statuszahl ist der Exit-Code von msmtp in hexadezimaler Schreibweise (siehe /usr/include/sysexits.h). 0x4e = 78 steht für EX_CONFIG, also für einen Fehler in der Konfiguration, 0x4b = 75 (EX_TEMPFAIL) für einen nicht erreichbaren Server. Die Meldung No MTA installed, discarding output bedeutet, dass /usr/sbin/sendmail fehlt, also msmtp-mta nicht installiert ist.

RAID, SMART und Updates

Mit dem funktionierenden sendmail-Ersatz können nun auch andere Dienste Mails versenden. Auf meinem Server waren mir drei Dinge wichtig: Warnungen über defekte RAID-Arrays, drohende Probleme mit den SSDs und Berichte über automatische Updates. Alle drei Dienste senden ihre Mails an root; dank /etc/aliases landen sie in meinem Postfach.

mdadm: Unter Ubuntu enthält /etc/mdadm/mdadm.conf bereits die Zeile MAILADDR root, und der Dienst mdmonitor läuft automatisch, sobald es ein Software-RAID gibt. Ich musste also nichts ändern. Mit dem folgenden Kommando erhalten Sie für jedes RAID-Array eine Testmail:

mdadm --monitor --scan --oneshot --test

smartd: Das Paket smartmontools ist unter Ubuntu Server nicht standardmäßig installiert. Nach apt install smartmontools überwacht smartd alle Datenträger. Die mitgelieferte Konfigurationsdatei /etc/smartd.conf sieht bereits Mails an root vor (Option -m root):

# Datei /etc/smartd.conf
DEVICESCAN -d removable -n standby -m root -M exec /usr/share/smartmontools/smartd-runner

Um eine Testmail auszulösen, habe ich eine temporäre Konfigurationsdatei mit der Option -M test verwendet und smartd einmalig damit ausgeführt:

echo "/dev/nvme0n1 -m root -M test" > /tmp/smartd-test.conf
smartd -q onecheck -c /tmp/smartd-test.conf
rm /tmp/smartd-test.conf

Regelmäßige Selbsttests der Datenträger führt smartd in dieser Konfiguration übrigens nicht durch. Dazu müssten Sie in smartd.conf die Option -s ergänzen (siehe man smartd.conf).

unattended-upgrades: Automatische Updates sind unter Ubuntu standardmäßig aktiv, aber ohne Mail-Benachrichtigung. Anstatt /etc/apt/apt.conf.d/50unattended-upgrades zu ändern, habe ich eine eigene kleine Datei eingerichtet:

# Datei /etc/apt/apt.conf.d/52unattended-upgrades-mail
Unattended-Upgrade::Mail "root";
Unattended-Upgrade::MailReport "on-change";

on-change bedeutet, dass nur dann eine Mail kommt, wenn tatsächlich Pakete aktualisiert wurden oder etwas schiefgegangen ist. Alternativen sind always (jeden Tag eine Mail) und only-on-error. Zum Testen habe ich vorübergehend always eingestellt und unattended-upgrade -v ausgeführt. Obwohl es nichts zu aktualisieren gab, kam ein Bericht per Mail. Danach habe ich die Einstellung wieder auf on-change zurückgesetzt.

Mail-Versand für gewöhnliche Benutzer

In der obigen Konfiguration kann nur root Mails versenden, weil nur root die Passwortdatei lesen darf. Ruft ein anderer Benutzer mail oder sendmail auf, scheitert msmtp beim Auslesen des Passworts. Für einen Server, auf dem ohnehin nur Systemdienste und Cron-Jobs von root Mails versenden, ist das genau richtig.

Soll doch einmal ein gewöhnlicher Benutzer Mails versenden, ist die einfachste Lösung eine eigene Konfigurationsdatei .msmtprc in seinem Home-Verzeichnis. Am schnellsten kopiert der Benutzer /etc/msmtprc (die Datei ist für alle lesbar) und ändert dann zwei Zeilen: Die Logging-Datei und die Passwortdatei müssen in seinem Home-Verzeichnis liegen.

cp /etc/msmtprc ~/.msmtprc

# Datei ~/.msmtprc (geänderte Zeilen)
logfile         ~/.msmtp.log
passwordeval    "cat ~/.msmtp-password"

Die Passwortdatei darf nur für den Benutzer selbst lesbar sein (chmod 600 ~/.msmtp-password). Wenn Sie das Passwort stattdessen mit password direkt in .msmtprc eintragen, gilt das für diese Datei; bei zu großzügigen Rechten verweigert msmtp den Dienst. Damit Cron-Mails dieses Benutzers nicht an seinen lokalen Account gehen, stellen Sie in seiner Crontab (crontab -e) außerdem MAILTO=... ein.

Fazit

msmtp ist in wenigen Minuten eingerichtet. Für Server, die keinen eigenen Mail-Server brauchen, ist das viel angenehmer als eine ganze Postfix-Installation, deren einziger Zweck darin besteht, wenige Status-Mails zu versenden.

Wenn Sie die fehlende Warteschlange stört, sind nullmailer oder dma (DragonFly Mail Agent) denkbare Alternativen: Beide Programme sind ähnlich minimalistisch, speichern Mails aber zwischen, wenn der SMTP-Server gerade nicht erreichbar ist.

Quellen/Links

• https://marlam.de/msmtp/
• https://marlam.de/msmtp/msmtp.html (Handbuch)
• https://wiki.archlinux.org/title/Msmtp
• https://wiki.debian.org/msmtp

Manchmal braucht es eine reißerische Überschrift, um das eigene Versagen zu übertünchen. Was war passiert? Wie in Ubuntu-Server-Update von 24.04 auf 26.04 beschrieben, habe ich vor ein paar Tagen einen Ubuntu-Server auf Version 26.04 aktualisiert. Dort lief (und läuft weiterhin) unter anderem Nextcloud.

Was ich bei meinem Upgrade übersehen hatte: Ich hatte meine Nextcloud-Installation in den vergangenen 18 Monaten sträflich vernachlässigt. Alles funktionierte, an Updates hatte ich nicht gedacht. Genau das ist mir mit dem Ubuntu-Upgrade auf die Füße gefallen. Meine Nextcloud-Clients konnten keine Verbindung mehr herstellen. Die Webseite zeigte kurz und bündig:

This version of Nextcloud is not compatible with PHP>=8.5. 
You are currently running 8.5.4

Ein kurzer Test ergab, dass Nextcloud 31 installiert war. Die erste Version, die PHP 8.5 unterstützt, ist aber Nextcloud 33. Aktuell wäre gar Nextcloud 35 …

Das klingt nach einem trivialen Problem, aber das täuscht: Für den Upgrade-Prozess ist ein PHP-Script zuständig, und dieses verweigert mit meiner neuen PHP-Version die Ausführung. Außerdem muss Nextcloud immer Version für Version aktualisiert werden. Eine direkte Abkürzung von Version 31 zu 35 ist nicht zulässig.

In der Vergangenheit hatte ich schon mehrfach das Problem, dass ich Nextcloud nicht aktualisieren konnte, weil PHP zu alt war. Auf die Idee, dass es auch den umgekehrten Fall geben könnte (PHP zu neu), bin ich nicht gekommen.

Docker ist die Lösung

Ich brauchte also auf meinem frisch aktualisierten Server eine alte PHP-Version. Dafür gibt es (inoffizielle) Repositories, aber die wollte ich nicht verwenden. PHP 8.3 oder 8.4 sollte ja nur für ein paar Minuten ein Script ausführen. Zu Hilfe kam mir einerseits Docker, das auf dem Server sowieso installiert ist, und andererseits Claude Code, von dem ich mir mit dem folgenden Prompt eine detaillierte Anleitung erstellen ließ.

/var/www/html/nextcloud contains Nextcloud 31.0.4. My problem: I upgraded to PHP 8.5, but Nextcloud 31 is incompatible with this PHP version. I need to upgrade to Nextcloud version 33 (first PHP 8.5 compatible version), keeping all data. Docker is available to run an older PHP version. Line out an upgrade plan.

Die Grundidee besteht darin, mit einem Dockerfile ein Image mit PHP 8.3 zur Ausführung des Upgrades zu erstellen:

# Dockerfile
FROM php:8.3-cli
ADD https://github.com/mlocati/docker-php-extension-installer/releases/latest/download/install-php-extensions /usr/local/bin/
RUN chmod +x /usr/local/bin/install-php-extensions \
 && install-php-extensions pdo_mysql gd intl zip bcmath gmp apcu exif opcache pcntl sysvsem imagick
RUN printf "memory_limit=2G\napc.enable_cli=1\n" > /usr/local/etc/php/conf.d/nc.ini

Das Image wird im Verzeichnis mit dem Dockerfile mit dem folgenden Kommando erzeugt:

sudo docker build -t nc-php83 .

Auf der Basis dieses Images kann das Nextcloud-Kommando occ mit dem folgenden Script nc-occ ausgeführt werden:

#!/bin/sh
exec sudo docker run --rm -it --network host \
  --user "$(id -u www-data):$(id -g www-data)" \
  -v /var/www/html/nextcloud:/var/www/html/nextcloud \
  -v /var/run/mysqld:/var/run/mysqld \
  -w /var/www/html/nextcloud nc-php83 \
  php -d pdo_mysql.default_socket=/var/run/mysqld/mysqld.sock occ "$@"

Das Script bindet in den temporären Container das Nextcloud-Verzeichnis unter demselben Pfad wie auf dem Host ein, damit die absoluten Pfade in der config.php weiter stimmen. Es läuft mit der UID von www-data, damit die Dateirechte passen, und nutzt --network host, damit die lokale Datenbank erreichbar ist. Code, Konfiguration und Daten bleiben also auf dem Host, und im Container läuft nur php occ.

Die größte Hürde war die Datenbankverbindung. Der erste Test mit nc-occ status scheiterte mit SQLSTATE[HY000] [2002] No such file or directory. Die Ursache: Das Debian-PHP sucht den MySQL-Socket standardmäßig unter /var/run/mysqld/mysqld.sock, das offizielle Docker-Image tut das nicht. Es reicht deshalb nicht, den Socket-Ordner per -v /var/run/mysqld:/var/run/mysqld einzubinden, man muss PHP den Pfad auch mit -d pdo_mysql.default_socket=/var/run/mysqld/mysqld.sock mitteilen.

Der weitere Ablauf ist in der schon erwähnten Anleitung detailliert ausgeführt. Selbstredend habe ich vorher ein Backup meiner Daten gemacht (also das Verzeichnis /var/www/html/nextcloud/data sowie die MySQL-Datenbank).

Danach habe ich diese Anleitung Schritt für Schritt abgearbeitet. Theoretisch wäre es auch denkbar, diese Aufgabe agentisch an Claude Code zu delegieren; dazu hätte ich Claude Code aber root-Rechte geben müssen. So mutig war ich dann doch nicht.

Später habe ich Nextcloud in der Web-UI weiter auf die Versionen 34 und 35 aktualisiert. Zum Schluss habe ich aufgeräumt, also insbesondere /var/www/html/nextcloud/data/updater-xxx/* sowie das Docker-Imgage für PHP 8.3 gelöscht.

Vor ein paar Wochen habe ich hier beschrieben, wie ich das Sprachmodell Qwen 3.8 Flash Next auf einem Rechner mit Strix-Halo-CPU und 128 GB RAM ausführe. Dort habe ich auch angekündigt, den Coding-Agenten Pi vorzustellen, mit dem ich das lokale Modell getestet habe: Pi ist so ziemlich das Gegenteil von Claude Code — minimalistisch, sparsam mit dem Kontext und gerade deswegen ideal für lokal ausgeführte Sprachmodelle.

Das Problem: Claude Code und lokale Modelle

Claude Code ist für mich aktuell das beste CLI-Coding-Tool. Das gilt aber nicht für das Zusammenspiel mit lokalen Modellen. Zwar lässt sich Claude Code über die Umgebungsvariable ANTHROPIC_BASE_URL mit LM Studio, llama.cpp & Co. verbinden, aber die Ergebnisse sind ernüchternd: Schon für einen Miniprompt wie »Can we talk?« vergehen je nach Modell Minuten, bis die erste Antwort erscheint.

Eine Ursache dafür ist das sogenannte Context Bloating. Claude Code schickt bei jedem Prompt einen riesigen Basiskontext mit. Wenn Sie in einer leeren Session nach »Can we talk?« das Kommando /context ausführen, zeigt Claude Code eine Kontextnutzung von 50k bis 60k Token an:

• Der Systemprompt beansprucht ca. 10k Token. Das ist eine Grundanleitung, wie Claude Code agieren soll.
• Ungefähr weitere 30k Token ergeben sich aus der Anleitung, wie der Agent Tools wie Bash, Edit, Read oder Write aufrufen soll.
• Der Rest stammt von Skills, Plugins, MCP-Servern usw.

Bei den Anthropic-Modellen mit einem Kontextfenster von einer Million Token ist das (fast) vernachlässigbar. Ein lokales Modell mit einem Kontextfenster von 260.000 Token ist aber schon zu 20 bis 25 Prozent gefüllt, bevor Sie überhaupt etwas Sinnvolles gefragt haben. Und all diese Token müssen von Ihrer lokalen Hardware verarbeitet werden, die nun mal nicht mit Cloud-Rechenzentren mithalten kann. Manche Kritiker sprechen bei Claude Code deswegen nicht nur von Context, sondern auch von Feature Bloating.

Die Idee hinter Pi

Hinter Pi steckt Mario Zechner: Der Österreicher hat unter anderem das Game-Framework libGDX entwickelt. Als ihm Claude Code zu komplex und zu geschwätzig wurde, hat er kurzerhand einen eigenen Agenten geschrieben. Der Code steht unter der MIT-Lizenz und wird mittlerweile von der Organisation Earendil weiterentwickelt. Seit 1.10.2026 gibt es die Version 1.0, aktuell (Anfang November 2026) ist schon Version 1.5.

Die Grundidee lässt sich schnell zusammenfassen: Moderne Sprachmodelle wissen ohnehin schon, wie man eine Shell bedient, wie ein Git-Repository funktioniert und wie man eine Datei bearbeitet. Vieles von dem, was ein Systemprompt, AGENTS.md, Skills usw. hinzufügen, kostet zuerst einmal Token und lenkt ab. (Das sagen übrigens nicht nur die Pi-Entwickler, das sagt interessanterweise — wenn auch in einem etwas anderen Zusammenhang — sogar Anthropic!)

Pi aktiviert deswegen standardmäßig nur vier Tools: read, write, edit und bash. Es gibt kein eigenes Tool für die Volltextsuche, keines für Webzugriffe. Wer suchen will, ruft über bash einfach grep oder rg auf. Der komplette Systemprompt inklusive aller Tool-Definitionen beträgt nur gut 1.000 Token. Das ist ein Fünfzigstel von dem, was Claude Code mindestens braucht! Bei einem lokalen Modell mit 130.000 oder 260.000 Token ist das der Unterschied zwischen »unbrauchbar langsam« und »funktioniert«.

Der Preis für diese Sparsamkeit sind weniger Funktionen, weniger Komfort im Terminal und weniger Tools. Pi ist aber erweiterbar (dazu gleich mehr). Erfreulich für Umsteiger: Pi liest beim Start AGENTS.md und ersatzweise CLAUDE.md, und zwar global, aus allen übergeordneten Verzeichnissen sowie aus dem aktuellen Verzeichnis.

Installation

Pi setzt Node.js (Version 22.19 oder neuer) voraus. Zur Installation verwenden Sie am einfachsten das Installations-Script oder npm (hier zur Referenz die Originalanleitung).

$ curl -fsSL https://pi.dev/install.sh | sh                  # Linux, macOS
> powershell -c "irm https://pi.dev/install.ps1 | iex"       # Windows
$ npm i -g --ignore-scripts @earendil-works/pi-coding-agent  # Node.js

Das Installations-Script hat den Vorteil, dass es alle Abhängigkeiten auf exakte Versionen fixiert; Updates führen Sie dann mit pi update durch. Weitere Installationsvarianten beschreibt https://pi.dev.

Anschließend starten Sie den Agenten im Projektverzeichnis mit pi und melden sich mit /login bei einem der über 40 unterstützten Anbieter an. Neben Anthropic, OpenAI und Google funktionieren auch OpenRouter, DeepSeek oder Groq. Bei OpenAI können Sie sogar ein ChatGPT-Abo verwenden.

Lokale Modelle anbinden

Für mich viel interessanter ist aber die Anbindung eines lokalen Modells. Dazu tragen Sie den Server in ~/.pi/agent/models.json ein. Das folgende Beispiel geht davon aus, dass LM Studio auf dem lokalen Rechner läuft und dort das Modell Qwen 3.8 Flash Next geladen ist:

{
  "providers": {
    "lmstudio": {
      "baseUrl": "http://localhost:1234/v1",
      "api":     "openai-completions",
      "apiKey":  "lmstudio",
      "models": [
        { "id": "qwen3.8-flash-next",
          "contextWindow": 262144 }
      ]
    }
  }
}

Pi spricht mit LM Studio über die OpenAI-kompatible Schnittstelle. Die meisten Inferenz-Engines unterstützen diese API, d.h., die gleiche Konfiguration funktioniert sinngemäß auch für Ollama, vLLM oder die auf Strix Halo optimierten Engines, die ich in meinem Artikel zu Qwen 3.8 Flash Next vorgestellt habe. Sie müssen nur baseUrl und die Modell-ID anpassen. Die Angabe von contextWindow ist optional; ohne sie nimmt Pi 128.000 Token an. Welche Modelle gerade zur Auswahl stehen, zeigt /model.

Mittlerweile hat Pi außerdem einen eingebauten Provider für den Router-Modus von llama.cpp. Dabei verwaltet llama serve mehrere GGUF-Modelle und lädt diese bei Bedarf. In Pi richten Sie die Verbindung mit /login llama.cpp ein, laden mit /llama ein Modell und wählen es dann mit /model aus.

Hinweis: Achten Sie darauf, dass Sie in Ihrer Inferenz-Engine ein ausreichend großes Kontextfenster einstellen. Viele Engines verwenden per Default einen winzigen Kontext von 4.096 oder 32.768 Token. Für agentisches Coding ist das viel zu wenig, auch mit Pi. Ich verwende auf meinem 128-GB-Rechner das Maximum, das viele lokale Modelle aktuell unterstützen, also 256k Token (262144).

Erweiterungsmechanismen

Ein Agent mit so wenigen Tools klingt trostlos. Pi kompensiert den anfänglichen Minimalismus mit vier Erweiterungsmechanismen:

• Skills: Im Kontext steht dauerhaft nur die Beschreibung eines Skills. Die eigentliche Anleitung wird erst geladen, wenn der Skill tatsächlich gebraucht wird.
• Extensions: Das sind TypeScript-Module, die eigene Tools, Slash-Kommandos oder Hooks (ebenfalls auf TypeScript-Basis) zur Verfügung stellen.
• Prompt Templates: wiederverwendbare Prompt-Bausteine, vergleichbar mit den Slash-Kommandos von Claude Code.
• Themes und Keybindings: Farbschemata und Tastenkürzel.

Skills liest Pi aus den folgenden Verzeichnissen:

~/.pi/agent/skills
~/.agents/skills
projektverzeichnis/.pi/skills
projektverzeichnis/.agents/skills

Alle vier Mechanismen lassen sich zu einem Pi Package zusammenfassen und über npm oder Git weitergeben. Installiert werden Pakete mit pi install npm:paketname.

MCP: Kehrtwende mit Kontext-Spartrick

Lange Zeit war die Meinung der Pi-Entwickler zu MCP klar: »No MCP. Build CLI tools with READMEs.« Wer partout MCP wollte, musste das Paket pi-mcp-adapter installieren.

Mit Version 0.99 (Ende September 2026) hat sich das geändert: Pi unterstützt MCP-Server jetzt direkt, sowohl lokal (stdio) als auch remote (Streamable HTTP, inklusive OAuth-Login). Die Konfiguration erfolgt in ~/.pi/agent/mcp.json bzw. projektspezifisch in .pi/mcp.json. Das Format entspricht dem von Claude Code, d.h., Sie können vorhandene mcpServers-Einträge einfach kopieren. Alternativ richten Sie Server mit pi mcp add ein:

$ pi mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem .
$ pi mcp add docs --url https://example.com/mcp --bearer-token-env-var DOCS_TOKEN
$ pi mcp list

Innerhalb von Pi zeigt /mcp den Zustand aller Server an. Dort können Sie Server auch aktivieren oder deaktivieren und sich bei OAuth-Servern anmelden.

Interessant ist, wie Pi das Kontextproblem löst, das MCP-Server üblicherweise verursachen. Per Default landen die Tool-Definitionen der MCP-Server nämlich gar nicht im Kontext. Stattdessen aktiviert Pi ein zusätzliches Tool namens Codemode. Damit schreibt das Sprachmodell kleine JavaScript-Programme, die in einer Sandbox ausgeführt werden. Dort kann das Modell mit searchTools() nach passenden MCP-Tools suchen, diese aufrufen, die Ergebnisse filtern und nur die wirklich relevanten Ergebnisse zurückgeben. Im Systemprompt steht pro MCP-Server nur eine Zeile mit einer Kurzbeschreibung. Alternativ können Sie in mcp.json für jeden Server bzw. für einzelne Tools einstellen, ob diese direkt deklariert werden (direct), erst nach einer Suche mit tool_search (deferred) oder gar nicht (hidden).

Ob dieses Konzept auch mit lokalen Modellen gut funktioniert, hängt vom Modell ab: Ein Modell, das zuverlässig JavaScript schreibt und Tools sucht, profitiert davon. Für kleinere Modelle ist es vermutlich besser, wenige wichtige Tools mit direct freizugeben.

Keine Websuche

Zu den Lücken in Pi zählt nach wie vor die Websuche. Pi greift auf das bash-Tool mit curl zurück, um einzelne Webseiten mit bekannter URL zu lesen, aber das ist kein echter Ersatz. Hier liegt kein technisches Problem vor, sondern ein wirtschaftliches: Die meisten Suchmaschinen leben von der Werbung. Sie erkennen agentische Websuchen und blockieren diese rasch. Die fehlende Websuche ist kein Pi-spezifisches Problem, sondern betrifft auch andere Open-Source-Agenten außerhalb des reinen Coding-Umfelds, z.B. Hermes und OpenClaw.

Glücklicherweise gibt es Packages, die eine Suchfunktion für Pi nachliefern. Die meisten davon benötigen aber einen Key oder ein Abo. Beispielsweise nutzt npm:@burneikis/pi-web-search die Websuche von Anthropic; dass setzt aber einen Claude-API-Key voraus. Ich habe stattdessen pi-anysearch-tools ausprobiert. Die Installation ist unkompliziert:

$ pi install npm:pi-anysearch-tools

Das Paket erfordert allerdings eine Registrierung und einen Key bei https://anysearch.com. AnySearch hat (Stand: November 2026) einen großzügigen Free Plan, der immerhin 1.000 Suchanfragen pro Tag erlaubt. Für mehr Suchen oder eine bessere Suchqualität müssen Sie ein Abo abschließen. Den Key tragen Sie in ~/.pi/agent/anysearch.json ein:

{
  "anysearchApiKey": "as_sk_xxx"
}

Bei meinen Tests hat das Zusammenspiel zwischen Pi und AnySearch ausgezeichnet funktioniert. Seit Pi MCP unterstützt, können Sie natürlich auch einen MCP-Server für die Websuche einbinden.

Keine Permissions

Pi hat kein Permission-System. Das Modell ruft bash auf. Damit läuft jedes Kommando mit Ihren Rechten; im Worst Case gilt das auch für rm -rf! Im Unterschied zu Claude Code gibt es weder einen Auto-Modus noch einen Classifier, der Kommandos vor der Ausführung begutachtet. Wer die Grenzen der Permission-Systeme kommerzieller Coding-Agenten kennt, mag das konsequent finden. Tatsächlich habe ich mit Pi durchwegs gute Erfahrungen gemacht. Dennoch gilt: Pi ist nur so gut wie die Modelle, die es nutzt.

Immerhin gibt es einen sogenannten Project Trust: Wenn ein Projektverzeichnis eigene Einstellungen, Extensions, Skills oder MCP-Server mitbringt (also z.B. .pi/settings.json oder .pi/mcp.json), fragt Pi beim Start, ob Sie diesem Projekt vertrauen. Das verhindert, dass ein fremdes Repository unbemerkt Code in den Pi-Prozess lädt. Auf die Aktionen des Sprachmodells hat das aber keinen Einfluss.

Die Dokumentation empfiehlt stattdessen, Pi in einen Container oder eine virtuelle Maschine zu stecken, und beschreibt dafür mehrere Varianten. Das ist nicht so komfortabel wie die Sandboxing-Systeme kommerzieller Coding-Agenten, aber sicherheitstechnisch ein vernünftiger Ansatz.

Was sonst noch fehlt

Ebenfalls nicht eingebaut sind Subagenten, ein Planungsmodus, Hintergrund-Tasks oder eine Worktree-Unterstützung. Die Entwickler argumentieren, dass solche Features besser als Extension aufgehoben sind. Tatsächlich gibt es fertige Pakete, die genau das nachrüsten. Wer alles auf einmal will, greift zu omp: Das ist ein Fork von Pi, der LSP-Integration, Debugger-Anbindung, Subagenten und Planungsmodus mitbringt. Leider ist man damit wieder bei der Komplexität, vor der Pi ursprünglich geflüchtet ist.

Sessions, Slash-Kommandos und Optionen

Pi speichert jede Session als JSONL-Datei in ~/.pi/agent/sessions, sortiert nach Arbeitsverzeichnis. Mit /resume kehren Sie zu einer früheren Session zurück, mit /fork zweigen Sie von einer beliebigen Nachricht eine neue ab. /compact fasst den bisherigen Verlauf zusammen.

Neuartig aus Claude-Code-Perspektive ist /tree: Das Kommando stellt die Session als Baum dar, in dem Sie navigieren und zwischen Zweigen wechseln können. Wenn Sie einen Prompt zurücknehmen und anders formulieren, geht der alte Ast nicht verloren; Sie können jederzeit dorthin zurückspringen und beide Varianten vergleichen. Das ist deutlich mächtiger als eine lineare Rewind-Funktion.

Für die Automatisierung gibt es Betriebsarten ohne Benutzeroberfläche: pi -p "prompt" liefert die Antwort und endet dann. --mode json gibt einen Event-Stream aus, --mode rpc erlaubt die Steuerung über stdin und stdout. Mit --export machen Sie aus einer Session eine HTML-Datei. Mit --tools bzw. -t bestimmen Sie, welche Tools aktiv sind. Beispielsweise aktiviert pi -t +codemode,-write zusätzlich codemode und deaktiviert write.

Praktische Erfahrungen

Ich habe Pi mit dem lokalen Modell Qwen 3.8 Flash Next getestet (siehe auch meinen Blog-Artikel zu Qwen 3.8 Flash Next). Als ersten Test habe ich Pi gebeten, ein Spiel in der Art von Space Invaders zu programmieren. Die erste, fehlerfrei spielbare Version war nach vier Minuten fertig. Auch meine Verbesserungswünsche samt einem größeren Refactoring wurden anstandslos und zügig ausgeführt.

Ein einfaches Browser-Spiel ist ein netter Test, aber wie sieht es mit realem Code aus? Pi und Qwen 3.8 Flash Next schlagen sich wacker. Heute habe ich in einer größeren PHP-Datei (ca. 2000 Zeilen / 60 kByte Code) eine Sicherheitsanalyse durchgeführt. Pi musste natürlich auch diverse verknüpfte Code-Dateien lesen. Das Ergebnis war inhaltlich exzellent und formal gut aufbereitet, aber Claude Code (oder Pi im Zusammenspiel mit kommerziellen Cloud-Modellen) wäre viel schneller fertig gewesen. Wenn Sie diesbezüglich einmal verwöhnt sind, fällt diese Gemächlichkeit schwer, zumal gleichzeitig der Lüfter hochdreht, um die CPU zu kühlen. Lokale Modelle verdeutlichen den mit der KI verbundenen Ressourcenaufwand viel spürbarer als Cloud-Modelle!

Ich verwende KI-Agenten nicht nur für das Coding, sondern auch für eine erste Korrektur meiner in Markdown-Syntax verfassten Texte (Rechtschreibfehler, Grammatik, inhaltliche Fehler, Redundanzen etc.). Die Geschwindigkeit spielt dabei eine untergeordnete Rolle; bei längeren Texten kann ich Korrekturläufe auch über Nacht ausführen. Mit dem Coding-Agent Pi hat dieser Test zugegebenermaßen wenig zu tun, vielmehr betreffen die Ergebnisse das von mir genutzte Sprachmodell.

Das Korrekturlesen für diesen Text samt einer inhaltlichen Kontrolle hat mehr als eine Viertelstunde gedauert. Qwen-3.8-flash-next ist dabei übertrieben pingelig vorgegangen. In Pi können Sie dem Sprachmodell beim »Denken« zusehen. Qwen hat immer wieder dieselben Dinge überprüft und viele — aus meiner Sicht — komplett sinnlose Doppel- und Dreifachkontrollen durchgeführt. (Hinterlassen Sie einen Kommentar, wenn Sie doch noch einen Fehler finden!) Mein Prompt war: »proofread @pi-agent.md: fix obvious typos or grammar errors; list everything else; also check content on factual errors«

Um es zusammenzufassen: Pi mit Qwen 3.8 Flash Next funktioniert ausgezeichnet, aber kommerzielle Coding-Agenten bzw. Pi in Kombination mit kommerziellen Modellen arbeiten eben noch besser.

Fazit

Für mich kann Pi plus ein lokales Modell Claude Code noch nicht vollständig ersetzen. Das habe ich zu Beginn meiner Tests auch nicht erwartet. Für große Software-Projekte bieten kommerzielle CLIs von Anthropic, OpenAI oder Mistral mehr Qualität, Geschwindigkeit und Arbeitskomfort.

Aber Pi zeigt, wie wenig ein Coding-Agent braucht. Pi glänzt da, wo kommerzielle Agenten schwächeln: im Zusammenspiel mit lokalen Modellen mit begrenztem Kontext und begrenzter Rechenleistung. Wenn Sie aus Gründen des Datenschutzes oder der Unabhängigkeit mit einem lokalen Modell arbeiten möchten, ist Pi die erste Wahl.

Von der geringeren Geschwindigkeit und Qualität lokaler Modelle einmal abgesehen, empfand ich die fehlende Websuche als das größte Hindernis für produktives Arbeiten: Für mich ist ein Coding-Agent auch ein Hilfsmittel zur Recherche. Bei Bugs im Zusammenspiel mit modernen Bibliotheken oder bei Setup-Problemen mit neuen Tools erwarte ich, dass der Agent aktuelle Infos aus dem Internet beschaffen kann. Bei Open-Source-Coding-Agenten wie Pi ist dazu die Anbindung an einen externen Suchdienst notwendig, die zumindest bei intensiver Nutzung zusätzliche Kosten verursacht.

Quellen/Links

• https://pi.dev
• https://github.com/earendil-works/pi
• https://claude.dev/blog/the-new-rules-of-context-engineering-for-claude-5-generation-models
• https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/mcp.md (MCP-Unterstützung)
• https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/codemode.md (Codemode)
• https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/llama-cpp.md (lokale Modelle mit llama.cpp)
• https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/security.md (Sicherheit, Project Trust)
• https://www.jsdelivr.com/package/npm/pi-anysearch-tools
• https://www.anysearch.com/pricing
• https://omp.sh
• https://kofler.info/qwen-38-flash-next-strix-halo

Auf meinen Rechnern verschlüssele ich Dateien mit Passwörtern oder anderen vertraulichen Daten, vor allem dann, wenn ich sie zwischen mehreren Rechnern teilen möchte oder wenn diese in Backups auf externen Datenträgern landen. Den einfachsten Weg dazu bietet das Kommando gpg -c file.txt. Es fragt (zur Sicherheit gleich zweimal) nach einem Passwort, verschlüsselt die Datei file.txt symmetrisch und macht daraus file.txt.gpg. gpg -d file.txt.gpg entschlüsselt die Datei wieder. (Symmetrisch bedeutet, dass Sie kein Schlüsselpaar brauchen. gpg verwendet zum Ver- und Entschlüsseln dasselbe Passwort, das oft passphrase genannt wird. Verwenden Sie eine ausreichend lange Zeichenkette, die Sie sich gut merken können!)

Kürzlich habe ich entdeckt, dass mein Lieblingseditor Emacs solche Dateien fast transparent beim Laden ent- und beim Speichern wieder verschlüsseln kann. Das Feature ist keineswegs neu, ich bin einfach noch nie darüber gestolpert. Es gibt keine temporäre Klartextdateien, die versehentlich liegen bleibt.

Emacs bringt mit EasyPG (epa-file) alles Nötige schon mit. Einzig gpg wird vorausgesetzt. Unter Linux ist dieses Kommando meist schon installiert, unter macOS führt brew install gnupg zum Ziel.

Mit Strg+X Strg+F öffnen Sie eine Datei mit der Endung .gpg. Emacs fragt nach dem Passwort und zeigt die Datei dann unverschlüsselt an. Wenn Sie eine Datei wie geheim.txt.gpg speichern, fragt Emacs nach dem gewünschten Verschlüsselungspasswort.

Mehr Komfort

Ohne Konfiguration fragt Emacs bei jedem Speichervorgang nach dem Passwort, das zur Sicherheit dann doppelt eingegeben werde muss. Mit einer Zusatzzeile in .emacs merkt sich Emacs das Passwort pro Datei im Speicher. (Das ist natürlich ein gewisses Sicherheitsrisiko. Solange der Editor läuft, befindet sich das Passwort im Arbeitsspeicher. Aber Sie können nun beliebig oft speichern, es wird immer automatisch das einmal beim Laden oder beim ersten Speichern festgelegte Passwort verwendet.)

;; in .emacs
;; GPG-Passwort pro Datei im Speicher halten
(setq epa-file-cache-passphrase-for-symmetric-encryption t)

Standardmäßig versucht gpg die Passworteingabe an ein externes pinentry-Programm zu delegieren. Sie können ein solches Programm installieren (z.B. brew install pinentry-mac). Viel besser ist es aber, zur Passworteingabe direkt den Minibuffer von Emacs zu verwenden:

;; direkte Passworteingabe ohne externen pinentry-Dialog
(setq epg-pinentry-mode 'loopback)

Beim Speichern neuer Dateien mit GPG-Kennung fragt Emacs nach den Empfängeradressen. Diese sind für die symmetrische Verschlüsselung aber nicht nötig. Sie überspringen den Dialog ohne Auswahl mit OK. Aber noch besser ist es, wenn er gar nicht angezeigt wird. (Das setzt voraus, dass Sie die asymmetrische Verschlüsselung nie verwenden!)

;; Frage nach GPG-Empfängern überspringen
(setq epa-file-select-keys 'silent)

Quellen/Links

• https://www.gnu.org/software/emacs/manual/html_mono/epa.html
• https://www.gnupg.org/documentation/
• https://www.masteringemacs.org/article/keeping-secrets-in-emacs-gnupg-auth-sources
• https://kofler.info/emacs-als-markdown-editor

Über Ubuntu 26.04 habe ich hier schon berichtet. Heute habe ich meinen ersten Ubuntu-Server von Version 24.04 auf 26.04 aktualisiert. Es ist eigentlich recht gut gegangen. Dieser Beitrag fasst die wichtigsten Erkenntnisse zusammen.

• MySQL-Passwörter
• Dovecot-Konfiguration (Update 2.3 -> 2.4)
• SSH-Server-Konfiguration
• Externe und obsolete Pakete aufräumen

Grundsätzliche Vorgehensweise

Logischerweise sollten Sie zuerst ein Backup machen. Mein System ist eine virtuelle Maschine (KVM), ich habe also ein Backup des Images gemacht (LVM-Snapshot im laufenden Betrieb). Wäre irgendetwas total schief gegangen, hätte ich den ganzen Server blitzschnell in den alten Zustand zurückversetzen können.

Wichtig: Falls Sie Nextcloud verwenden, aktualisieren Sie die Nextcloud-Version zuerst und führen Sie das Ubuntu-Update erst danach durch. Andernfalls kann es Ihnen passieren, dass Nextcloud danach nicht mehr startet (Fehlermeldung: This version of Nextcloud is not compatible with PHP>=8.5. You are currently running 8.5.4). Es ist ziemlich mühsam, aus dieser Falle wieder herauszukommen, weil die üblichen Update-Mechanismen PHP voraussetzen!

Am Zielsystem habe ich dann ein letztes Update durchgeführt und dann do-release-upgrade gestartet. Der erste Lauf scheiterte an alten MySQL-Passwörtern. Nachdem ich diese umgestellt hatte (Details folgen gleich), lief do-release-upgrade ziemlich problemlos durch.

Bei sämtlichen Rückfragen, ob ich meine geänderten Konfigurationsdateien behalten oder lieber die neuen Konfigurationsdateien verwenden möchte, habe ich mich für meine alten Konfigurationsdateien entschieden. (Die Entscheidung ist nicht ganz einfach: Die neuen Konfigurationsdateien enthalten in der Regel bessere/neuere Einstellungen, die vorzuziehen wären. Umgekehrt will ich aber auch nicht die in der Vergangenheit vorgenommenen Änderungen verlieren.)

Danach ein Reboot, nach 30 Sekunden war ein neuer SSH-Login möglich. Sehr gut!

Jetzt begannen die Aufräumarbeiten. Es gab zwei Hauptprobleme:

• Dovecot funktionierte nicht mehr (das war zu erwarten).
• PHP auch nicht (das kam überraschend).

Vor dem Ubuntu-Update: MySQL-Passwörter

Mit Ubuntu 26.04 kommt MySQL 8.4. Diese Version des Datenbank-Servers unterstützt standardmäßig keine mysql_native_password-Passwörter mehr. Das ist an sich vernünftig, die Passwörter werden nach einem unsicheren Verfahren verschlüsselt. Es gibt zwei Lösungen: Eine besteht darin, das nicht mehr empfohlene Plugin mysql_native_password doch wieder zu aktivieren. (In Version 9 wird das aber nicht mehr gehen.) Die andere besteht darin, für alle betroffenen Benutzer ein neues Passwort mit dem Verfahren caching_sha2_password einzurichten, im Wesentlichen so:

ALTER USER name@localhost IDENTIFIED WITH caching_sha2_password BY 'topsecret';

Ich habe mich für diese Variante entschieden, zumal es ohnedies nur wenige betroffene Accounts gab. Zwei bereiteten mir allerdings Kopfzerbrechen. Welche Passwörter sollte ich für die (in der Vergangenheit) automatisch eingerichteten Accounts 'debian-sys-maint'@localhost und mysql.session@localhost verwenden? Eine kurze Recherche ergab, dass sich das Passwort für ersteren Account (eine Debian/Ubuntu-Spezialität) in /etc/mysql/debian.cnf befindet. Der zweite Account ist MySQL-intern. Es muss existieren, ist aber nicht für einen Login gedacht. Jedes zufällige Passwort ist OK.

Das eigentliche Update habe ich NACH den MySQL-Änderungen gestartet.

Nach dem Ubuntu-Update: PHP

Nach dem Update liefen Apache und der MySQL-Server auf Anhieb, nur PHP wollte nicht. Die Fehlermeldung im Apache-Log lautete:

(2)No such file or directory: AH02454: FCGI: attempt to connect to Unix domain socket /run/php/php8.3-fpm.sock (localhost:8000) failed

Der Fehler war leicht zu finden: Ich verwende PHP mit dem FastCGI Process Manager (FPM). Die PHP-Version wurde auf 8.5 aktualisiert, aber die Konfiguration verwies weiter auf die FPM-8.3-Version. Abhilfe:

apt install php-fpm
systemctl enable --now php8.5-fpm
a2disconf php8.3-fpm
a2enconf php8.5-fpm
systemctl restart apache2

Warum der Upgrade-Prozess sich um diese Details nicht gekümmert hat, kann ich nicht sagen. Möglicherweise hatte ich unter Ubuntu 24.04 irgendeine Abweichung von der Default-Konfiguration durchgeführt und die Konfigurationsdateien wurden deswegen nicht aktualisiert.

Ein letzter Hinweis zu PHP: Mit PHP 8.5 werden neue Konfigurationsdateien nach /etc/php/8.5 installiert. In meinem Fall (FPM) ist die Datei /etc/php/8.5/fpm/php.ini relevant. Änderungen, die in der Vergangenheit in der 8.3er-Version von php.ini vorgenommen wurden, müssen jetzt in der 8.5er-Version wiederholt werden. (In meinem Fall war vor allem memory_limit = 512M wichtig, damit Nextcloud ordentlich läuft. Der Defaultwert 128M ist zu klein.)

Dovecot

Dovecot (ein IMAP-Server) macht mit Ubuntu 26.04 einen Versionssprung von 2.3 auf 2.4. Das klingt unspektakulär, aber tatsächlich hat Dovecot mit der neuen Version die Syntax der Konfigurationsdateien grundlegend geändert. Solange die Dateien nicht angepasst werden und insbesondere die Anweisungen dovecot_config_version = 2.4.0 sowie dovecot_storage_version = 2.4.0 an den Beginn von /etc/dovecot.conf eingebaut werden, startet der Dienst nicht.

Upgrading Dovecot CE from 2.3 to 2.4 enthält eine umfassende Migrationsanleitung. Die simple Übernahme der neuen Konfigurationsdateien ist (in meinem Fall) unmöglich, weil ich diverse eigene Anpassungen vorgenommen habe. Schon vor dem Ubuntu-Update habe ich deswegen sicherheitshalber ein Backup des alten Konfigurationsverzeichnisses /etc/dovecot durchgeführt.

Die manuelle Migration erschien mir recht mühsam. Also habe ich Claude Code SSH-Zugriff auf meinen Server gegeben (für einen normalen Account, nicht für root) und habe den folgenden Prompt formuliert:

you can ssh to example.com (no root); go to /etc/dovecot and look at the config files; these are partially from 2.3 and must be updated to 2.4 (see also https://doc.dovecot.org/main/installation/upgrade/2.3-to-2.4.html); explain me what to change, don’t try to do it yourself; summarize your findings locally (not on example.com) into dovecot-migration-plan.md

Diesen Plan habe ich anschließend manuell umgesetzt. Anbei eine Kurzfassung:

Dovecot 2.3 -> 2.4: config changes

dovecot.conf

  Add these as the very first settings:

    dovecot_config_version = 2.4.0
    dovecot_storage_version = 2.4.0

  Remove the empty "dict { }" block.

conf.d/10-auth.conf

  Old: auth_username_format = %Ln
  New: auth_username_format = %{user | username | lower}

conf.d/auth-system.conf.ext

  passdb and userdb blocks need a name:

    passdb pam {
    }
    userdb passwd {
    }

conf.d/10-mail.conf

  mail_location is gone:

    mail_driver = maildir
    mail_path = ~/Maildir

conf.d/10-master.conf

  Old: user = $default_internal_user
  New: user = $SET:default_internal_user

conf.d/10-ssl.conf

  New setting names, no more "<" before file names:

    ssl = yes
    ssl_server_cert_file = /etc/letsencrypt/live/
                           example.com/fullchain.pem
    ssl_server_key_file  = /etc/letsencrypt/live/
                           example.com/privkey.pem
    ssl_server_dh_file   = /etc/dovecot/dh.pem
    ssl_server_prefer_ciphers = server

  (Each path belongs on one line; it is split here only
  for readability.)

  ssl_server_prefer_ciphers accepts "client" or "server";
  "yes" is a fatal error. The DH file is only needed for
  non-ECC key exchange and can be omitted.

conf.d/20-lmtp.conf

  "mail_plugins = $mail_plugins sieve" no longer works:

    protocol lmtp {
      postmaster_address = postmaster@example.com
      mail_plugins {
        sieve = yes
      }
    }

conf.d/90-sieve.conf

  The plugin { } block is gone. Use named script blocks:

    sieve_script personal {
      driver = file
      path = ~/sieve
      active_path = ~/.dovecot.sieve
    }
    sieve_script after {
      type = after
      driver = file
      path = /etc/dovecot/sieve-after
    }

  Recompile global sieve scripts (as root):

    sievec /etc/dovecot/sieve-after/spam-to-folder.sieve

  Users' own scripts are recompiled automatically.

Protocols

  2.4 enables no protocols by default. On Debian they come
  from /usr/share/dovecot/protocols.d, i.e. one file per
  installed package (imapd, lmtpd, managesieved, ...).

Testing

  doveconf -n          # must run without errors
  systemctl restart dovecot
  journalctl -u dovecot -n 50

  Then check IMAP login, LMTP delivery from Postfix, SMTP
  auth via the Postfix SASL socket and sieve filtering.

Eine halbe Stunde später konnte ich in Thunderbird meine Mails wieder abrufen.

Update Configuration File (UCF)

Eine Debian/Ubuntu-Pakete verwenden das Verfahren Update Configuration File (UCF). Bei diesen Paketen wird parallel zur unverändert belassenen Konfigurationsdateien die neue Version der Konfigurationsdatei mit der Kennung *.ucf-dist angelegt. Das ist praktisch, weil Sie unkompliziert danach suchen können:

find /etc -name '*.ucf-dist'

Leider wird UCF nur von ausgewählten Paketen verwendet (auf jeden Fall: apt, dovecot und ssh).

SSH-Server

Der SSH-Server (openssh-server 10.2) läuft zwar auf Anhieb (alles andere wäre ja eine Katastrophe), aber journalctl -u ssh liefert diverse Warnungen:

sshd: rexec line 16: Deprecated option UsePrivilegeSeparation
sshd: rexec line 19: Deprecated option KeyRegenerationInterval
sshd: rexec line 20: Deprecated option ServerKeyBits
sshd: rexec line 31: Deprecated option RSAAuthentication
sshd: rexec line 38: Deprecated option RhostsRSAAuthentication

Also habe ich auch diese Datei etwas aufgeräumt, wobei Claude Code einige weitere Verbesserungsvorschläge gemacht hat (ChallengeResponseAuthentication -> KbdInteractiveAuthentication, PermitRootLogin without-password -> PermitRootLogin prohibit-password, HostKey /etc/ssh/ssh_host_dsa_key entfernen).

Docker

In Ubuntu 24.04 hatte ich Docker-Pakete direkt aus dem Docker-Repo installiert. Die alten Pakete wurden unverändert belassen, Docker funktionierte weiter. Allerdings wurde im Rahmen des Updates die Docker-Paketquelle deaktiviert (siehe /etc/apt/sources.list.d/*.disabled), d.h. ich würde keine Updates mehr erhalten. Ich habe daher die folgende Datei docker.sources neu eingerichtet:

Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: resolute
Components: stable
Architectures: amd64
Signed-By: /etc/apt/keyrings/docker.asc

apt update und apt list --upgradable zeigt jetzt zu Ubuntu 26.04 passende Docker-Pakete an, die ich mit apt dist-upgrade installierte. Ein kurzer Test mit docker ps zeigt, dass alle Docker-Container wie geplant laufen.

Obsolete Pakete entfernen

Das Kommando

apt list '?obsolete'

liefert eine Liste von Paketen, die aus früheren Ubuntu-Versionen stammen (zu meiner Schande bis zurück nach 14.04) und zu denen es keine aktive Paketquellen mehr gibt (z.T. uralte Kernel-Versionen). Höchste Zeit, auch hier aufzuräumen. Ich habe Claude Code um eine Analyse gebeten.

find obsolete packages and access which can be safely removed

In der Folge habe ich die meisten betreffenden Pakete mit apt purge entfernt.

Quellen/Links

• https://documentation.ubuntu.com/release-notes/26.04/
• https://documentation.ubuntu.com/release-notes/26.04/summary-for-lts-users/#mysql
• https://doc.dovecot.org/main/installation/upgrade/2.3-to-2.4.html
• https://manpages.debian.org/trixie/ucf/ucf.1.en.html
• https://www.debian.org/doc/debian-policy/ch-files.html#configuration-files
• https://kofler.info/ubuntu-26-04

Im Rahmen meiner Arbeit für unser Claude-Code-Buch habe ich wieder einmal durchgetestet, wie weit man mit lokalen Modellen und Open-Source-Tools kommt. Als Coding-Agent habe ich das Programm Pi verwendet, das ich demnächst hier näher vorstellen will. Pi habe ich zusammen mit diversen lokalen Modellen ausprobiert, unter anderem Gemma 4, Qwen-3.6-35b-a3b, Qwen-3.8-27b sowie Qwen-3.8-Flash-Next. Der Testrechner ist mit 128 GB RAM und einer Strix-Halo-CPU ausgestattet.

Um es kurz zu machen: Gemma 4 und Qwen-3.6-35b-a3b sind für agentisches Programmieren einfach zu schwach. Qwen-3.8-27b ist spürbar besser, aber als »dichtes« Modell (dense, immer alle Parameter im Einsatz) mit meiner Hardware definitiv zu langsam. Richtig spannend ist dagegen Qwen-3.8-Flash-Next! Es ist mit 125 Milliarden Parametern das größte und neueste Modell in meinem Testparcours. Dank MoE (Mixture of Experts) sind aber stets »nur« 6 Milliarden Parameter aktiv. Das Modell enthält außerdem eine Look-up-Tabelle für Token-Kombinationen mit weiteren 51 Milliarden Parametern (N-gram Embedding Layer). Die Gesamtmodellgröße wird daher oft mit 180 Milliarden Parametern angegeben. Der Platzbedarf beträgt bei 4-Bit-Quantisierung ca. 110 GB auf der SSD sowie ca. 90 GB im RAM (weniger, weil nur Teile der Look-up-Tabelle tatsächlich im RAM landen). Bei meinen Tests liefert das Modell bessere Ergebnisse als Qwen-3.8-27b und ist gleichzeitig schneller. Eine sehr angenehme Kombination.

Der Rest dieses Artikels beschäftigt sich mit der Frage, welche Möglichkeiten es gibt, Qwen-3.8-Flash-Next auf Strix-Halo-Rechnern auszuführen. Um es vorwegzunehmen: Mein für Testzwecke beliebtes LM Studio ist ungeeignet. Dafür gibt es zwei Projekte, die speziell für die AMD-CPU optimierte Engines anbieten und einen Output von über 40 Token/s erreichen.

LM Studio

LM Studio ist prinzipiell meine erste Wahl, um ein neues Sprachmodell erstmalig auszuprobieren. Tatsächlich gelingt damit die Ausführung von Qwen3.8-Flash-Next-GGUF mit ca. 24 Token/s. Das ist OK, aber weit weg vom theoretischen Maximum. Der Hauptgrund besteht darin, dass es mir (mit meiner Hardware) nicht gelungen ist, MTP zum Laufen zu bringen. Es gibt zwar auf Hugging Face mehrere Qwen-3.8-Flash-Next-Varianten mit inkludierten MTP-Daten, aber die eine Variante läuft gar nicht, bei der nächsten funktioniert MTP nicht und die Token-Rate sinkt auf 12 Token/s etc.

Die Ursache: Diverse Qwen-3.8-Flash-Next-Varianten setzen speziell gepatchte llama.cpp-Versionen voraus. Das Experimentieren damit ist eine Frickelei, die mich an die ersten Linux-Jahre zurückdenken lässt.

Erfreulicherweise gibt es einige Projekte, die sich darauf spezialisiert haben, moderne Sprachmodelle auf Strix-Halo-Hardware bestmöglich auszuführen. Einen guten Überblick gibt dieses YouTube-Video von Donato Capitella. Ich konzentriere mich hier auf Gufo und Halogen.

Gufo

Das Open-Source-Projekt Gufo will einen einfachen Weg anbieten, speziell für die Strix-Halo-CPU optimierte Engines und Sprachmodelle so zu kombinieren, dass diese mit minimalem Aufwand installiert und so effizient wie möglich ausgeführt werden können.

Die Projektseite enthält Anleitungen, wie Gufo als Podman-Container ausgeführt oder mit nix lokal installiert und kompiliert werden kann. Ich habe mich für die Podman-Variante entschieden und setze dieses Container-System im Folgenden voraus. (Unter Fedora ist Podman per Default installiert.)

Die folgenden Kommandos kombinieren Infos aus dem Gufo-Quickstart und dem Qwen-3.8-Flash-Next-Readme mit ein paar Detailkorrekturen. Der Kontext ist auf die Maximalgröße eingestellt. --sessions 2 ermöglicht zwei parallele Sessions. Das kostet zusätzlichen Arbeitsspeicher; außerdem sind zwei parallele Sessions natürlich langsamer. Wenn Sie nur eine Session brauchen, ist --sessions 1 sicherer.

# hf-Kommando installieren
sudo dnf install python3-huggingface-hub

# aktuellen Benutzer zu den Gruppen render
# und video hinzufügen; wird erst in einer
# neuen Shell wirksam
sudo usermod -aG render,video "$USER"

# Arbeitsverzeichnis erstellen
mkdir ~/gufo
cd ~/gufo

# Qwen-3.8-Flash-Next herunterladen (ca. 110 GB); die Dateien
# landen in ~/gufo/models/qwen3.8-flash-next
hf download unsloth/Qwen3.8-Flash-Next-GGUF \
  --revision 38bb39ee97821de2c9009abb7e93950eec396e66 \
  --include "UD-Q4_K_XL/*" \
  --include "MTP/mtp-Qwen3.8-Flash-Next-shared-Q8_0.gguf" \
  --include "mmproj-BF16.gguf" \
  --local-dir models/qwen3.8-flash-next

# Pfade zu den Modellen in Variablen speichern
export MODEL="$PWD/models/qwen3.8-flash-next/UD-Q4_K_XL/Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf"
export MTP="$PWD/models/qwen3.8-flash-next/MTP/mtp-Qwen3.8-Flash-Next-shared-Q8_0.gguf"

# Gufo-Runtime-Image herunterladen (ca. 5,5 GB)
podman pull ghcr.io/gufo-org/toolboxes/gufo-runtime:latest

# LLM ausführen und auf Port 8080 anbieten
podman run --rm \
  --userns=keep-id:uid=1000,gid=1000 \
  --security-opt label=disable \
  --device /dev/kfd \
  --device /dev/dri \
  --group-add keep-groups \
  --ulimit memlock=-1 \
  -p 127.0.0.1:8080:8080 \
  -v "$(dirname "$(dirname "$MODEL")")":/models:ro \
  ghcr.io/gufo-org/toolboxes/gufo-runtime:latest \
  gufo serve --host 0.0.0.0 --port 8080 llm \
  --model "/models/UD-Q4_K_XL/$(basename "$MODEL")" \
  --speculative mtp \
  --mtp-model "/models/MTP/$(basename "$MTP")" \
  --sessions 2 \
  --context 262144

Mit curl können Sie ausprobieren, ob das Sprachmodell funktioniert:

curl -s http://127.0.0.1:8080/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{
           "model": "Qwen3.8 Flash Next",
           "messages": [{"role": "user",
                         "content": "Write a Python function that checks if a string is a palindrome."}],
           "max_tokens": 1000,
           "reasoning_effort": "low"
         }' | jq -r '.choices[0].message.content'

  (Antwort gekürzt ...)
  # Palindrome Checker in Python
  def is_palindrome(s: str) -> bool:
      # Remove non-alphanumeric characters and convert to lowercase
      cleaned = ''.join(ch.lower() for ch in s if ch.isalnum())

      # Compare the string with its reverse
      return cleaned == cleaned[::-1]

Damit der Coding-Agent Pi das Sprachmodell verwendet, tragen Sie den Server in ~/.pi/agent/models.json ein:

{
  "providers": {
    "qwen-38-flash-next-gufo": {
      "baseUrl": "http://localhost:8080/v1",
      "api":     "openai-completions",
      "apiKey":  "not necessary",
      "models": [
        { "id": "Qwen3.8 Flash Next",
          "contextWindow": 262144 }
      ]
    }
  }
}

Als Test habe ich Pi aufgefordert, zuerst einen Space-Invaders-Klon zu programmieren und danach eine Pause-Funktion zu implementieren. Dazu waren diese beiden Prompts und ca. 10 Minuten Geduld erforderlich. Der Terminal-Tab mit dem Podman-Container protokollierte Output-Token-Raten zwischen 35 und 50 Token/s, meistens ca. 40 Token/s.

Create a browser game called Invaders in a single file index.html. Plain HTML, CSS and JavaScript, no frameworks, no build step, no dependencies. Use a canvas size of 800×600. The player controls a ship at the bottom edge with the left and right arrow keys and fires with the space bar. Five rows of eight aliens move sideways as a block, step down one row when they reach an edge, and disappear when a shot hits them. The game ends when all aliens are destroyed or an alien reaches the bottom row. Show the score in the top left corner. Do not start a web server.

Implement a pause key (P).

Halogen

Der Halogen-Flash-Server ist in seiner Zielrichtung noch fokussierter. Als einziges Modell wird Qwen-3.8-Flash-Next unterstützt. Die Projektseite verspricht die höchste Token-Rate für dieses Modell auf Strix-Halo-CPUs. Der Nachteil: Teile der Software sind nicht Open Source und damit eine Black Box.

Die Installation bzw. Inbetriebnahme ist einfacher als bei Gufo. Auch Halogen setzt auf Podman. Ein einziges Kommando reicht aus, um das Halogen-Image und das Modell herunterzuladen. Weil Halogen eine anders optimierte Variante von Qwen-3.8-Flash-Next verwendet, ist neuerlich ein Download von über 110 GB notwendig (natürlich nur beim ersten Start). Das Modell wird in ~/halogen-models gespeichert. Die API verwendet standardmäßig den Port 8731. Halogen verwendet automatisch die maximale Kontextgröße (262.144 Token) und erlaubt vier parallele Sessions (einstellbar mit der Umgebungsvariablen HALOGEN_KV_SLOTS).

podman run --rm -p 127.0.0.1:8731:8731 \
  --device /dev/kfd --device /dev/dri --group-add keep-groups \
  --ipc=host --ulimit memlock=-1:-1 \
  -e HALOGEN_DOWNLOAD=peonist-ai/halogen-qwen3.8-flash-next \
  -v ~/halogen-models:/models \
  ghcr.io/peonist-ai/halogen-flash-server:0.17.3

Wiederum sollten Sie zuerst mit curl testen, ob alles funktioniert:

curl -s http://127.0.0.1:8731/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{
           "model": "halogen-qwen3.8-flash-next",
           "messages": [{"role": "user",
                         "content": "Write a Python function that checks if a string is a palindrome."}],
           "max_completion_tokens": 4096,
           "reasoning_effort": "low"
         }' | jq -r '.choices[0].message.content'

Die Konfigurationszeilen für Pi sehen so aus:

{
  "providers": {
    "halogen": {
      "baseUrl": "http://127.0.0.1:8731/v1",
      "api":     "openai-completions",
      "apiKey":  "halogen",
      "models": [
        { "id": "halogen-qwen3.8-flash-next",
          "contextWindow": 262144 }
      ]
    }
  }
}

Bei meinen Tests habe ich mit Halogen tatsächlich eine spürbar höhere Geschwindigkeit erreicht (Output zwischen 50 und 60 Token/s). Ich habe einen sehr simplen Benchmarktest durchgeführt und dazu die ersten 40 Aufgaben von HumanEval+ aus EvalPlus 0.3.1 mit Greedy-Decoding und reasoning_effort: low ausgeführt. Halogen brauchte 356 s (61,6 Tokens/s), Gufo 407 s (52,2 Tokens/s), also rund 12 % weniger Zeit bzw. 18 % mehr Durchsatz. Bei der Qualität lagen beide gleichauf: 39 von 40 Aufgaben mit den Original-Tests, mit den erweiterten Tests 37 (Halogen) bzw. 38 (Gufo). Der Test ist zu wenig spezifisch, um echte Qualitätsunterschiede für agentisches Coding festzustellen. Mir fehlt die Zeit, um weitere Tests laufen zu lassen. Immerhin lässt sich sagen: Beide Modelle tun, was sie sollen, und Halogen macht es ein wenig schneller.

Wenn Ihnen der Closed-Source-Black-Box-Charakter von Halogen egal ist, ist Halogen also eine gute Wahl und aktuell vermutlich der schnellste Weg, um Qwen-3.8-Flash-Next auf Strix-Halo-Geräten auszuführen. Gegen das Projekt spricht neben dem fehlenden Quellcode der Umstand, dass keine anderen Sprachmodelle unterstützt werden.

Fazit

Es ist immer wieder überraschend, wie viel Bastelarbeit erforderlich ist, um moderne Sprachmodelle mit offenen Gewichten tatsächlich auszuführen. (Um es noch einmal zu betonen: »Freie« Sprachmodelle sind nicht mit Open-Source-Software zu vergleichen. Zwar ist bei vielen derartigen Modellen immerhin dokumentiert, wie die Gewichte zustande kommen; die Basis des Modells, insbesondere die Trainingsdaten und die genauen Trainingsbedingungen, ist aber nicht zugänglich.)

Um die positiven Aspekte zu nennen: Die real erzielbaren Ergebnisse lokaler Modelle werden von Monat zu Monat besser. Das in diesem Beitrag vorgestellte Modell ist ein gutes Beispiel dafür. Qwen-3.8-Flash-Next schlägt sich in Benchmark-Tests ausgezeichnet. In Kombination mit einer dafür optimierten Engine sind die erzielbaren Token-Raten so hoch, dass ein produktives Arbeiten auf Consumer-Hardware möglich ist.

Die Qualität, Geschwindigkeit und Kontextgröße lokaler Modelle auf Consumer-Hardware kommen natürlich bei weitem nicht an die kommerziellen Modelle auf Cloud-Servern von OpenAI oder Anthropic heran; aber je nach Aufgabenstellung sind freie Modelle mittlerweile gut genug für praktische Arbeiten, z.B. zur Software-Entwicklung mit dem CLI Pi. Das sind gute Nachrichten für alle, die sich Unabhängigkeit und Datenschutz wünschen.

Ehrlicherweise muss ich sagen: Ein Claude-Pro-Abo kostet auch über Jahre gerechnet viel weniger als die für diese Tests erforderliche Hardware. (Mein Testrechner hat Ende 2025 knapp 2500 € gekostet. Mittlerweile ist der Rechner leider fast doppelt so teuer.) Gleichzeitig bieten Claude Code, Codex, Vibe CLI oder andere kommerzielle Angebote mehr Komfort, eine viel höhere Coding-Geschwindigkeit und natürlich, und das ist am wichtigsten, eine deutlich höhere Coding-Qualität. Wenn ich es mir aussuchen darf, werde ich für professionelle Software-Entwicklung also weiter bei den kommerziellen Anbietern bleiben.

Quellen/Links

• https://pi.dev
• https://lmstudio.ai
• https://kofler.info/llm-mtp-apex-qwopus
• https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF
• https://youtu.be/Nm_zN6RQ_eE (Qwen3.8-Flash-Next auf AMD Strix Halo, Video von Donato Capitella)
• https://github.com/evalplus/evalplus

Gufo

• https://github.com/gufo-org/gufo
• https://github.com/gufo-org/gufo/blob/main/docs/models/qwen3.8-flash-next/README.md

Halogen

• https://github.com/peonist-ai/halogen-flash-server
• https://huggingface.co/peonist-ai/halogen-qwen3.8-flash-next

Coding mit KI-Unterstützung ist mittlerweile für die meisten Entwickler gelebte Praxis. Weniger bekannt ist, dass CLIs wie Claude Code auch abseits der Programmierung ein großartiges Werkzeug sind: Mit CLIs können Sie per SSH Linux-Installationen administrieren, Backups überprüfen, Docker-Setups einrichten oder Mail-Server-Konfigurationen analysieren.

Darüber hinaus setze ich Claude Code seit einigen Monaten für die Korrektur meiner Linux-Prüfungen ein. In diesem Beitrag erkläre ich, wie das funktioniert und warum das für mich eines der überzeugendsten Beispiele für »agentische KI« abseits des Codings ist.

Ich konzentriere mich in diesem Artikel auf Claude Code und habe das Setup auch nur mit dieser CLI getestet. Aber prinzipiell sollte das Setup ebenso gut mit Codex, Vibe CLI, Pi oder jedem anderen KI-Tool funktionieren, das im Terminal läuft und mit einem ausreichend leistungsstarken Sprachmodell verbunden ist.

Linux-Administration mit Claude Code

Die größte Hürde bei der Systemadministration besteht darin, wie Claude Code root-Rechte erlangt. Der naheliegende Weg, die interaktive Eingabe des Passworts für sudo während einer Session, ist leider nicht vorgesehen. Es gibt mehrere Wege, diese Hürde zu umgehen:

• SSH-Key: Sie führen Claude Code auf Ihrem Arbeitsrechner oder Notebook aus. Über einen SSH-Key kann sich Claude Code beim zu administrierenden System ohne Passwort als root anmelden und dort arbeiten. Für die Prüfungskorrektur habe ich mich für diese Variante entschieden.

• sudo ohne Passwort: Sie installieren Claude Code auf dem Zielsystem und führen das Programm in einem gewöhnlichen Account aus. Dank einer Regel in /etc/sudoers.d/ kann Claude Code ohne interaktive Passwortangabe root-Rechte erlangen (z.B. ALL=(ALL:ALL) NOPASSWD: ALL). Dieser sudo-Zugang kann uneingeschränkt sein oder auf ausgewählte Kommandos limitiert werden.

• Claude Code als root: Sie installieren Claude Code am Zielsystem und führen es dort direkt mit root-Rechten aus. Das widerspricht aber dem Grundprinzip, möglichst nie größere, interaktive Programme mit root-Rechten auszuführen.

Sicherheitstechnisch sind alle drei Varianten in etwa gleich schlecht. Die letzte Variante ist vermutlich die schlimmste. Für Test-VMs und Entwicklungsumgebungen sind die skizzierten Wege akzeptabel. Für echte (produktive) Server ist Variante 2 der am ehesten taugliche Kompromiss.

Mindestens ebenso wichtig ist der Arbeitsmodus. Seit Sommer 2026 gilt der Auto-Modus als Defaultmodus von Claude Code. Dabei entscheidet ein zweites Sprachmodell (der Classifier), welche Kommandos ohne Rückfrage ausgeführt werden dürfen. Beim Programmieren funktioniert das ausgezeichnet.

Für die Administration von Servern ist dieser Modus aber gefährlich. Der Classifier sieht nämlich nie die Ausgabe von Kommandos wie lsblk oder pvs. Er kann deshalb nicht überprüfen, ob /dev/vdb wirklich das neue, leere Disk-Image ist oder ob sich dort schon aktiv genutzte Partitionen befinden. Paradoxerweise gilt: Je präziser Sie Ihren Auftrag formulieren, desto weniger wird nachgefragt. Wenn Sie sich bei /dev/vdb1 vertippt haben: Pech gehabt!

Wenn Claude Code beim Coding falsch »denkt« und Sie per Git zurück zum vorherigen Stand Ihres Projekts gehen müssen, ist das ärgerlich. Sollte Claude Code hingegen versehentlich die falsche SSD Ihres Servers neu partitionieren, ist das ein Fehler, der nicht mehr gutzumachen ist. (Nun gut, Sie haben natürlich ein Backup! Aber der Arbeitstag ist vermutlich trotzdem verloren.)

Für administrative Arbeiten empfehle ich deswegen den manuellen Modus, in dem jede Dateiänderung und jedes Shell-Kommando bestätigt werden muss. Am besten richten Sie für Ihre Admin-Aufgaben ein eigenes Projektverzeichnis ein und verankern den Modus dort dauerhaft in .claude/settings.json, damit Sie die Aktivierung nicht vergessen können:

{
  "permissions": {
    "defaultMode": "manual"
  }
}

Der manuelle Modus ist mit vielen Rückfragen verbunden. Mit der Antwort Yes, and don’t ask again speichert Claude Code eine Freigaberegel in .claude/settings.local.json. Ein regelmäßiger Blick in diese Datei lohnt sich: Zu großzügig geratene Regeln bleiben sonst dauerhaft aktiv, umgekehrt lassen sich oft mehrere Regeln zu einer zusammenfassen (z.B. Bash(sudo du *)). Die goldene Mitte sind Setups, in denen Sie den manuellen Modus mit Allow-Regeln für harmlose Kommandos kombinieren.

Nie auf Produktivsystemen! In meiner Admin-Praxis bin ich begeisterter Claude-Code-Anwender. Aber meine rote Linie sind Produktivsysteme. Mir ist klar, dass die Wissensbasis von Claude Code breiter und tiefer ist als die jedes Linux-Admins, und ich lasse mich auch gerne beraten. Aber so wie sich ein junger Mitarbeiter erst Vertrauen erarbeiten muss, bevor er kritische Aufgaben selbstständig erledigen darf, so geht es mir auch mit Claude Code. Was das Coding angeht, habe ich dieses Vertrauen. Was die Linux-Administration betrifft: noch nicht im gleichen Ausmaß.

Meine Linux-Lehrveranstaltung

Ich unterrichte an der Fachhochschule JOANNEUM in Kapfenberg seit über einem Jahrzehnt Linux-Administration. Das ist eine sehr grundlagenorientierte Lehrveranstaltung: Benutzerverwaltung, Zugriffsrechte samt setuid und setgid, Administration des Dateisystems samt LVM, Netzwerk-Basics, Paketverwaltung, systemd, Logging, elementare Tools (find, tar etc.).

Sowohl während der Übungen als auch zur Prüfung erhalten alle Studentinnen und Studenten Zugang zu virtuellen Maschinen. Die Prüfung besteht darin, Admin-Aufgaben auszuführen. Beurteilt wird danach der Zustand der virtuellen Maschinen. Die Prüfung ist damit viel praxisnäher als ein Multiple-Choice-Test. Drei Beispiele für typische Aufgaben:

• Richte auf /dev/vdb ein Physical Volume mit xxx MiB ein, füge es der Volume Group für das Root-Dateisystem hinzu und vergrößere dann das Logical Volume und das Dateisystem für /.
• Richte die Benutzer Jack, Joe und Averall ein. Deren Accounts sollen nach 90 Tagen ablaufen. Sie haben Zugriff auf ein gemeinsames Verzeichnis /data/some-task. Jeder der drei soll dort neu erzeugte Dateien der beiden anderen lesen, bearbeiten, aber nicht löschen können. Richte das Verzeichnis entsprechend ein.
• Sichere den SSH-Server mit Fail2ban ab.

Diese Prüfungs- bzw. Übungsaufgaben klingen beinahe wie Prompts! Bevor ich Claude Code mit der Korrektur der Prüfungen beauftragt habe, habe ich deswegen die Probe aufs Exempel gemacht: Ich habe eine zusätzliche virtuelle Maschine eingerichtet, Claude Code per SSH-Key Root-Zugang gegeben und ihm eine Prüfung übergeben, samt der Aufforderung, alle Aufgaben zu erledigen und die genaue Vorgehensweise in einer Datei zu protokollieren.

Weniger als zehn Minuten später war Claude Code fertig. Ich habe das Ergebnis kontrolliert: Alle Punkte! Die Studierenden haben 90 Minuten Zeit. Die volle Punkteanzahl erreicht praktisch niemand, nicht weil meine Prüfung so schwierig wäre (ist sie wirklich nicht!), sondern weil auch guten Admins Schlampigkeitsfehler unterlaufen, speziell unter (Prüfungs-)Stress.

Prüfungskorrektur bisher

Zur Korrektur musste ich bisher via SSH in jede virtuelle Maschine »hineinsehen« und den Zustand des Dateisystems, der Netzwerkkonfiguration, von installierten Paketen und Dateien analysieren. Ich habe dazu ein selbst geschriebenes Script verwendet, das per SSH für jede VM Kommandos wie cat /etc/fstab, lsblk, pvs, getfacl usw. ausführte und die Ergebnisse in einer Textdatei sammelte. Diese Textdatei (plus bei Unklarheiten ein direkter Login samt ein paar manuellen Kontrollen) war dann die Grundlage für meine Beurteilung.

Das hat funktioniert, war aber mühsam. Für Details musste ich trotzdem oft in die VM hinein. Und weil sich die Aufgaben von Prüfung zu Prüfung ändern, musste ich auch das Script jedes Mal anpassen. Damit nicht genug: Ich musste in einer Tabelle dokumentieren, welche Teilaufgaben erledigt wurden und welche Fehler dabei passiert sind, mir überlegen, wie viele Teilpunkte eine unvollständige Aufgabe wert ist, und schließlich die wichtigsten Dateien aus den virtuellen Maschinen archivieren, sodass ich meine Beurteilung zur Not später nachvollziehen und begründen kann. Jeder Schritt für sich ist einfach, aber in Summe kostete die Beurteilung jeder Prüfung eine Menge Zeit.

Prüfungskorrektur mit Claude Code

Mittlerweile sieht sich Claude Code die virtuellen Maschinen selbst an. Dazu habe ich ein Projektverzeichnis mit Unterverzeichnissen für die Prüfungsangaben (exams/), meine Unterrichtsunterlagen (teaching/) und die Protokolle der von Claude Code ausgeführten Kommandos (reports/) eingerichtet. Die Datei CLAUDE.md enthält ganz genaue Anweisungen, wie Claude Code die virtuellen Maschinen nach einer Prüfung analysieren soll. Die Idee sieht so ähnlich wie der folgende, stark gekürzte Prompt aus:

Exam evaluation

* You have root access to the VMs fh01.example.com to fh20.example.com.
* Each VM is the result of an exam according to exam-2026-06.md.
  You are to evaluate the exam.
* Prepare an ODS table with columns for each VM and rows for each
  task / subtask.
* For each VM evaluate the exam. First, make a backup of
  /root/.bash_history (backup file name: bash_history_<date_time>).
* Other than that, do not change anything! Only read/access/evaluate.
  Do not create or modify files, do not run configuration commands,
  do not fix errors. The VM should stay as much as possible in the
  state the student left it when finishing the exam.
* Insert the achieved points and comments on wrong or missing details
  into the ODS table.
* Make a backup of /etc, /root and /home/student, download it to the
  local machine and save it as archive-fh<nn>.tar.gz.

Damit die Punkteaufteilung für alle Teilnehmer konsistent ist, lasse ich Claude Code vorweg zu jeder Prüfung ein Bewertungsschema erstellen. Dieses kontrolliere ich und passe es fallweise an: Auch wenn eine Frage in fünf Aufzählungspunkten formuliert ist, sind die Punkte oft unterschiedlich zu gewichten, je nach Schwierigkeit und Zeitaufwand.

Ein großartiger Aspekt des Setups besteht darin, dass Claude Code die VMs nicht nur auswertet, sondern die Ergebnisse gleich in eine LibreOffice-Tabelle einträgt: Pro Prüfung/VM gibt es eine Spalte mit den Punkten und eine mit Kommentaren zu Fehlern oder fehlenden Details. Wenn ich mit einer Bewertung nicht einverstanden bin, ändere ich einfach die Punkte, die Summe wird automatisch neu berechnet. Um die ODS-Datei zu erzeugen, hat Claude Code ein kleines Python-Script geschrieben (mit dem Modul odfpy, installiert mit uv in einem lokalen Virtual Environment).

Beim ersten Durchlauf habe ich die Ergebnisse von Claude Code mit einer älteren Prüfung verglichen, die ich zuvor manuell korrigiert hatte. Überwiegend kamen wir zu den gleichen Resultaten, aber nicht immer. Beispielsweise hat Claude Code nur die benutzerspezifische Crontab-Datei angesehen, nicht aber die systemweite (/etc/crontab). Dort befand sich die in der Prüfung geforderte Konfiguration. Claude Code hätte hier also fälschlich einen Punkt abgezogen. Solche Erkenntnisse lasse ich Claude Code in einer Anleitungsdatei festhalten, die in CLAUDE.md verankert ist. Claude Code hat dort einen Abschnitt Known gotchas angelegt, der mit jeder Prüfung ein wenig wächst.

Die Erstellung des ganzen Setups hat ca. vier Arbeitsstunden beansprucht, in etwa so lange, wie ich bisher für die manuelle Korrektur einer Prüfung gebraucht habe. Bei der ersten »echten« Korrektur hat Claude Code für sieben Teilnehmer ca. eine halbe Stunde gebraucht, geht also keineswegs blitzschnell vor. Laut /status hat die Korrektur ca. ein Drittel des Tagesbudgets meines Pro-Abos verbraucht.

Fazit

Ganz ohne Handarbeit geht es nicht. Bei manchen VMs mit einer kaputten /etc/fstab-Datei muss ich diese zuerst reparieren, bevor die VM überhaupt bootet. Natürlich werfe ich nach der KI-Korrektur weiterhin einen Blick in jede virtuelle Maschine. Da und dort finde ich noch einen Punkt, wo mir Claude Code zu streng erscheint. (Ich handle eher nach der Richtlinie »Im Zweifel für den Angeklagten«.) Und in die endgültige Note fließen neben der Prüfung noch weitere Teilleistungen während des Semesters ein.

Was mir an diesem Setup so gut gefällt: Es nimmt mir den ungemein mühsamen Teil der Korrektur ab, das manuelle Auswerten jeder einzelnen VM. Das war in der Vergangenheit ebenso öd wie zeitaufwendig. Per KI-Hilfe verkleinert sich der Gesamtaufwand für die Korrektur etwa auf die Hälfte. Insbesondere muss ich nicht mehr für jede Prüfung ein neues Script zur Datensammlung schreiben: Claude Code liest die Prüfungsangabe und weiß selbst, wo es nachsehen muss.

Für mich ist das eines der besten Beispiele dafür, was »agentische KI« abseits des Codings in der Praxis bedeutet: Der Agent loggt sich selbstständig in beliebig viele VMs ein, führt dort Dutzende Kommandos aus, interpretiert die Ergebnisse im Kontext der Aufgabenstellung, vergibt Punkte, begründet Abzüge und schreibt alles in eine Tabelle. Ich kann Zusatzregeln angeben, dass mir z.B. die exakte Größe von Dateisystemen egal ist (alles im Bereich +/- 10 Prozent ist OK).

Ein angenehmer Nebenaspekt: Datenschutzprobleme gibt es keine. Claude Code erhält zu keinem Zeitpunkt die Namen meiner Studentinnen und Studenten. Der Agent sieht nur Linux-VMs mit Hostnamen wie fh<nn>.example.com. Die Zuordnung der VM-Nummern zu den Prüfungsteilnehmern erfolgt manuell durch mich.

Ist es für mich und meine StudentInnen nicht frustrierend, dass die KI auch bei der Linux-Administration besser ist als wir? Es ist wie beim Programmieren: Wir müssen uns mit neuen Realitäten arrangieren. Ich gebe zu, dass ich Claude Code und vergleichbare Tools noch nie auf produktiven Servern eingesetzt habe. So groß ist mein Vertrauen (noch) nicht. Für Testumgebungen, virtuelle Maschinen usw. ist es aber definitiv gut genug, auch zur Analyse »echter« Systeme. Sicher ist: So wie bei der Programmierung wird die KI auch in der Systemadministration viel verändern.

Bleibt die Frage nach dem richtigen Unterricht bzw. den richtigen Themen: Ist es noch zeitgemäß, tar-Optionen und LVM-Kommandos zu unterrichten? Ich habe mich immer gegen das Auswendiglernen gewehrt und erlaube meinen Studierenden, einen »Schwindelzettel« zur Prüfung mitzunehmen. Wichtiger als Detailwissen ist das Verständnis der Grundlagen. Was ist ein Dateisystem überhaupt? Warum gibt es unterschiedliche Dateisysteme? Was bringt LVM? Was ist der Preis? Wie kann ich LVM mit RAID kombinieren? Warum ist das sinnvoll?

Ich bin der Überzeugung, dass diese Grundlagen wichtig bleiben. KI-Tools werden uns (Systemadmins) manche öde Arbeit abnehmen. Aber so wie gute Programmierer mit KI bessere Ergebnisse erzielen als schlechte Programmierer, so werden gute Admins die KI sinnvoll anwenden, während schlechten Admins mehr Fehler unterlaufen. Die KI tut, was man ihr sagt, aber sie stellt den Auftrag selten in Frage. Wenn schon die Grundannahme falsch war, wird auch das KI-produzierte Ergebnis nicht aufregend ausfallen.

Zuletzt möchte ich noch auf zwei Videos von Florian Dalwigk verweisen. Er unterrichtet Ethical Hacking und hat mit Claude beim Pentesting/Hacking ähnliche Erfahrungen gemacht wie ich im Linux-Unterricht. Unsere Schlussfolgerungen sind vielleicht nicht ganz deckungsgleich, aber Sie werden viele Ähnlichkeiten erkennen …

• KI löst Praxisprüfung in Ethical Hacking
• Klausuren sind ein Anachronismus

Quellen/Links

• https://code.claude.com/docs/en/permissions
• https://code.claude.com/docs/en/auto-mode-config
• https://youtu.be/qGKSEgZgwV0
• https://youtu.be/_uXsYL6CdoU

Bernd Öggl und ich haben vor einem halben Jahr darüber diskutiert, welche Tools wir täglich nutzen. Das Ergebnis: Docker, Git und Claude Code. Nachdem wir zu den ersten beiden Themen bereits Bücher geschrieben haben, war es naheliegend, einen weiteren Band zu unserem neuen Lieblingswerkzeug nachzulegen. Und genau das haben wir getan! Das Buch wird gerade aus der Druckerei ausgeliefert.

Eigentlich beginnt die Geschichte dieses Buchs schon 2024. Da haben wir mit Aider das erste Coding-CLI ausprobiert. Die Begeisterung hielt sich damals in Grenzen. Im Herbst 2025 hat sich das geändert: Die Sprachmodelle waren gut genug, um agentisches Programmieren ohne die Kontrolle jeder einzelnen Zeile zu ermöglichen. Anthropic ist mit Claude Code das Kunststück gelungen, schneller und agiler als die Konkurrenz zu erraten, was Programmiererinnen und Entwicklern wichtig ist, und das Ganze in eine Terminal-basierte Umgebung zu verpacken. Agentic Coding per CLI erlebt gerade seinen Durchbruch.

Heute ist für uns ein Arbeiten ohne Claude Code kaum noch vorstellbar. Wir setzen das Programm nicht nur zur Software-Entwicklung ein, sondern auch für administrative Arbeiten, die Lösung von Setup-Problemen, die Suche nach Sicherheitslücken usw.

Das Buch ist kein Handbuch, das alle Optionen und Slash-Kommandos der Reihe nach abarbeitet. Stattdessen verbinden wir die Grundlagen mit vielen praktischen Beispielen aus größeren und kleineren Software-Projekten, die aus unserem beruflichen Alltag stammen. Wir versprechen Ihnen nicht das Blaue vom Himmel: Wir zeigen auch, wo Claude Code danebenliegt, und leiten daraus Arbeitsweisen ab, die sich bei uns bewährt haben.

Natürlich behandeln wir wichtigen Funktionen: Permissions, CLAUDE.md, Skills, Hooks, Plugins, MCP-Server, Subagenten und Worktrees. Ein eigenes Kapitel zeigt, was Claude Code als IT-Agent jenseits des Programmierens leisten kann. Auf KI-Grundlagen verzichten wir dagegen bewusst. Das Buch konzentriert sich fast vollständig auf die Nutzung von Claude Code im Terminal.

Weitere Details finden Sie hier.

Die 2. Auflage meines Scripting-Buchs ist frisch aus der Druckerei und ab Anfang August im Buchhandel erhältlich. Wie schon die erste Auflage dreht sich alles um die drei Scripting-Sprachen Bash, PowerShell und Python. Für die Neuauflage habe ich das Buch vollständig überarbeitet und aktualisiert. Neu dazugekommen sind unter anderem:

• Terminal Tuning (»Pimp my Terminal«): Nerd Fonts, Prompt Frameworks, moderne CLI-Tools
• Python-Modulverwaltung mit uv
• Ein neues Kapitel zum Erstellen und Zeichnen von Diagrammen
• Ein neues Kapitel zum E-Mail-Versand per Script
• Ein neues Kapitel zur Nutzung von KI-APIs in eigenen Scripts
• Viele neue Praxisbeispiele: Claude-Code-Sessions exportieren, Web Scraping mit Playwright, GPS-Tracks aus Fotos extrahieren, WordPress-Bilder nachträglich mit Alt-Beschreibungen versehen usw.

Gerade jetzt ist Scripting-Wissen wichtiger denn je. KI-Tools wie Claude, ChatGPT oder Gemini erzeugen auf Zuruf Scripts – und führen sie oft gleich selbst aus. Das funktioniert erstaunlich gut, solange jemand am Ruder sitzt, der den resultierenden Code auch beurteilen kann: Welche Sprache eignet sich für die Aufgabe? Was macht dieses PowerShell-Cmdlet eigentlich? Ist der generierte Bash-Einzeiler sicher, oder löscht er versehentlich das falsche Verzeichnis? Ohne dieses Grundwissen bleibt nur blindes Vertrauen in den KI-Output – und das ist bei Code, der auf Servern oder Produktivsystemen läuft, keine gute Idee.

Das Buch vermittelt das Fundament, um Scripts selbst oder mit KI-Hilfe zu erstellen: Crashkurse zu den drei Sprachen, das nötige Handwerkszeug (SSH, Git, VS Code, reguläre Ausdrücke, JSON/XML-Verarbeitung) und zahlreiche Praxisbeispiele aus Backup, Bildverarbeitung, Web Scraping, Datenbank- und Cloud-Administration. Wer diese Grundlagen beherrscht, kann KI-generierte Scripts nicht nur einsetzen, sondern auch verstehen, anpassen und im Zweifel selbst debuggen.

Alle Infos zum Buch, eine Leseprobe und die Bestell-Links finden Sie auf der Buchseite.

Gemeinsam mit Rainer Hattenhauer habe ich im Frühjahr/Sommer Agentic AI – Wie Sie die KI für sich arbeiten lassen verfasst. Das Buch wird gerade an die Buchhandlungen ausgeliefert. Während bei der KI-Nutzung in der Vergangenheit die Kommunikation mit Chatbots im Vordergrund stand, können moderne KI-Agenten selbstständig planen, Werkzeuge nutzen und mehrstufige Aufgaben ausführen – von der Tagesplanung über die E-Mail-Kommunikation bis zu Workflows mit Skills, MCP, lokalen Modellen und der Steuerung von Smart-Home-Systemen.

Das Buch richtet sich explizit nicht an Leute, die mit KI-Unterstützung programmieren möchten. Für dieses Thema verweise ich auf Coding mit KI sowie Claude Code.

Ein paar persönliche Anmerkungen: Der reine Chat mit einer KI – Frage stellen, Antwort bekommen – gehört für mich schon fast der Vergangenheit an. Natürlich verwende ich Chatbots weiterhin zur Recherche. Aber auf dem Rechner installierte KI-Agenten (sprich: die ChatGPT-App, die Claude-App, aber auch Claude Code, oder unter Linux das Programm Hermes) können viel mehr: Ich erstelle damit komplexe Automatisierungs-Setups, die dann in einem faszinierenden Ausmaß selbstständig laufen.

Ich frage also nicht mehr »Wie geht das?«, sondern ich fordere den KI-Agenten auf: »Mach das!« Ganz von alleine klappt das natürlich nicht immer. Ein wenig Arbeit für das Setup, das Einrichten von CLAUDE.md oder AGENTS.md, manchmal die Installation eines Plugins oder MCP-Servers — das gehört dazu. Diese Arbeit lohnt sich, wenn es um Aufgaben geht, die sich wiederholen.

Mein Aha-Erlebnis war die Korrektur einer Linux-Prüfung, die ich vor einem Monat (fast) vollständig auf KI umgestellt habe (siehe den entsprechenden Blog-Artikel). Nein, die Korrektur erfolgt NICHT zur Gänze KI-gesteuert, ich muss zum Schluss noch einmal darüberschauen. Aber Claude Code (mein Lieblings-Tool für fast alles) nimmt mir jetzt unglaublich viel öde Arbeit ab. Claude Code verbindet sich via SSH mit einem Dutzend virtueller Maschinen, sieht nach, welche der Aufgabenstellungen dort erledigt sind, und trägt die Ergebnisse in eine ODS-Tabelle ein. Grandios!

Oder werfen Sie einen Blick auf https://scripting-buch.netlify.app. Spannend ist weniger der Inhalt, den können Sie auch hier auf kofler.info nachlesen. Spannend ist, dass diese Website ausschließlich aus ein paar Prompts entstanden ist. Ich habe der ChatGPT-App (ehemals Codex) die Markdown-Dateien zum Buch gegeben, einen Link auf die Buchseite beim Rheinwerk-Verlag, und habe im Prinzip gesagt: »Mach‘ mir eine tolle Website zu diesem Buch.« Ich bin nicht leicht zu verblüffen, aber alleine das zum Scripting-Thema so gut passende Layout ist großartig! Mit meinen eher bescheidenen Layout-Fähigkeiten hätte das viel nüchterner, langweiliger ausgesehen. Beachten Sie die konzentrischen Kreisen hinter dem Cover. Die Idee stammt von Codex nach einer Analyse des Cover-Bilds, die Umsetzung sind wenige Zeilen CSS-Code. Das ist schon ziemlich genial.

Hab‘ ich Sie neugierig gemacht? Alle Details – Kapitelübersicht und Bestell-Links – finden Sie auf der Buchseite.

In der Vergangenheit gab es in Österreich eine PV-Förderung (EAG-Investitionszuschuss). Die Anträge waren kompliziert, der Fördertopf innerhalb weniger Minuten erschöpft.

Die damalige türkis-grüne Regierung hat diesen Unsinn per 1.1.2024 weitgehend abgestellt und stattdessen die Umsatzsteuer für private PV-Anlagen bis 35 kWp ausgesetzt. Damit entfielen für fast alle privaten PV-Anlagen die lästigen Förderanträge bei der OeMAG. Die erlassene USt entsprach ziemlich genau der Förderhöhe. Im Gegenzug sank der irrsinige Verwaltungsaufwand praktisch auf Null.

Mit dem Regierungswechsel kam das rasche Ende. In einer der ersten Maßnahmen wurde die ohnedies befristete USt-Aussetzung per 1.4.2025 vorzeitig beendet. Aber ein bisschen »öko« wollte die neue Regierung dann doch sein. Das alte Fördermodell wurde mit all seinen Nachteilen reaktiviert, aber mit einem (noch) bescheidenerem Budget ausgestattet. So bescheiden, dass beim letzten Förder-Call nur Anträge innerhalb der ersten 33 Sekunden angenommen wurden (derstandard.at).

Lieber ein ehrlicher Förderstopp als eine Verhöhnung des Volkes

PV-Produkte sind in den vergangenen Jahren erheblich billiger geworden. Man kann also volkswirtschaftlich argumentieren, dass eine Förderung nicht mehr notwendig ist. Von diesem Argument lasse ich mich sogar überzeugen. Ein regenerativer Umbau Österreichs genießt ja leider nicht die höchste Priorität der Regierung, um es einmal höflich zu formulieren. Insofern wäre es also vermutlich zweckmäßiger, die ohnedies bescheidenen Mittel zur Förderung regenerativer Heizungen (Wärmepumpen!) zu bündeln und den PV-Sektor ganz dem freien Markt zu überlassen.

Aber wenn man zu dieser Erkenntnis gelangt, dann sollte man auch den Mut haben, das auszusprechen. Die Pseudo-PV-Förderung, die wir heute haben, ist eine Verhöhnung des Volkes. In den Genuss einer Förderung kann aktuell nur kommen, wer erstens die Formulare für den Förderantrag praktisch auswendig kennt und alle Daten per Cut&Paste blitzschnell einfügen kann; und wer zweitens Glück hat.

Dieses System ist absurd. Es ist mit einer Lotterie zu vergleichen. Dann lieber gar keine Förderung! Das aktuelle System bereitet nur Frust und ist sogar kontraproduktiv, weil geplante PV-Anlagen verschoben werden — in der unsinnigen Hoffnung, vielleicht beim nächsten Förder-Call mehr Glück zu haben.

Quellen/Links

• https://www.bmf.gv.at/themen/steuern/fuer-unternehmen/umsatzsteuer/informationen/steuersatz-fuer-photovoltaikmodule.html
• https://www.derstandard.at/story/3000000331550/solar-foerderung-in-33-sekunden-weg-wie-der-sparkurs-den-photovoltaik-boom-ausbremst
• https://www.eag-abwicklungsstelle.at

Für die Neuauflage meines Scripting-Buchs habe ich mich zuletzt mit dem Senden und Empfangen von E-Mails per SMTP und IMAP beschäftigt. Dieser Blog-Beitrag stellt das Standardmodul imaplib vor. Damit können Sie per IMAP Postfächer abrufen und verwalten. Die Anwendung ist ein wenig umständlich, aber dafür können Sie wirklich praktisch alles machen, was das Protokoll IMAP vorsieht.

Kurz erklärt: IMAP und Authentifizierung

IMAP (Internet Message Access Protocol) ist das Standardprotokoll zum Abrufen und Verwalten von E-Mails auf einem Mailserver. Die Verbindung erfolgt normalerweise über Port 993 mit SSL/TLS. Im Unterschied zu POP3 verbleiben die Nachrichten auf dem Server und lassen sich in Ordnern organisieren – IMAP eignet sich daher besonders gut für die automatisierte Verarbeitung.

Klassische Unix/Linux-Mailserver erlauben die Anmeldung mit Benutzername und Passwort. Bei Google-Konten ist das anders: Gmail erfordert entweder App-Passwörter (16-stellige Codes, die Sie nach Aktivierung der Zwei-Faktor-Authentifizierung unter myaccount.google.com/apppasswords erstellen) oder OAuth2. App-Passwörter sind dabei die einfachere Variante für Scripts.

Passwörter sollten nie direkt im Scriptcode stehen. Die Beispiele hier lesen die Zugangsdaten aus Umgebungsvariablen, die wiederum aus einer Datei credentials.env geladen werden:

# credentials.env  (chmod 600; in .gitignore aufnehmen!)
IMAP_HOST=mail.example.com
IMAP_USER=username
IMAP_PASS=topSecret

In Python laden Sie die Datei am einfachsten mit python-dotenv:

from dotenv import load_dotenv
load_dotenv("credentials.env")

Das Modul installieren Sie mit pip install python-dotenv oder – wenn Sie uv verwenden – mit uv add python-dotenv.

imaplib: Verbinden, suchen und herunterladen

imaplib ist seit Python 2 Bestandteil der Standardbibliothek und deckt den vollständigen IMAP-Befehlssatz ab. Das folgende Beispiel-Script stellt die Verbindung zur Inbox her, lädt die zehn neuesten E-Mails herunter und zeigt die wichtigsten Metadaten tabellarisch an – mit * als Indikator für noch ungelesene Nachrichten:

* 13-05 17:53  papa.xxx@xxx...     AW: Halbjahresabrechnungen
  12-05 20:48  kundenxxx@xxx...    Terminanfrage Sendungszustel...
  12-05 04:02  info@weltxxx...     Japan, Korsika oder Sansibar ...
  11-05 20:51  noreply@xxx...      OpenAI Dev News: Realtime 2.0...
  05-05 18:58  cron@webxxx         Invitation updated: iprot dev 
  04-05 08:28  externexxx@fhxxx... Vertrag bereit zur Abbrechnung

imaplib.IMAP4_SSL stellt die Verbindung zum IMAP-Server auf Port 993 her. select öffnet einen Ordner, search liefert eine Liste von Nachrichten-IDs als leerzeichen-getrennte Byte-Zeichenkette, fetch lädt die Rohdaten einer einzelnen oder mehrerer Nachrichten.

Der Parameter readonly=True bei select stellt sicher, dass das Abrufen der Nachrichten keine Nebeneffekte hat – insbesondere werden keine Nachrichten als gelesen markiert. Das ist wichtig, weil IMAP-Server den Status einer Nachricht bereits beim Öffnen verändern können.

search(None, "ALL") liefert eine aufsteigend sortierte Liste aller Nachrichten-IDs im Postfach. Mit split()[-10:] extrahieren Sie die zehn neuesten. Diese IDs werden, getrennt durch Kommas, zu einem einzigen fetch-Aufruf zusammengefasst. Als Fetch-Attribute übergeben Sie FLAGS für den Lesestatus sowie BODY.PEEK[HEADER.FIELDS (...)], um nur die benötigten Header-Felder abzurufen. PEEK verhindert dabei, dass der Server die Nachrichten automatisch als gelesen kennzeichnet.

Jede Zeile der Server-Antwort ist ein Tupel aus Metadaten und rohen Header-Bytes. ParseFlags wertet die Metadaten aus und gibt die IMAP-Flags als Tupel zurück. Wenn \Seen fehlt, gilt die Nachricht als ungelesen. message_from_bytes wandelt die Header-Bytes in ein auswertbares Objekt um.

parsedate_to_datetime macht aus einem RFC-2822-Datum ein datetime-Objekt, das dann mit strftime nach eigenen Vorstellungen formatiert werden kann. parseaddr zerlegt das From-Feld in ein (Name, Adresse)-Tupel. MIME-kodierte Header-Zeichenketten wie =?utf-8?q?...?= entschlüsselt decode_header aus dem Modul email.header.

Die Ergebnisse werden zunächst in einer Liste gesammelt, da die Reihenfolge der Server-Antwort nicht zwingend der Reihenfolge der angefragten IDs entspricht. reversed dreht die Liste beim Ausgeben um, sodass die neueste Nachricht zuerst erscheint.

# Beispieldatei fetch-imap.py
import os, email, imaplib
from email.header import decode_header, make_header
from email.utils import parsedate_to_datetime, parseaddr
from dotenv import load_dotenv

# IMAP-Konfigurationsparameter lesen
load_dotenv("credentials.env")
HOST = os.environ["IMAP_HOST"]
USER = os.environ["IMAP_USER"]
PASS = os.environ["IMAP_PASS"]

# RFC-2047-Header (=?utf-8?q?...?=) dekodieren
def decode_mime(value: str | None) -> str:
    return str(make_header(decode_header(value or "")))

# Zeichenkette auf max_len verkürzen
def truncate(text: str, n: int) -> str:
    return text if len(text) <= n else text[: n - 3] + "..."

# Verbindung zum IMAP-Server
with imaplib.IMAP4_SSL(HOST) as imap:
    imap.login(USER, PASS)
    imap.select("INBOX", readonly=True)  # nichts ändern!

    # IDs aller Nachrichten ermitteln -> Byte-String für fetch()
    _, data = imap.search(None, "ALL")
    id_set = b",".join(data[0].split()[-10:])  # max. 10

    # IDs der ungelesenen Nachrichten
    _, unseen_data = imap.search(None, "UNSEEN")
    unseen = set(unseen_data[0].split())

    # relevante Spalten abfragen (IMAP-Syntax); PEEK, damit
    # das Seen-Flag nicht gesetzt wird
    fields = "(FLAGS BODY.PEEK[HEADER.FIELDS (DATE FROM SUBJECT)])"
    _, rows = imap.fetch(id_set, fields)

    # Daten/Spalten dekodieren und formatieren
    messages = []
    for row in rows:
        if not isinstance(row, tuple):
            continue
        meta, raw_headers = row
        # Sequence-Nummer am Beginn der Metadaten (b'4 (FLAGS ...')
        seq     = meta.split()[0]
        is_new  = seq in unseen
        msg     = email.message_from_bytes(raw_headers)
        dt      = parsedate_to_datetime(msg["Date"])
        date    = dt.strftime("%d-%m %H:%M")
        addr    = parseaddr(decode_mime(msg.get("From", "")))[1]
        sender  = truncate(addr, 20)
        raw_sub = decode_mime(msg.get("Subject", "(no subject)"))
        subject = truncate(raw_sub, 40)
        messages.append((is_new, date, sender, subject))

    # in umgekehrter Reihenfolge ausgeben, die neueste Mail zuerst
    for is_new, date, sender, subject in reversed(messages):
        flag = "*" if is_new else " "
        print(f"{flag} {date}  {sender:<20}  {subject}")

Was imaplib sonst noch kann

Das obige Beispiel kratzt nur an der Oberfläche. imaplib deckt den vollständigen IMAP-Befehlssatz ab:

• Vollständige Nachrichten laden: Mit fetch können Sie nicht nur Header, sondern auch den kompletten Nachrichtentext inklusive Anhänge abrufen.
• Filtern: search akzeptiert IMAP-Suchkriterien wie FROM, SUBJECT, SINCE oder UNSEEN, um gezielt nach bestimmten Nachrichten zu suchen.
• Flags setzen: store setzt oder entfernt Flags wie \Seen, \Flagged oder \Deleted.
• Löschen: expunge löscht die als \Deleted markierten Nachrichten endgültig.
• Ordner verwalten: copy verschiebt Nachrichten zwischen Ordnern, list gibt alle verfügbaren Mailboxen zurück, create und delete legen neue Ordner an oder entfernen sie.

Kurz gesagt: Von der einfachen Posteingangsübersicht bis zur vollautomatisierten Mailbox-Verwaltung ist alles drin.

Alternativen zu imaplib

Wer die etwas sperrige API von imaplib als mühsam empfindet, kann auf IMAPClient ausweichen. Die Bibliothek ist ein High-Level-Wrapper um imaplib, der insbesondere den Umgang mit Nachrichten-IDs, Flags und Ordnern deutlich angenehmer macht. Das folgende Mini-Beispiel zeigt die Verbindung und das Abrufen der Betreffzeilen aller ungelesenen Nachrichten:

from imapclient import IMAPClient

with IMAPClient(HOST) as client:
    client.login(USER, PASS)
    client.select_folder("INBOX", readonly=True)
    messages = client.search("UNSEEN")
    for uid, data in client.fetch(messages, "ENVELOPE").items():
        print(data[b"ENVELOPE"].subject.decode())

IMAPClient installieren Sie mit pip install imapclient bzw. uv add imapclient.

Wer IMAP in einem asyncio-Kontext benötigt, greift zu aioimaplib – einer vollständig async-fähigen Bibliothek, da imaplib synchron blockiert. Und imbox ist eine sehr einsteigerfreundliche Abstraktion, die E-Mails als Python-Objekte mit direkt zugänglichen Attributen wie .subject oder .attachments liefert. Der Nachteil: weniger Kontrolle bei komplexen Operationen.

Quellen und Links

• imaplib – Dokumentation (docs.python.org)
• Introduction to IMAP (nickb.dev)
• python-dotenv
• IMAPClient
• aioimaplib
• imbox

Mitte Juni 2026 wurden über 1500 AUR-Pakete kompromittiert (siehe auch den vorigen Blog-Beitrag zu diesem Thema). Es zeugt natürlich von großer Überheblichkeit, als Mitautor eines Hacking-Buches zu glauben, selbst immun gegen Angriffe zu sein. Ein Update zum falschen Zeitpunkt hat mich auf den Boden der Tatsachen zurückgeholt und mir — einen Tag vor Urlaubsantritt — eine Menge sinnloser Arbeit beschert. Ich habe Anthropic- und OpenAI-Keys widerrufen, die SSH-Keys des betroffenen Notebooks von diversen Servern und Dienstleistern gelöscht und unzählige Passwörter geändert. Sch***!

Heute habe ich, natürlich ohne das System neuerlich zu booten, eine Analyse gemacht. Im Prinzip:

pacman --root /mnt/arch --dbpath /mnt/arch/var/lib/pacman -Qm

Ich habe 60 AUR-Pakete gefunden. Nur eines davon (libgdata, eine veraltete GNOME-Bibliothek für den Zugriff auf Google-Dienste) wurde kompromittiert. Ich habe es nur Stunden nach der Manipulation, aber eben noch vor der Berichterstattung über den Hack installiert. Extremes Pech im Timing!

Dieser Blog-Beitrag ist der Versuch einer persönlichen Aufarbeitung. Was ist passiert? Warum ist es passiert? Und was kann ich daraus lernen?

Eines vorweg. Dieser Artikel ist keine Kritik am Arch-Linux-Projekt. Dieses hat immer klar kommuniziert, dass AUR-Pakete — wie der Name schon sagt (Arch User Repository) — von den Benutzern selbst gepflegt werden und keiner Kontrolle unterliegen. Wer solche Pakete installiert, ist selbst verantwortlich, mit allen — dieses Mal sehr unerfreulichen — Konsequenzen.

Auch Updates können gefährlich sein

Die Sicherheitsempfehlung schlechthin lautet: »Installieren Sie regelmäßig Updates.« Aber diese Regel gilt nur für Pakete aus offiziellen Quellen.

Für extern gepflegte Pakete wäre eine Cool-Down-Phase sinnvoll. Im Prinzip: »Mach ein Update aller offiziellen Pakete sowie eines aller extern gepflegten Pakete, sofern dieses Update zumindest 4 Tage alt ist«. (Über die genaue Zeitspanne kann man streiten.) Ich kenne allerdings keinen Paketmanager, der so eine Funktion bietet.

In die richtige Richtung gehen die Auto-Update-Funktionen von Debian und Ubuntu: Unter Debian werden per Default ausschließlich offizielle Debian-Sicherheitsupdates berücksichtigt (Datei /etc/apt/apt.conf.d/50unattended-upgrades). Sonstige Updates werden ignoriert und müssen manuell installiert werden. Ubuntu ist etwas liberaler und installiert alle Updates aus offiziellen Quellen (aber ebenfalls keine aus externen Quellen).

Kurz gesagt: Ein blindes Update über alle Pakete ist nur sinnvoll, wenn Sie sich über die Herkunft aller Pakete sicher sind. Vielleicht werde ich in zukünftigen Blog-Artikeln Tipps zusammenfassen, wie Updates feiner gesteuert werden können.

Wozu überhaupt nicht-offizielle Pakete?

Eine andere Sicherheitsempfehlung lautet: »Verwenden Sie nur offiziell gepflegte Pakete.« Dennoch hat praktisch jede Distribution zusätzliche Paketquellen:

• Arch Linux: AUR
• Debian: externe Debian-Repositories
• Fedora: externe YUM-Paketquellen, COPR
• RHEL + Klone: EPEL, Remi und andere externe YUM-Paketquellen
• Ubuntu: externe Debian-Repositories, PPAs

Wenn externe Quellen unsicher sind, warum gibt es sie dann überhaupt? Weil sie manchmal der einzige und viel öfter der bequemste Weg sind, um Software zu installieren, die in den offiziellen Quellen fehlt. Für mich als Autor ist es wichtig, neue, nicht so bekannte Programme unkompliziert auszuprobieren. Viele Entwickler nutzen externe Pakete zur Installation von Tools, die nicht oder nur in veralteten Versionen zur Verfügung stehen. Schließlich fehlen kostenlose Programme mit kommerziellem Ursprung (also keine reine Open-Source-Software) wie Google Chrome in den offiziellen Quellen. Für »große« Distributionen gibt es zumeist »halb-offizielle« Pakete, aber für kleinere Distributionen wie Arch Linux sind Sie auf AUR-Pakete angewiesen.

Insofern ist der Rat, auf externe Quellen zu verzichten, für fortgeschrittene Benutzer und Software-Entwicklerinnen nur schwer umzusetzen.

Alles, worüber ich hier im Kontext von Linux-Paketen schreibe, gilt im Übrigen auch für die Erweiterungen/Bibliotheken aller wichtigen Programmiersprachen, Editoren und anderer Tools: also für Python-Module, NPM-Pakete, VSCode-Plugins etc. Der Überbegriff für Angriffe auf derartige Zusatzpakete lautet Software Supply Chain Attack (Lieferkettenangriff).

Weniger ist mehr

Für mich persönlich ist das AUR-Debakel ein Grund, die Nutzung externer Pakete viel stärker zu hinterfragen. Vorgenommen habe ich mir folgende Regeln:

• So wenig externe Pakete wie möglich! (Gibt es geeignete Alternativen in den offiziellen Quellen?)
• Ungenutzte externe Pakete deinstallieren. (Welche Pakete habe ich zwei, drei Monate nicht mehr gebraucht? Weg damit!)
• Eine stärkere Differenzierung zwischen Test- und Work-Systemen.

Schadensminimierung

Der AUR-Angriff hat auf Authentifizierungsdaten abgezielt, also Keys, Tokens, Passwörter etc. aus allen erdenklichen Quellen (.ssh-Verzeichnis, Passwörter diverser Browser usw.) Eine sehr detaillierte Analyse der Malware finden Sie auf ioctl.fail.

In meinem Fall war das größte Problem die Passwortsynchronisation von Google Chrome. Ich speichere im Webbrowser viele Passwörter. Die Passwort-Synchronisation ist durch ein zusätzliches, persönliches Passwort geschützt. Bookmarks und Passwörter sollten also für Google unlesbar sein. Wenn ich ein neues System einrichte (Linux, Windows, macOS, iOS oder Android), installiere ich Google Chrome, melde mich bei Google an, gebe das Master-Passwort für Bookmarks und Passwörter ein und synchronisiere die Daten. Das geht blitzschnell und ist komfortabel. Aber es ist eben ein riesiger Single Point of Failure! Das Master-Passwort schützt mich vor einem Passwort-Hack bei Google, aber es hilft nicht, wenn der Angreifer die lokale Passwort-Datenbank (sqlite-Format) auslesen kann. Und genau das war beim AUR-Angriff der Fall.

Die Konsequenz: Ich werde in Zukunft die Anzahl der so synchronisierten Passwörter auf ein absolutes Minimum reduzieren und länger nicht benutzte Passwörter löschen bzw. woanders speichern. Der naheliegende Ort wäre natürlich ein Passwort-Manager. Ich muss aber gestehen, dass ich diesen Programmen gegenüber auch skeptisch bin. Sie ersetzen einen Single Point of Failure durch einen anderen. Wer mit plattformübergreifenden Tools positive Erfahrungen gemacht hat, darf seine/ihre Erfahrungen gerne in den Kommentaren teilen :-)

Einmal mehr die Distributionsfrage

Auf meinem Linux-Notebook werde ich die aktuelle Parallel-Installation von Arch Linux und CachyOS bei nächster Gelegenheit durch Fedora ersetzen. Ich habe das Notebook zuletzt fast nur noch unterwegs verwendet. Im Büro habe ich mit dem Framework Desktop eine attraktivere Alternative. Dort habe ich mich im Rahmen meiner KI-Arbeiten gut an Fedora gewöhnt.

Zu glauben, Fedora sei frei von den skizzierten Gefahren, wäre natürlich naiv. Aber vermutlich sind die Risiken bei großen, weit verbreiteten Distributionen mit kommerziellem Hintergrund (Fedora ist ja eine Art offizielle Spielwiese von Red Hat) doch geringer als bei kleineren Distributionen — auch, was weit verbreitete, aber eben inoffizielle Paketquellen für Zusatzpakete angeht. Alleine schon die Trennung über mehrere Einzel-Repos anstelle des zentralen AUR-Verzeichnisses ist schon ein Vorteil.

Der Abschied von Arch Linux fällt mir schwer. Ich empfinde das Rolling-Release-Modell äußerst attraktiv. Arch Linux hat über mehrere Jahre sehr gut für mich funktioniert. Aber ich werde auch in Zukunft nicht ganz ohne externe Pakete auskommen. Mit AUR habe ich mir die Finger einmal verbrannt. Diese Art der Verwaltung externer Pakete ist vielleicht doch zu liberal; Paketmanager wie yay oder paru verschleiern das Risiko zu sehr. Ein zweites Mal will ich dieses Risiko nicht eingehen.

Quellen, Links

• https://ioctl.fail/preliminary-analysis-of-aur-malware/
• https://github.com/lenucksi/aur-malware-check (Test-Scripts, ob Sie betroffen sind)
• https://kofler.info/infos-zur-arch-linux-attacke

Am 11.6. 2026 entdeckten Sicherheitsforscher kompromittierte AUR-Pakete in Arch Linux (AUR = Arch User Repository). Zwischenzeitlich waren ca. 1600 AUR-Pakete betroffen.

AUR-Pakete sind nicht offizielle Zusatzpakete, die kein dezidiertes Prüfverfahren durchlaufen. Die Installation erfolgt häufig über einsteigerfreundliche Tools wie yay oder paru. Der Angriff erfolgte durch die Modifizierung der PKGBUILD-Dateien von Paketen, die als verwaist (orphaned) galten, für die es also keinen Maintainer mehr gab. Aufgrund der veränderten PKGBUILD-Datei wurde zusätzlich zum Paket Schadsoftware installiert.

Ziel des Angriffs ist offensichtlich das Einsammeln von Passwörtern aus Firefox- und Chromium-basierten Browsern sowie von SSH-Keys und anderer sensibler Daten. Die Informationen dazu sind noch spärlich.

Ob ich selbst betroffen bin, kann ich aktuell nicht mit Sicherheit sagen; auf meinem Linux-Notebook habe ich zwei oder drei Tage vor Bekanntwerden das letzte Update durchgeführt. Vorerst habe ich das Gerät stillgelegt und den heutigen Morgen damit verbracht, potentiell betroffene SSH-Keys von diversen Server, GitHub- und GitLab-Accounts zu entfernen :-( An einer Neuinstallation wird kein Weg vorbeiführen.

Detaillierte Informationen finden Sie hier:

• https://ioctl.fail/preliminary-analysis-of-aur-malware/
• https://www.sonatype.com/blog/atomic-arch-npm-campaign-adds-malicious-dependency
• https://cybersecuritynews.com/arch-linux-aur-packages-compromised/
• https://linuxnews.de/massiver-angriff-auf-das-aur-ueber-400-pakete-kompromittiert/
• https://lists.archlinux.org/archives/list/aur-general@lists.archlinux.org/thread/FGXPCB3ZVCJIV7FX323SBAX2JHYB7ZS4/ (Diskussion auf dem Arch-Linux-Forum)
• https://md.archlinux.org/s/SxbqukK6IA (Liste der betroffenen Pakete, inoffiziell, Stand 13.6.2026)
• https://github.com/lenucksi/aur-malware-check (Test-Scripts, ob Sie betroffen sind)

Weitere Links

• https://www.heise.de/news/Angriffswelle-auf-Arch-Linux-Hunderte-Paketbeschreibungen-mit-Malware-im-AUR-11330029.html
• https://www.phoronix.com/news/Arch-Linux-AUR-More-Than-1500
• https://www.archlinux.de/news/35807-Aktuelle-Aktivitaeten-schaedlicher-Pakete-im-AUR (spärliche Informationen)
• https://wiki.archlinux.org/title/Arch_User_Repository (Erklärung, was AUR-Pakete sind)

Im April oder Mai 2026 habe ich einen denkwürdigen Meilenstein erreicht: Laut meinen Aufzeichnungen wurden eine Million meiner Bücher verkauft. Ein guter Anlass für einen beruflichen Rückblick und ein Dankeschön!

Die erste Million fällt zufälligerweise mit einem anderen Jubiläum zusammen: Vor 40 Jahren habe ich mit der Arbeit an meinem ersten Buch begonnen, dem Atari ST Grafikbuch (mehr Details hier). Dieses Buch war ein Mittelding zwischen Abenteuer, Hobby und Ferialjob. Nie hatte ich damals gedacht, dass das Schreiben zu meinem Beruf werden könnte.

Während meines Elektrotechnik-Studiums folgten weitere Bücher zu GfA-Basic, Visual Basic und Mathematica (ein Computer-Algebra-Programm). Die Bücher habe ich überwiegend in den Sommerferien geschrieben. Charakteristisch für diese Zeit war meine grenzenlose Begeisterung für die IT:

• Der erste, zweite, dritte Computer! (1984: Oric 1, 1986: Atari ST, vermutlich 1990: der erste PC von Vobis)
• Das erste Programm in Maschinencode (6502) bzw. Assembler (Motorola 68000)!
• GfA-Basic, ein für die damalige Zeit modernes Basic samt vernünftigem Editor.
• Dann Visual Basic! Mir war sofort klar, welches Potenzial diese (beinahe erste) grafische IDE hatte.
• Mathematica! Da hatte ich jahrelang Mathematikvorlesungen besucht, integrieren und Differenzialgleichungen lösen gelernt, und plötzlich gab es ein Programm, das symbolisch rechnen konnte! Aus damaliger Perspektive war das so eindrucksvoll wie vor wenigen Jahren das erste Mal ChatGPT auszuprobieren.

Ich empfand es großartig, diese Programme erkunden und dokumentieren zu dürfen — und damit auch noch Geld zu verdienen. Software mit all ihren Stärken und Schwächen zu beschreiben, wie sie in der Praxis wirklich funktionierten. (Halten Sie sich die Zeit vor Augen: Es gab damals noch kein öffentlich zugängliches Internet. Die einzige Dokumentation war ein mitgeliefertes, meist miserables Handbuch. Vereinzelt noch Zeitschriftenartikel.)

Erst mit Abschluss von Studium und Zivildienst stellte sich die Frage: Weiter schreiben oder einen »richtigen« Beruf ergreifen? Ich entschied mich für die Selbstständigkeit — und hatte Glück: Zwei, drei Jahre später überschritt ich mit Visual Basic 3 zum ersten Mal die 10.000-Stück-Auflage.

Aus meiner Sicht begann damals ein goldenes Zeitalter. Das Interesse an der IT war riesig, und ich hatte (zumindest manchmal) einen guten Riecher für die spannendsten Themen. Für wenige Jahre war ich Bestseller-Autor, zumindest im Maßstab von IT-Büchern.

Eine erste berufliche Zeitenwende war das Internet. Plötzlich gab es kostenlose, stets aktuelle Information — eine gewaltige Konkurrenz zu Büchern. Die Verkaufszahlen sanken, aber der Internet-Hype, stets neue Programmiersprachen, der Durchbruch von Open-Source-Software schufen gleichzeitig neue Möglichkeiten.

Die Ausgesetztheit und das Risiko des selbstständigen Arbeitens wurden mir erstmals 2013 vollständig klar. Addison-Wesley, der Verlag, für den ich über 20 Jahre praktisch exklusiv geschrieben hatte, wurde innerhalb von Monaten abgewickelt und geschlossen. Ich hatte damals den Verdacht, dass die Zeit der IT-Bücher vorbei wäre. Erfreulicherweise fand ich beim Rheinwerk Verlag (ehemals Galileo Press) eine neue Heimat und bin dort sehr glücklich (siehe auch hier).

Mit ChatGPT & Co. hat ein neuer Umbruch begonnen: KI-Tools stellen die ganze IT-Branche auf den Kopf und verkleinern das Zielpublikum für Coding-Bücher dramatisch. Natürlich ergeben sich auch damit neue Chancen. Unser Buch Coding mit KI steckt ab, was aktuell technisch möglich ist — und das ist absolut faszinierend! In gewisser Weise schließt sich mit dem Thema »Künstliche Intelligenz« der Kreis dieses Rückblicks: Die Faszination, die ich als Jugendlicher für die ersten Computer empfand, ist nach wie vor da. Heute richtet sie sich auf die Möglichkeiten, die KI-Tools bieten. Was wird morgen kommen?

Danke!

Leserinnen und Leser: Hätten Sie nicht immer wieder meine Bücher gekauft, auf Amazon hoch bewertet und in Ihrem beruflichen und privaten Umfeld weiterempfohlen, wäre mein berufliches Dasein nicht möglich gewesen. Danke, danke, danke!

Verlag/Lektorat/Herstellung: Ich schreibe meine Bücher selbst (im KI-Zeitalter ist das ja nicht mehr selbstverständlich), aber ein Buch entsteht doch nie alleine. Einen ganz wesentlichen Einfluss hat der Verlag und dort speziell das Lektorat. Es spricht bei der Planung des Buchs, bei der inhaltlichen Ausrichtung, der Korrektur, dem Layout, dem Titelbild, beim Marketing und der Werbung mit. Ohne die Mithilfe des Verlags sind erfolgreiche Bücher praktisch unmöglich.

Im Verlauf von vier Jahrzehnten hatte ich durchwegs großartige und engagierte Lektorinnen und Lektoren, von denen ich die wichtigsten hier namentlich nennen möchte: Norbert Hesselmann (der Lektor meines ersten Buchs, Sybex), Irmgard Wagner und Boris Karnikowski (beide prägten meine Zeit bei Addison-Wesley) sowie Sebastian Kestel und Christoph Meister (beide waren/sind im Rheinwerk Verlag tätig).

Eine besondere Rolle im Verlag nimmt die Herstellung ein: Diese Abteilung des Verlags ist verantwortlich dafür, dass Bücher in ordentlichem Layout gesetzt und dann gedruckt werden, dass E-Books in allen erdenklichen Formaten zur Verfügung stehen usw. Aus historischen Gründen setze ich die meisten Bücher selbst, früher mit LaTeX, jetzt mit einem Docker-Setup bestehend aus Markdown, Pandoc und LuaTeX. Dass ich selbst setzen kann und darf, ist ein absoluter Sonderfall; ich bedanke mich ausdrücklich bei Norbert Englert (Rheinwerk Verlag) für seine Unterstützung.

Co-Autoren: Im Lauf der Zeit habe ich ein halbwegs solides IT-Wissen erworben, aber es gibt doch Grenzen :-) Viele meiner Bücher wären/sind ohne die Team-Arbeit mit Co-Autoren unmöglich. Die zahlreichen Kooperationen waren immer äußerst produktiv und für mich sehr lehrreich. Mit Bernd Öggl (erster gemeinsamer Titel 2004: PHP und MySQL) ist daraus sogar eine langjährige berufliche Zusammenarbeit und private Freundschaft entstanden.

Antworten auf Fragen, die Sie nie gestellt haben

Kann man vom Bücherschreiben leben? Normalerweise nicht, in meinem Fall schon. Die ersten Jahre war das Schreiben von Computer-Büchern ein Mittelding zwischen Hobby und einem netten Zuverdienst neben dem Studium. Danach wurde das Schreiben mein Beruf; seit über 30 Jahren sind Bücher meine Haupteinnahmequelle. Einige Jahre habe ich (für meine Begriffe) großartig verdient, die restliche Zeit ganz passabel.

Macht das wirklich Spaß? Ja! Je neuartiger das Thema, desto besser. (Die zehnte Überarbeitung eines Buchs ist zugegebenermaßen weniger lustig.) Ich bin ja nicht ausschließlich Autor, sondern unterrichte gelegentlich an einer Fachhochschule, entwickle Software und administriere Server. Aber bei weitem die liebste Tätigkeit ist für mich das Konzipieren eines neuen Buchs, das Recherchieren und Ordnen von Informationen, das Verfassen von verständlichen Anleitungen und Erklärungen. Noch ein Argument für das Schreiben: die freie Zeiteinteilung. Kurz und gut: Ich habe es immer als Privileg empfunden, vom Schreiben leben zu können.

Stimmt das mit der Million überhaupt? Ich bekomme je nach Verlag viertel-, halb- oder ganzjährig Abrechnungen mit Verkaufszahlen. Diese landen in einer großen LibreOffice-Calc-Datei. 95% der Million sind so belegt. Der Rest entfällt auf E-Books und Übersetzungen, für die ich zwar Geld, aber keine detaillierten Abrechnungen erhalten habe. Ich habe die Zahlen konservativ geschätzt, aber ich gebe zu: Ganz genau kann ich es nicht sagen. Vielleicht habe ich die Million schon im Februar erreicht, vielleicht ist es erst im Juli so weit. Ich denke, es spielt keine Rolle.

Welche Bücher haben sich am besten verkauft? Auf Platz eins steht natürlich mein Linux-Buch, dessen zahlreiche Auflagen fast ein Drittel zur Million beitrugen. Andere Bestseller waren Visual Basic, Raspberry Pi, Excel VBA, Hacking & Security und der Python-Grundkurs.

Wie geht es weiter? Wenn es nach mir geht: Auf zur nächsten Million! Realistisch gesehen haben IT-Fachbücher aber ihren Zenit überschritten. Speziell Programmiertitel kämpfen gegen die KI-Konkurrenz. IT-Studien leiden unter sinkenden Studentenzahlen. Konkret heißt das: Es wird Neuauflagen bzw. neue Bücher geben, solange Sie sie kaufen :-)

PS: Bitte nehmen Sie sich hin und wieder Zeit für eine kurze Rezension! Das ist ein Zeichen der Wertschätzung für mich und eine Orientierungshilfe für andere. Ja, auch wenn die Links zu Amazon von dieser Website verschwunden sind, gerne dort. Auf Amazon werden die Rezensionen nämlich gelesen, selbst von Leuten, die dort nicht bestellen.

Quellen/Links

• https://kofler.info/ueber/bibliografie
• https://kofler.info/ueber/uebersetzungen
• https://kofler.info/30-jahre-linux-buch
• https://kofler.info/10-jahre-beim-rheinwerk-verlag
• https://kofler.info/20-jahre-linux-buch
• https://kofler.info/30-jahre-buchautor

Vor gut zweieinhalb Jahren habe ich hier über pip-Probleme berichtet, die unter aktuellen Ubuntu- und Debian-Systemen aufgetreten sind: externally-managed-environment (PEP 668) verhinderte lokale pip-Installationen wegen Konflikten zwischen System-Paketen. Die damals beschriebenen Lösungen, insbesondere das Einrichten eines virtuellen Environments, funktionieren weiterhin.

Aber inzwischen gibt es eine bessere Option: uv ist ein schneller, moderner Paketmanager für Python, der pip, venv, pipx und noch einige andere Tools auf einmal ersetzt. Wer regelmäßig Python-Module installiert, sollte sich die paar Minuten nehmen, uv kennenzulernen. Es lohnt sich.

Update 8.6.2026: uv und Cron

Update 31.7.2026: uv 0.12 mit neuem Init-Verhalten (src-Verzeichnis)

Das pip-Problem

Zuerst eine kurze Wiederholung meines alten Artikels: Bei immer mehr Linux-Distributionen verhindert PEP 668, dass pip install systemweit Pakete installiert. Stattdessen erscheint die Fehlermeldung externally-managed-environment. Es gibt zwei Auswege: entweder installieren Sie das Python-Modul als Distributionspaket (falls verfügbar), oder sie richten ein Virtual Environment, also ein projektspezifisches Verzeichnis mit eigenen, isolierten Modul-Installationen.

Das Einrichten eines Virtual Environments mit python3 -m venv .venv ist nicht schwierig, aber umständlich. Man muss es bei jedem neuen Terminal-Fenster aktivieren (source .venv/bin/activate oder eine Variante dieses Kommandos für Zsh, Fish oder PowerShell), eine requirements.txt pflegen und bei der Weitergabe des Projekts dem Empfänger erklären, was er zu tun hat. uv macht das alles einfacher.

Was ist uv?

uv ist in der Programmiersprache Rust entwickelt worden und stammt von der Firma Astral. Im März 2026 hat OpenAI Astral übernommen; das Team arbeitet seitdem in der Codex-Abteilung. Ob und wie das die Weiterentwicklung von uv beeinflusst, ist noch nicht absehbar. Das Projekt bleibt aber Open Source (https://github.com/astral-sh/uv).

Was uv von pip unterscheidet:

• Es ersetzt pip, venv, pip-tools, pipx und pyenv in einem einzigen Binary.
• Es ist laut eigenen Benchmarks 10- bis 100-mal schneller als pip.
• Es verwaltet Abhängigkeiten in pyproject.toml und einer Lock-Datei. Das manuelle Pflegen von requirements.txt ist damit vorbei.

Allein im Februar 2026 wurde uv über 126 Millionen Mal heruntergeladen. Es hat sich als De-facto-Standard für neue Python-Projekte etabliert. Auch bei meinen eigenen Python-Projekten ist uv inzwischen eine Selbstverständlichkeit geworden. Das Kommando ist einfach zu bedienen und funktioniert gut.

uv installieren

uv wird unabhängig von Python installiert. Unter macOS gelingt das am einfachsten mit Homebrew:

brew install uv

Bei manchen Linux-Distributionen steht uv als Paket zur Verfügung (apt install uv, dnf install uv). Falls nicht, funktioniert dieses Vorgehen:

curl -LsSf https://astral.sh/uv/install.sh -o uv_install.sh
less uv_install.sh   # kurze Kontrolle
sh uv_install.sh

Das Script gibt am Ende Hinweise, wie .local/bin zur PATH-Variablen hinzuzufügen ist. Unter Windows führen Sie folgende PowerShell-Kommandos aus:

powershell -ExecutionPolicy ByPass `
    -c "irm https://astral.sh/uv/install.ps1 | iex"

$env:Path = "C:\Users\<accountname>\.local\bin;$env:Path"

Nach der Installation überzeugen Sie sich kurz davon, dass alles geklappt hat:

uv --version

  uv 0.11.19 (...)

Updates führen Sie mit brew upgrade uv (macOS) bzw. durch Wiederholung des Installations-Kommandos durch.

Weitere Installationstipps finden Sie auf der GitHub-Seite.

Neues Projekt einrichten

Nehmen wir an, Sie entwickeln ein Script, das die Module requests und beautifulsoup4 benötigt. Die folgenden Kommandos richten das Projekt ein:

uv init my-webscraper   # erzeugt das Projektverzeichnis
cd my-webscraper        # dorthin wechseln
uv add requests beautifulsoup4  # Module installieren

Falls es schon ein Projektverzeichnis gibt, wechseln Sie mit cd dorthin und führen uv init . aus. uv init erzeugt ein Projektverzeichnis mit folgender Struktur:

my-webscraper/
├── .gitignore
├── .python-version
├── .venv/
├── main.py
├── pyproject.toml
└── README.md

uv init kümmert sich also um das Virtual Environment im Verzeichnis .venv. uv add installiert das gewünschte Modul und trägt es in pyproject.toml ein.

Hinweis: Die Datei .gitignore wird nicht erzeugt bzw. verändert, wenn das aktuelle Verzeichnis bereits unter Git-Kontrolle steht. In diesem Fall sollten Sie selbst in .gitignore eine Regel einbauen, die das Verzeichnis .venv ignoriert.

Ihr Script führen Sie mit uv run aus:

uv run main.py

uv run sorgt dafür, dass die richtige Python-Version und das Virtual Environment aktiv sind. Sie müssen sich um nichts weiter kümmern.

Weitere Module fügen Sie mit uv add hinzu, überflüssige entfernen Sie mit uv remove. Normalerweise verwendet uv einfach die gerade installierte Python-Version. Wenn Sie ausnahmsweise für ein Projekt eine andere Version benötigen, installieren und fixieren Sie diese:

uv python install 3.12
uv python pin 3.12

Projektweitergabe

uv pflegt mehrere Dateien für die Projektverwaltung:

• pyproject.toml enthält die Abhängigkeiten des Projekts.
• uv.lock enthält die exakten Versionsnummern aller installierten Module.
• .python-version enthält die gewünschte Python-Version.

Wenn Sie Ihr Projekt weitergeben oder auf einem anderen Rechner einsetzen möchten, geben Sie neben dem Quellcode die ersten beiden Dateien weiter, falls die Python-Version wichtig ist, auch die dritte. Die Empfängerin kann das Projekt dann sofort ausführen:

uv run main.py

uv erkennt pyproject.toml und uv.lock, richtet das Virtual Environment ein und installiert alle erforderlichen Module — vollautomatisch, ohne weitere Anweisungen.

Ältere Projekte mit requirements.txt

Bei bestehenden Projekten, die noch requirements.txt verwenden, bietet uv ebenfalls Unterstützung:

uv venv                             # Virtual Environment einrichten
uv pip install -r requirements.txt  # Abhängigkeiten installieren

Bestehende Projekte auf uv migrieren

Wer ein vorhandenes Projekt von pip auf uv umstellen möchte, beginnt mit uv init --bare im Projektverzeichnis. Das Flag --bare verhindert, dass Beispieldateien erzeugt oder vorhandene Dateien überschrieben werden. Als Ergebnis erscheint eine minimale pyproject.toml. Im nächsten Schritt importieren Sie die bisherigen Abhängigkeiten aus requirements.txt:

cd my-project
uv init --bare
uv add -r requirements.txt

uv add -r requirements.txt trägt alle Module in pyproject.toml ein und erzeugt gleichzeitig uv.lock mit den exakten Versionsnummern. Mit uv sync installiert uv anschließend alle Module in einem neuen .venv-Verzeichnis — ohne manuelles Aktivieren der Umgebung. Ab jetzt führen Sie Ihr Script mit uv run aus.

Nach erfolgreicher Migration geben Sie künftig pyproject.toml und uv.lock weiter — requirements.txt können Sie löschen. Falls CI-Systeme oder Docker-Builds weiterhin eine requirements.txt benötigen, lässt sie sich jederzeit automatisch aus der Lock-Datei erzeugen:

uv export --format requirements-txt > requirements.txt

Python-Tools global installieren

uv ersetzt auch pipx: Mit uv tool install installieren Sie in Python entwickelte Kommandozeilen-Tools direkt auf Ihrem Rechner, außerhalb eines Projektverzeichnisses. Die Tools landen in .local/share/uv/tools, Links dazu werden in .local/bin angelegt:

uv tool install httpie

httpie --version
  3.2.4

Noch praktischer ist uvx: Damit führen Sie ein Tool aus, ohne es permanent zu installieren. uv lädt die erforderlichen Dateien in ein Cache-Verzeichnis und führt das Tool sofort aus — ideal für die gelegentliche Nutzung:

uvx ruff check .   # überprüft alle Python-Dateien im Verzeichnis

Mit uv cache clean löschen Sie bei Bedarf die zwischengespeicherten Dateien.

uv und Cron

Wer ein Python-Script per Cron automatisch ausführen möchte, stößt auf zwei Probleme: Erstens ist uv häufig lokal installiert, meist in .local/bin/uv. Cron verwendet eine minimale PATH-Variable und findet das Kommando uv daher nicht. Zweitens setzt uv run voraus, dass das aktuelle Verzeichnis das Projektverzeichnis ist — das ist beim Aufruf per Cron ebenfalls nicht der Fall.

Theoretisch könnten Sie beide Probleme durch die Angabe absoluter Pfaden in der crontab-Datei lösen. Eleganter ist es aber, ein kleines Wrapper-Script zu schreiben:

# Datei /home/user/myproject/run.sh
cd /home/user/myproject
/home/user/.local/bin/uv run main.py

Dieses Script rufen Sie dann aus Cron auf:

# /etc/crontab
0 8 * * * user /home/user/myproject/run.sh

user ersetzen Sie jeweils durch Ihren Benutzernamen. Vergessen Sie nicht, das Script ausführbar zu machen (chmod +x run.sh).

uv 0.12 mit geändertem Init-Verhalten

Mit Version 0.12 hat sich das Verhalten von uv init geändert. Bisher hat uv init einfach main.py eingerichtet. Jetzt ist die Default-Verzeichnisstruktur verschachtelt:

tree
.
├── pyproject.toml
├── README.md
└── src
    └── <projektname>
        └── __init__.py

Wenn Sie also uv init my-project aufrufen, erzeugt uv das Verzeichnis src/my-project und speichert dort __init__.py. Den resultierenden Start-Code in __init__.py können Sie nun mit uv run my-project aufrufen. Die Verzeichnisstruktur entspricht den Python-Empfehlungen für Module.

Die src-Verschachtelung mag für große Projekte zweckmäßig sein. Wenn Sie mit uv ein kleines Script einrichten, ist die Verschachtelung aber unnötig. Es hindert Sie niemand daran, weiterhin direkt im Projektverzeichnis my-script.py einzurichten und dieses mit uv run my-script.py auszuführen.

Quellen/Links

• https://peps.python.org/pep-0668
• https://docs.astral.sh/uv
• https://docs.astral.sh/uv/guides/migration/pip-to-project/
• https://github.com/astral-sh/uv
• https://github.com/astral-sh/uv/releases/tag/0.12.0
• https://docs.python.org/3/tutorial/modules.html#packages
• https://simonwillison.net/2026/Mar/19/openai-acquiring-astral
• https://dasroot.net/posts/2026/05/uv-openai-python-supply-chain-acquisition-risks/
• https://kofler.info/hilfe-pip-funktioniert-nicht-mehr/

Wer mein Linux-Buch gelesen hat weiß, dass ich nicht im Vi-Lager zuhause bin, sondern zu den Emacs-Fans zähle. Beim Programmieren verwende ich diverse Editoren und IDEs, von VSCode über IntelliJ bis hin zu Xcode. Aber längere Texte (sprich: Bücher) schreibe ich seit Jahrzehnten ausschließlich mit dem Emacs. Ich habe ein paar halbherzige Versuche mit anderen Editoren gemacht, aber ich bin immer wieder zurückgekommen.

Meine Emacs-Liebe hat weniger mit der Großartigkeit dieses Programms zu tun als viel mehr damit, dass ich mir im Laufe der Zeit ein eigenes Setup mit Tastenkürzeln und Zusatzfunktionen gebastelt habe. Davon bin ich jetzt abhängig, meine Finger wollen sich nicht mehr umgewöhnen.

Die Motivation für diesen Blogbeitrag ist die immer wiederkehrende Frage, womit ich meine Markdown-Texte verfasse. Vielleicht finden andere Emacs-Fans in der nachfolgenden .emacs-Datei Ideen, die sie noch nicht kennen; vielleicht schreibt mir auch jemand im Forum, welches Feature ich bisher übersehen habe.

Dieser Beitrag ist aber keinesfalls ein Versuch, Sie vom Emacs zu überzeugen. Ein Neustart heute bei Null — da würde ich höchstwahrscheinlich bei einem deutlich moderneren Programm landen (möglicherweise bei zed). Dieser Text will Ihnen auch nicht meine Tastenkürzel aufzwingen. Die sind im Laufe der Zeit eher zufällig entstanden. Aber dieser Teil von .emacs lässt sich ja am einfachsten anpassen.

Die Datei .emacs

Die Konfiguration des Emacs erfolgt in der Datei .emacs. Die Anweisungen dort müssen in der Programmiersprache Elisp formuliert werden. Das ist die Emacs-Variante der heute ansonsten kaum noch gebräuchlichen Sprache Lisp. Früher war Elisp eine Hürde für viele Emacs-Einsteiger, und in einigen frühen Auflagen meines Linux-Buchs hatte ich sogar ein kurzes Elisp-Kapitel untergebracht. Heute sagen Sie Claude oder einem anderen KI-Tool, was Sie erreichen wollen, schon bekommen Sie den erforderlichen Code. (Manchmal klappt es erst im zweiten oder dritten Versuch.) Dank KI ist die Elisp-Syntaxhürde also überwunden.

Der Emacs liest .emacs automatisch beim Start. Spätere Änderungen gelten daher erst mit dem nächsten Start oder indem Sie die geänderten Zeilen markieren und mit Alt+X eval-region Return ausführen.

Meine Konfiguration

Die ersten Zeilen im folgenden Listing aktivieren einige allgemeine Einstellungen. cua-mode erlaubt die vertrauten Tastenkürzel Strg+C, Strg+X und Strg+V für Kopieren, Ausschneiden und Einfügen. Im originalen Emacs gibt es dafür andere Kürzel, die parallel aktiv bleiben. save-place-mode bewirkt, dass der Emacs die letzte Cursor-Position in jeder geöffneten Datei dauerhaft speichert. Damit das Arbeitsverzeichnis nicht mit Backup-Dateien übersät wird, landen Emacs-Backups gesammelt in ~/.emacs.d/backups/.

Moderne Emacs-Konfigurationen laden Erweiterungspakete über package.el nach. Das Standard-Repository des Emacs enthält nur wenige Pakete; deshalb binde ich MELPA ein, das mit Abstand größte Community-Repository mit Tausenden von Erweiterungen. Beim ersten Start auf einem neuen Rechner aktualisiert der Emacs automatisch die Paketliste (package-refresh-contents), sodass alle benötigten Pakete sofort installiert werden können.

Das Makro use-package bündelt je ein Paket zusammen mit seiner Konfiguration, Hooks und Tastenkürzel-Bindungen in einem einzigen Block. Die Einstellung use-package-always-ensure t sorgt dafür, dass fehlende Pakete automatisch nachinstalliert werden, ohne manuelles Eingreifen.

Der markdown-mode aus dem gleichnamigen Paket steht im Zentrum des Setups. Der Modus hebt Markdown-Syntax farbig hervor und aktiviert über Hooks mehrere Begleitmodi: visual-line-mode sorgt für weiche Zeilenumbrüche ohne harte Zeilenenden in der Datei, display-line-numbers-mode blendet Zeilennummern ein, und visual-fill-column-mode begrenzt die Textbreite auf 100 Zeichen.

adaptive-wrap ist ein kleines, aber feines Detail: Wenn eine Zeile weich umgebrochen wird, rückt die Folgezeile so ein, dass Listenelemente (* oder -) korrekt untereinander ausgerichtet bleiben. unfill ergänzt den eingebauten Befehl fill-paragraph (bei mir F4): Statt einen Absatz auf mehrere kurze Zeilen zu verteilen, fasst unfill-paragraph alle Zeilen eines Absatzes wieder zu einer einzigen langen Zeile zusammen. Das ist hilfreich, wenn Markdown-Quellen von anderen Tools weiterverarbeitet werden.

Das Paket vertico erweitert den Emacs-Minibuffer um eine vertikale Auswahlliste (siehe den folgenden Screenshot). Beim Wechsel zwischen Buffern (F1) sehe ich alle offenen Dateien auf einen Blick inklusive Dateigröße, Modus und Pfad — letzteres dank marginalia, das die Listeneinträge um nützliche Zusatzinformationen ergänzt. orderless macht die Suche komfortabler: Ich kann mehrere Suchbegriffe mit Leerzeichen trennen und in beliebiger Reihenfolge eingeben.

Die benutzerdefinierte vertico-sort-override-function ändert die Sortierreihenfolge im Buffer-Switcher: Statt alphabetischer Reihenfolge erscheinen die zuletzt verwendeten Buffer ganz oben in der Liste. Bei vielen Dateien finde ich die zuletzt verwendeten Datei schneller.

swap-char (F11) vertauscht die zwei Zeichen an der Cursor-Position. Tippfehler wie getsern statt gestern lassen sich damit sofort korrigieren: Cursor auf das erste falsche Zeichen, einmal F11, fertig.

change-case (F12) wechselt die Groß- bzw. Kleinschreibung des Zeichens unter dem Cursor. change-word-case (F9) tut dasselbe für den ersten Buchstaben des aktuellen Worts, unabhängig davon, wo im Wort der Cursor gerade steht.

point-to-register-1 (F5) / jump-to-register-1 (F6): Mit F5 speichere ich die aktuelle Position, mit F6 springe ich dorthin zurück. Beim Sprung wird gleichzeitig die neue Position gespeichert, sodass ich mit wiederholten F6-Drücken zwischen zwei weit entfernten Textstellen hin- und herspringen kann. Ich finde das praktisch, wenn ich parallel an zwei Stellen eines langen Dokuments arbeite.

expand-abbrev-or-dabbrev (F3) versucht zunächst, eine gespeicherte Abkürzung zu expandieren. In .abbrevs_defs habe ich einige solche Abkürzungen gespeichert, z.B. ms für »Microsoft« oder rhel für »Red Hat Enterprise Linux«. Falls keine passt, greift dabbrev-expand und vervollständigt das angefangene Wort anhand von Vorkommen im selben Buffer. Praktisch für lange Schlüsselwörter.

Beim Einlesen der .emacs-Datei lädt der Editor automatisch alle erforderlichen Pakete herunter. Wenn dabei Download-Fehler auftreten, müssen Sie eventuell den MELPA-Cache aktualisieren. Dazu führen Sie Alt+X package-refresh-contents Return aus und starten den Emacs dann neu.

;; Datei ~/.emacs

;; ======== Grundeinstellungen ====================================

(cua-mode 1)                               ;Cut&Paste mit Strg+C/X/V
(setq inhibit-startup-message t)           ;kein Emacs-Startbildschirm
(setq screen-preserve-screen-position t)   ;zurück zur letzten Zeile
(setq scroll-step 5)                       ;bei Scrollen Sprünge von 5 Zeilen
(column-number-mode 1)                     ; ... Spaltennummern in der Statusleiste
(abbrev-mode 0)                            ;kein automatisches expand-abbrev
(setq require-final-newline t)             ;letzte Zeile automatisch mit Return abschließen
(save-place-mode)                          ;Cursor-Position innerhalb der Datei merken

;; automatische Backups nicht im lokalen Verzeichnis, sondern in ~/.emacs.d/backups/
(setq backup-directory-alist
      `(("." . ,(concat user-emacs-directory "backups"))))
(setq auto-save-file-name-transforms
      `((".*" ,(concat user-emacs-directory "backups/") t)))

;; Spaltenbreite für Zeilennummern (nur Markdown)
(setq-default display-line-numbers-width 4)

;; Abkürzungstabelle automatisch laden und speichern
;; Falls ~/.abbrev_defs nicht existiert, leere Datei anlegen (kein Fehler)
(let ((abbrev-file "~/.abbrev_defs"))
  (unless (file-exists-p abbrev-file)
    (write-region "" nil abbrev-file))
  (read-abbrev-file abbrev-file))
(setq save-abbrevs t)                      ;automat. speichern


;; ======== Packages ================================================

;; package.el initialisieren und MELPA-Repo hinzufügen (falls erforderlich)
(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
(package-initialize)

;; Paket-Repo aktualisieren (first run / new machine)
(when (not package-archive-contents)
  (package-refresh-contents))

;; alle erforderlichen Pakete automatisch laden
(unless (package-installed-p 'use-package)
  (package-install 'use-package))
(require 'use-package)
(setq use-package-always-ensure t)

;; scratch-Buffer automatisch speichern (https://github.com/Fanael/persistent-scratch)
(use-package persistent-scratch
  :config
  (persistent-scratch-setup-default))

;; weiche Zeilenumbrüche mit Einrückung bei Listen etc.
(use-package adaptive-wrap
  :hook (visual-line-mode . adaptive-wrap-prefix-mode))

;; Spalte mit Zeilennummern / zentrierter Text
(use-package visual-fill-column
  :hook (markdown-mode . visual-fill-column-mode)
  :config
  (setq-default visual-fill-column-width 100)
  (setq visual-fill-column-width 100))

;; Markdown-Modus
(use-package markdown-mode
  :mode (("\\.text\\'" . markdown-mode)
         ("\\.md\\'"   . markdown-mode))
  :hook ((markdown-mode . visual-line-mode)          ; soft-wrap long lines
         (markdown-mode . display-line-numbers-mode) ; show line numbers
         (markdown-mode . visual-fill-column-mode)   ; center text within column width
         (markdown-mode . (lambda () (setq fill-column 79))))) ; hard-wrap at 79 chars

;; Unfill: mehrzeilige Absätze zu einer langen Zeile verbinden (Shift+F4)
(use-package unfill)

;; mehr Komfort im Minibuffer
(use-package vertico
  :config
  (vertico-mode 1)
  ; sort buffer list by 'recently shown'
  (setq vertico-sort-override-function
        (lambda (candidates)
          (if (eq minibuffer-history-variable 'buffer-name-history)
              (let ((hist (symbol-value minibuffer-history-variable)))
                (sort candidates
                      (lambda (a b)
                        (let ((pa (or (cl-position a hist :test #'equal) most-positive-fixnum))
                              (pb (or (cl-position b hist :test #'equal) most-positive-fixnum)))
                          (< pa pb)))))
            candidates))))

(use-package orderless
  :config
  (setq completion-styles '(orderless basic)))
(use-package marginalia
  :config
  (marginalia-mode 1))


;; schönere Statuszeile (setzt voraus, dass die JetBrains Nerd Fonts
;; installiert und als Emacs-Font verwendet werden)
(use-package nerd-icons
  :config
  (setq nerd-icons-font-family "JetBrainsMono Nerd Font"))
(use-package doom-modeline
  :after nerd-icons
  :config
  (doom-modeline-mode 1)
  (setq doom-modeline-height 25)
  (setq doom-modeline-icon t))

;; Ligaturen (setzt ebenfalls einen Nerd Font voraus)
(use-package ligature
  :config
  (ligature-set-ligatures 't '("!=" "!==" "->" "<-" "=>" "<=>" ">=" "<=" "//"))
  (global-ligature-mode t))


;; ======== Farben ================================================

(set-face-attribute 'line-number nil
                    :height 0.8 :foreground "#ffffff" :background "#dddddd")
(set-face-attribute 'link nil
                    :foreground "RoyalBlue3" :underline nil)

;; für Markdown-Modus
(with-eval-after-load 'markdown-mode
  (set-face-attribute 'markdown-italic-face nil
                      :inherit 'italic :foreground "dark magenta" :slant 'italic)
  (set-face-attribute 'markdown-pre-face nil
                      :inherit 'font-lock-constant-face))

(with-eval-after-load 'doom-modeline
  (set-face-attribute 'doom-modeline-buffer-modified nil
                      :foreground "firebrick" :weight 'bold))


;; ======== eigene Funktionen ===================================================

(defun expand-abbrev-or-dabbrev ()    ;Expansion von Abkürzung: F3
  (interactive)
  (unless (expand-abbrev)             ;falls keine Abkürzung existiert
    (dabbrev-expand nil)))            ;dynamische Expansion

(defvar my-point-register 1
  "Hilfsvariable für jump-to-register-1: merkt sich, welches Register aktiv ist.")

(defun point-to-register-1 ()         ;Position in Reg. 1 speichern: F5
  (interactive)
  (setq my-point-register 1)
  (point-to-register 1))

(defun jump-to-register-1 ()          ;Position wechseln: F6
  (interactive)                       ;springt zur Position, die mit F5
  (if (= my-point-register 1)         ; gespeichert wurde ...
      (progn
        (setq my-point-register 2)
        (point-to-register 2)
        (jump-to-register 1))
    (progn
      (setq my-point-register 1)
      (point-to-register 1)
      (jump-to-register 2))))

(defun swap-char ()                   ;zwei Buchstaben an der Cursor-Position
  (interactive)                       ;vertauschen: F11
  (save-excursion
    (forward-char)
    (transpose-chars 1)))

(defun change-case ()                 ;Groß- und Kleinschreibung des Zeichens
  (interactive)                       ;an der Cursorposition ändern: F12
  (let ((zeichen (char-after (point))))
    (if (> zeichen 64)
        (progn
          (setq zeichen (logxor zeichen 32))
          (insert-char zeichen 1)
          (delete-char 1))
      (forward-char 1))))

(defun change-word-case ()            ;Groß- und Kleinschreibung des ersten
  (interactive)                       ;Zeichens eines Worts verändern: F9
  (point-to-register 2)
  (backward-word 1)
  (change-case)
  (jump-to-register 2))

(defun unfill-paragraph-and-advance () ;Absatz zusammenfügen und zum nächsten springen: S-F4
  (interactive)
  (unfill-paragraph)
  (forward-paragraph)
  (skip-chars-forward "\n")
  (recenter))

(defun toggle-fill-column-width ()     ;Zeilenumbruch zwischen 100 und 1000 Zeichen wechseln
  (interactive)
  (setq-local visual-fill-column-width
              (if (eq visual-fill-column-width 100) 1000 100))
  (visual-fill-column-mode 1))



;; ======== Tastenkürzel ======================================================

(global-set-key [f1]    'switch-to-buffer)             ;F1  Buffer wechseln
(global-set-key [f2]    'other-window)                 ;F2  Fenster wechseln
(global-set-key [f3]    'expand-abbrev-or-dabbrev)     ;F3  Abkürzung erweitern
(global-set-key [f4]    'fill-paragraph)               ;F4  Absatz umbrechen
(global-set-key [S-f4]  'unfill-paragraph-and-advance) ;S-F4 Absatz zusammenfügen + nächster
(global-set-key [f5]    'point-to-register-1)          ;F5  Position speichern
(global-set-key [f6]    'jump-to-register-1)           ;F6  zu Position springen
(global-set-key [f7]    'goto-line)                    ;F7  goto line
(global-set-key [f8]    'toggle-fill-column-width)     ;F8 kurze/lange Zeilen
(global-set-key [f9]    'change-word-case)             ;F9  Groß/Klein Wort
(global-set-key [f10]   'undo)                         ;F10 Undo
(global-set-key [f11]   'swap-char)                    ;F11 Buchst. vertauschen
(global-set-key [f12]   'change-case)                  ;F12 Groß-/Klein ändern

;; Mac-Tastatur: fn+ctrl+cursor to start/end of buffer
(global-set-key [C-prior] 'beginning-of-buffer)   
(global-set-key [C-next]  'end-of-buffer)

;; Guillemets-Eingabe mit Alt+Q / Shift+Alt+Q
(defun insert-guillemot1 ()
  (interactive)
  (insert "«"))
(defun insert-guillemot2 ()
  (interactive)
  (insert "»"))
(global-set-key [?\M-q] 'insert-guillemot1)            ;Alt+Q:       «
(global-set-key [?\M-Q] 'insert-guillemot2)            ;Shift+Alt+Q: »

;; macOS: rechte Alt-Taste zur Eingabe von Sonderzeichen wie @ oder € verwenden
(when (eq system-type 'darwin)
  (setq mac-right-option-modifier nil)                 ; LeftAlt + L -> @ etc.
  )

Quellen / Links

Die oben abgedruckte Datei können Sie als dotemacs.txt herunterladen.

• https://www.gnu.org/software/emacs/
• https://www.gnu.org/software/emacs/documentation.html
• https://www.gnu.org/software/emacs/manual/html_node/eintr/
• https://www.emacswiki.org
• https://github.com/chrisdone-archive/elisp-guide (Elisp Guide)
• https://en.wikipedia.org/wiki/Lisp_(programming_language)
• https://melpa.org/ (Erweiterungspakete)
• https://github.com/doomemacs/doomemacs (Emacs-Statuszeile)

Andere .emacs-Beispiele

• https://github.com/jackrusher/dotemacs
• https://sachachua.com/dotemacs/index.html
• https://protesilaos.com/emacs/dotemacs

Unser Buch Coding mit KI ist gerade erst erschienen, schon gibt es spannende Neuigkeiten rund um die Ausführung lokaler Modelle:

• Multi-Token Prediction (MTP) ist ein ganz neues Feature in llama.cpp. Seit ein paar Tagen steht es auch in LM Studio zur Verfügung. Durch einen »Trick« (Details folgen gleich) kann mit MTP die Output-Token-Geschwindigkeit deutlich vergrößert werden: laut diversen Benchmarktests im Internet bis auf das Doppelte, in meinen Tests immerhin um ca. 60 bis 70 Prozent.

• Adaptive Precision for EXpert Models (APEX) ist ein neues Verfahren zur besonders platzsparenden Quantisierung von MoE-Modellen. Der Platzbedarf sinkt je nach Qualitätsstufe auf die Hälfte gegenüber der herkömmlichen 4-Bit-Darstellungen (Q4_x_x).

• Qwopus ist eine neue Variante zu den Qwen-Modellen, bei denen das Fine Tuning mit Claude Opus verbessert wurde.

Von Speculative Decoding zur Multi-Token Prediction

In Coding mit KI gehe ich kurz auf das Vorgängerkonzept zu MTP ein, auf Speculative Decoding: Dabei führt die Engine (z.B. llama.cpp) zwei Sprachmodelle aus. Das kleinere (schnellere) dient als Draft Model. Während der Token-Generierung macht das Draft Model Vorschläge für die folgenden Token. Das größere, qualitativ bessere Modell überprüft anschließend eine Sequenz mehrerer vorgeschlagener Token auf einmal. Im Idealfall wird die ganze Sequenz akzeptiert. Der Geschwindigkeitsvorteil ergibt sich durch die parallele Verifizierung eines ganzen Token-Blocks. Dazu sind weniger Speicher-Transfers vom VRAM in die GPU notwendig, als wenn jedes Token für sich generiert wird. (Die Token-Generierung wird durch zwei Faktoren limitiert: die Rechenleistung der GPU und die Speicherbandbreite vom VRAM in die GPU-Cores. Speculative Decoding setzt beim zweiten Punkt ein, der oft der limitierende Faktor ist.)

In der Praxis funktioniert das nur mäßig gut: Zum einen ist es schwierig, ein geeignetes Draft Model zu finden. Es muss aus der gleichen »Familie« stammen, aber deutlich kleiner sein, idealerweise etwa um den Faktor zehn. Zum anderen funktioniert Speculative Decoding für Dense Models besser als für Mixture of Experts Models (MoE). Das Problem bei MoE besteht darin, dass bei jedem Token andere »Experten« zum Einsatz kommen können, was den Geschwindigkeitsvorteil von Speculative Decoding teilweise zunichtemacht. Kleinere MoE-Modelle für den Draft-Einsatz haben zudem oft eine andere Experten-Aufteilung, was die Acceptance Rate verringert.

Multi-Token Prediction (MTP) greift die Idee des Speculative Decoding auf. Der entscheidende Unterschied besteht darin, dass ein Modell ausreicht. Ein in das Modell integrierter Layer ist dafür zuständig, rasch ein paar Tokens (üblicherweise 2 bis 4) vorherzusagen. Das Gesamtmodell überprüft dann alle Token auf einmal, was nur unwesentlich mehr Zeit kostet, als ein Token zu berechnen. MTP erspart damit das umständliche Handling mit zwei Modellen.

Speculative Decoding und Multi-Token Prediction sind mit keinerlei Qualitätsverlust verbunden! Es werden exakt die gleichen Ergebnisse erzielt, weil jede Token-Sequenz vollständig kontrolliert und bei Abweichungen verworfen wird. Werfen Sie diesbezüglich einen Blick in das Video von Donata Capitella, das diesen Umstand anschaulich erklärt.

Für den erzielten Geschwindigkeitsgewinn ist der Prozentsatz der akzeptierten Draft Tokens entscheidend. Dieser variiert je Aufgabenstellung: Bei kreativem Text ist die Akzeptanzrate nur mittelmäßig, bei Code hingegen deutlich höher — ganz einfach deswegen, weil Code strengen Regeln folgt und weniger Spielraum als menschliche Sprachen bietet.

Leider ist auch MTP mit Nachteilen verbunden:

• Das Modell muss für MTP konzipiert sein. MTP muss schon beim Training berücksichtigt werden. Das Modell benötigt einen zusätzlichen Layer für die Token Prediction. Aktuell gibt es nur eine einzige »freie« Modellfamilie mit MTP, nämlich Qwen 3.6 und dessen Variante Qwopus. Gemma-4-Modelle sollten demnächst folgen. In Zukunft wird MTP wohl zu einem Standard-Feature für freie Modelle.

• Natürlich muss auch die Software MTP unterstützen. Weil viele Programme intern llama.cpp verwenden, wird MTP rasch weite Verbreitung finden.

• Schließlich teilt sich MTP einen Nachteil mit Speculative Decoding: Es funktioniert bei herkömmlichen Dense-Modellen besser als bei MoE-Modellen (Mixture of Experts). Die ohnedies schon schnellen MoE-Modelle werden also nur geringfügig schneller oder, wie bei einigen meiner Tests, sogar langsamer. Bei den Dense-Modellen ist dagegen eine spürbare Verbesserung zu bemerken. Bei meinen Tests ca. +65%, bei einigen Benchmarks im Internet bis zu +100%, also eine Verdoppelung der Output-Token-Rate.

• MTP ändert nichts an der Input-Verarbeitung (dem Prompt Processing, pp). Schneller wird nur der Output (die Token Generation, tg).

Dense versus Mixture of Experts (MoE): MoE ist schneller, kann aber qualitativ bei gleicher Modellgröße nicht ganz mithalten. Während bei Dense-Modellen immer alle Parameter aktiv sind, nutzen MoE-Modelle nur wenige, stets wechselnde »Experten«, also Subsets mit viel weniger Parametern. Das spart Zeit, aber kein »Experte« ist so gut wie das volle Modell. Dementsprechend sinkt die Qualität der Antworten, nicht massiv, aber spürbar.)

Praktische Erfahrungen

Ich habe MTP mit LM Studio 0.4.14 auf meinem Framework Desktop ausprobiert (AMD Ryzen Max 395 CPU/GPU). Mein Mini-Benchmarktests lautete: »Explain Python dictionaries«. Die getesteten Modelle denken über diese Frage eine Weile nach und produzieren dann einen mehrseitigen, qualitativ sehr hochwertigen Text mit eingebauten Code-Schnipseln.

Ich habe alle Tests mit einem Kontextfenster von 128.000 Token ausgeführt. Bei den MTP-Modellen habe ich die Einstellung MTP Max Tokens = 3 verwendet, also immer drei Tokens auf einmal erzeugt. Alle getesteten Modelle weisen eine 4-Bit-Quantisierung auf (Ausnahme: das APEX-Modell, siehe unten). Als Backend kommt llama.cpp mit Vulkan zum Einsatz.

                                                            Draft Token 
Modell                     MoE   APEX  MTP   Output (tg)    Acceptance
-----------------          ----  ----  ----  ------------   ------------------
qwen-3.6-27b               nein  nein  nein  12,3 Token/s
qwen-3.6-27b-mtp           nein  nein  ja    20,1 Token/s   66,3 %
qwopus-3.6-27b-v2-mtp      nein  nein  ja    19,0 Token/s   63,7 %

qwen-3.6-35b-a3b           ja    nein  nein  69,7 Token/s
qwen-3.6-35b-a3b-mtp       ja    nein  ja    67,1 Token/s   66,6 %
qwen-3.6-35b-a3b-apex-mtp  ja    ja    ja    71,5 Token/s   63,3 %
qwopus-3.6-35b-a3b-mtp     ja    nein  ja    74,2 Token/s   68,2 %

Professionellere Benchmark-Tests hat Donata Capitella durchgeführt (siehe die ersten zwei Links in den Übersicht der Quellen am Ende des Artikels). Interessanterweise ist dort auch bei MoE-Modellen ein spürbarer Geschwindigkeitszuwachs von etwa 30% zu sehen, den ich bei meinen Tests aber nicht nachvollziehen kann.

Qwopus-Modelle

Die neuen Qwopus-Modelle basieren auf Qwen-Modellen, erhalten aber ein zusätzliches Fine-Tuning mit Claude Opus. Dieses soll den Nachdenkprozess beschleunigen und eine bessere Antwortqualität mit sich bringen. Die erste Versprechung trifft definitiv zu, aber ich bin nicht in der Lage, die Qualität des Modells im Detail zu beurteilen. Subjektiv hatte ich den Eindruck, dass die Unterschiede zu den Qwen-Originalen gering sind.

Zum Denkprozess: Beim Prompt »write a Sudoku solver in Python« denkt qwen-3.6-27b-mtp ca. 1:30 Minuten nach, qwopus-3.6-27b-v2-mtp aber ca. nur 1:00 Minuten. (Die Denkzeit hat eine relativ starke Varianz, weswegen hier genaue Angaben sinnlos sind.) Die resultierende Antwort samt Code ist mehr oder weniger gleichwertig (Backtracking-Algorithmus).

APEX Quantisierung

Die Verkleinerung von Modellen bei möglichst geringen Qualitätsverlust ist zu einer eigenen KI-Disziplin geworden. Die Grundidee besteht darin, Milliarden von Parametern (also eigentlich Fließkommazahlen) mit möglichst wenigen Bits darzustellen, ohne dass die Qualität der Ergebnisse allzu sehr leidet.

Der geringere Platzbedarf von Modellen ist insbesondere dann wichtig, wenn der Speicher (VRAM) limitiert ist. Mit einer geschickten Quantisierung läuft ein Modell vielleicht gerade noch auf einer GPU mit 16 GiB VRAM.

Vor ein paar Monaten machte Google mit dem neuen Turbo-Quant-Verfahren Furore. Bei der Recherche für diesen Artikel bin ich nun auf das neue Verfahren Adaptive Precision for EXpert Models (APEX) gestoßen. Das von Local AI entwickelte Verfahren ist speziell für MoE-Modelle optimiert und kompatibel zu aktuellen llama.cpp-Versionen. Die Grundidee besteht darin, dass für jede Parametergruppe eine andere, für den Wertebereich und die Wichtigkeit angepasste Quantisierung verwendet wird. Insofern ist eine klare Bit-Angabe (4 Bit pro Parameter) unmöglich. Technische Details und Benchmarks finden Sie auf der GitHub-Projektseite. Local AI arbeitet daran, Modelle lokal auf Smartphones auszuführen; da ist die möglichst platzsparende Darstellung natürlich wichtig.

Konkret sind APEX-Modelle zum Teil wirklich erheblich kleiner als vergleichbare Modelle mit Q4-Quantisierung, wie sie bei der lokalen Ausführung von Modellen üblich ist. Die folgende Tabelle zeigt lauter Qwen-3.6-Modelle mit jeweils 35 Milliarden Parameter. Das APEX-MTP-Modell benötigt nur halb so viel Platz wie das MTP-Modell mit einer herkömmlichen Q4-Quantisierung.

Leider verrät die Huggingface-Seite des Modells nicht, welche Variante der APEX-Quantisierung verwendet wurde. Es existieren verschiedene Qualitätsstufen, z.B. Quality, Balanced, Compact und Mini. Ich würde vermuten, das Modell ist eher bei Mini als bei Quality angesiedelt.

Modell                      Quantisierung   Größe (Disk)
------------------------    -------------   ------------
qwen-3.6-35b-a3b            Q4_K_M          22,0 GB
qwen-3.6-35b-a3b-mtp        Q4_K_S          23,0 GB
qwen-3.6-35b-a3b-apex-mtp   APEX            11,7 GB (!)

Bei der Ausführung des Modells waren für mich keine nennenswerten Unterschiede erkennbar, weder in der Geschwindigkeit noch qualitativ. Aber nochmals: Das sind subjektive Feststellungen anhand einiger Tests, keine objektiven Benchmark-Tests. Dazu fehlt mir ganz einfach die Zeit.

Quellen/Links

• https://www.youtube.com/watch?v=MI0Pm1d6YF4 (gutes Video von Donata Capitella)
• https://kyuz0.github.io/amd-strix-halo-toolboxes/mtp.html (Benchmarks von Donata Capitella)
• https://sebastianraschka.com/llm-architecture-gallery/mtp/
• https://github.com/ggml-org/llama.cpp/pull/22673 (MTP für llama.cpp)
• https://lmstudio.ai/changelog/lmstudio-v0.4.14 (LM Studio Changelog)
• https://github.com/localai-org/apex-quant

Ausgewählte Modelle mit MTP und/oder APEX

• https://huggingface.co/unsloth/Qwen3.6-35B-A3B-MTP-GGUF (Qwen MTP)
• https://huggingface.co/Jackrong/Qwopus3.6-27B-v2-MTP-GGUF (Qwopus MTP)
• https://huggingface.co/Jackrong/Qwopus3.6-35B-A3B-v1-MTP-GGUF (ebenso)
• https://huggingface.co/mudler/Qwen3.6-35B-A3B-APEX-MTP-GGUF (APEX)

Technisch/Wissenschaftliche Grundlagen

• https://arxiv.org/abs/2211.17192 (Speculative Decoding)
• https://arxiv.org/abs/2404.19737 (MTP)
• https://arxiv.org/abs/2509.18362v1 (FastMTP)
• https://arxiv.org/abs/2412.19437 (MTP in DeepSeek-Modellen)
• https://blog.google/innovation-and-ai/technology/developers-tools/multi-token-prediction-gemma-4/ (MTP in Gemma-Modellen)

Wenn Sie Ihre Domains bei Hetzner verwalten, wurden Sie in den vergangenen Monaten dazu aufgefordert, die Domains in ein neues DNS-Verwaltungstool zu migrieren. Das gelingt zumeist problemlos (zumindest in meinen Fällen).

Allerdings hat Hetzner nun auch die alte API zur DNS-Administration abgeschaltet. Falls Sie bei der Ausstellung von Let’s-Encrypt-Zertifikate die alte DNS-API verwendet haben, scheitert die Erneuerung der Zertifikate mit unspezifischen Fehlern (invalid domain).

Ich verwende zur Zertifikatsausstellung normalerweise acme.sh und bin auf das Problem erst aufmerksam geworden, als das erste Zertifikat auf einem meiner Server abgelaufen ist. (Ein ordentliches Monitoring hätte dieses Hoppala natürlich verhindert. Es war nicht die wichtigste Domain …)

Ich habe keinen Weg gefunden, den Zertifiktaserneuerungsmechanismus von acme.sh irgendwie zu aktualisieren, also gewissermaßen die vorhandene Konfiguration auf die neue API zu migrieren. Die Lösung bestand darin, in der Hetzner-Console einen neuen API-Key einzurichten und dann mit acme.sh die Zertifikate neu auszustellen. Falls Sie viele Server administrieren, ist das, gelinde formuliert, unbequem …

Hinweis/Klarstellung: Sie sind von diesem Problem NICHT betroffen, wenn die Domain-Validierung mit anderen Verfahren erfolgt, z.B. durch das Ablegen einer Datei in /var/www/html. Dieser Blog-Artikel bezieht sich explizit auf den Zertifikatserneuerungsprozess, wenn Sie bisher die alte Hetzner-DNS-API verwendet haben! Ich verwende als Tool acme.sh, aber das Problem hat nichts mit acme.sh an sich zu tun, sondern mit der Frage, wie der Domain-Validierung erfolgt. Kommt dabei die alte Hetzner-DNS-API zum Einsatz, wird es Probleme geben.

API-Key

Zuerst brauchen Sie einen neuen API-Key für die Hetzner-Cloud-API. Den erstellen Sie in der Hetzner-Konsole unter Security / API-Tokens. Der Token muss read/write sein, weil acme.sh für die Validierung Ihrer Domain vorübergehend eine zusätzlichen DNS-Eintrag hinzufügt, die DNS-Konfiguration also ändert. Den vollständigen Token-Code können Sie nur einmal ansehen/kopieren.

Hetzner bietet aktuell keine Möglichkeit, die Gültigkeit des Keys irgendwie einzuschränken. Ein RW-Key gibt damit weit mehr Rechte, als zur DNS-Administration erforderlich wären. Die API bietet alle erdenklichen weiteren Funktionen (create a server, delete a server usw.). Dass der Key mit so vielen Rechten ausgestattet ist, macht mich nicht glücklich, aber es ist aktuell nicht zu ändern.

acme.sh aktualisieren, Zertifikate neu erstellen und einrichten

acme.sh muss das Verfahren Hetzner Cloud DNS API unterstützen. Dieses ist verhältnismäßig neu. Eventuell müssen Sie Ihre vorhandene acme.sh-Installation aktualisieren:

acme.sh --upgrade

Mit acme.sh --list gewinnen Sie einen Überblick, welche Zertifikate es auf dem Server gibt (Output verkürzt):

acme.sh --list

  Main_Domain         SAN_Domains              CA               Created     Renew
  eine-firma.de       www.eine-firma.de        LetsEncrypt.org  2026-05-12  2026-07-11
  mail.eine-firma.de  smtp.eine-firma.de,...   LetsEncrypt.org  2026-05-12  2026-07-11

Jetzt speichern Sie das Token in einer Umgebungsvariablen und wiederholen die Kommandos zur Zertifikatsausstellung sowie zum Kopieren der Zertifikate an den Zielort, wobei Sie die bisherige acme.sh-Option --dns dns-hetzner durch --dns dns-hetznercloud ersetzen.

Die folgenden Beispielkommandos zeigen die Neuausstellung der Zertifikate und deren Deployment. Sofern Sie exakt die gleichen Namen/Pfade wie bei der ursprünglichen Zertifikatsausstellung verwenden, sollte danach alles wieder funktionieren (d.h. der Webserver verwendet die neuen Zertifikate).

export HETZNER_Token='oqCF...'

# wichtig ist die geänderte Option --dns dns_hetznercloud
acme.sh --issue --dns dns_hetznercloud --server letsencrypt \
  -d eine-firma.de -d www.eine-firma.de

# Zertifikate in /etc/letsencrypt speichern (setzt voraus, dass
# Apache so konfiguriert ist, dass das Programm die Zertifikate
# von dort liest)
acme.sh --install-cert -d eine-firma.de \
        --cert-file      /etc/letsencrypt/eine-firma.de.cert \
        --key-file       /etc/letsencrypt/eine-firma.de.key \
        --fullchain-file /etc/letsencrypt/eine-firma.de.fullchain \
        --reloadcmd 'systemctl restart apache2'

Sie müssen die Kommandos natürlich an Ihre Gegebenheiten anpassen.

Quellen/Links

• https://github.com/acmesh-official/acme.sh/wiki/dnsapi2#dns_hetznercloud
• https://github.com/acmesh-official/acme.sh/issues/6554
• https://docs.hetzner.cloud/reference/cloud#description/getting-started
• https://www.hetzner.com/de/news/dns-beta/

Da ist Coding mit KI frisch aus der Druckerei ausgeliefert, schon taucht ein neues Tool auf, das mehr Effizienz verspricht. Graphify erstellt einen sogenannten Knowledge Graph, also eine interne Datenbank über die Verknüpfungen zwischen Komponenten (Text, Code, Bilder, was auch immer) eines Projekts. In der Folge können KI-Tools wie Claude Code auf diese Datenbank zugreifen und sich damit rascher und vor allem Token-sparender im Projekt orientieren. Graphify funktioniert besonders gut für ungeordnete Verzeichnisse, in denen Sie PDFs, Screenshots etc. zu einem Thema ablegen, um diese Informationen später wieder zu nutzen.

Aktualisiert 10.5.2026, 23.6.2026, 3.7.2026

Installation

Graphify ist ein Python-Programm (Open Source, MIT-Lizenz), das Sie am besten mit uv tool install auf Ihrem Rechner einrichten. (uv ist ein moderner Python-Modulmanager, über den ich demnächst hier schreiben will.) Beachten Sie, dass der Paketname graphifyy mit Doppel-Y lautet, während das Kommando graphify heißt.

uv tool install graphifyy installiert das Programm. Sofern PATH das Verzeichnis .local/bin enthält, kann graphify anschließend sofort gestartet werden. graphify install richtet Skill-Dateien für die auf Ihrem Rechner gefundenen KI-Tools (in meinem Fall: Claude) ein.

$ uv tool install graphifyy

$ graphify install
  skill installed  ->  /Users/kofler/.claude/skills/graphify/SKILL.md
  CLAUDE.md        ->  created at /Users/kofler/.claude/CLAUDE.md

  Done. Open your AI coding assistant and type:

  /graphify .

Verwendung

Im Projektverzeichnis starten Sie nun das KI-Tool Ihrer Wahl (in meinem Fall: Claude Code). Dort steht Graphify jetzt als Skill zur Verfügung. Einfach

/graphify .

analysiert das Projektverzeichnis und erstellt nach vielen Rückfragen das Verzeichnis graphify_out. Das dauert geraume Zeit und verbrennt etliche Tokens. Das Verzeichnis enthält die folgenden Dateien:

ls -l graphify-out/

drwxr-xr-x  4 kofler  staff     128  7 Mai  09:54 cache/
-rw-r--r--  1 kofler  staff     213  7 Mai  10:10 cost.json
-rw-r--r--  1 kofler  staff    8523  7 Mai  10:10 GRAPH_REPORT.md
-rw-r--r--  1 kofler  staff  139973  7 Mai  10:10 graph.html
-rw-r--r--  1 kofler  staff  137091  7 Mai  10:09 graph.json
-rw-r--r--  1 kofler  staff    7912  7 Mai  10:10 manifest.json

Ich habe meine Tests anhand einer Swift-App mit ca. 2000 Zeilen Code in diversen Dateien durchgeführt. Die Ergebnisse sehen eindrucksvoll aus, der unmittelbare Erkenntnisgewinn war aber — zumindest bei diesem Projekt — überschaubar.

Wenn Sie Änderungen in der Code-Basis oder in Ihren Dateien durchführen, aktualisieren Sie den Knowledge Graph:

/graphify . --update        # merge changed content into existing graph

Der Knowledge Graph kann jetzt die Grundlage für Analysen mit /graphify explain oder graphiy query sein (Ausgabe etwas gekürzt):

/graphify explain "the sync process"

  Here's what the graph tells us about the sync process, grounded in the
  extracted edges:

  The sync process is orchestrated by ShoppingViewModel.pullMergePushSave
  (RestShopping.swift:125-175), which implements the Pull-Merge-Push lifecycle
  documented in CLAUDE.md. The graph found 16 nodes directly connected to this
  concept.

  The three phases (all EXTRACTED edges):

  1. Pull — apiPullItems (RestShopping.swift:62-93) fetches items from the
     remote REST API since the last sync timestamp.
  2. Merge — mergeItems (RestShopping.swift:178-193) resolves conflicts using
     Timestamp-Wins: whichever version of an item has the newer updatedAt
     wins. Two design rationale nodes connect here:
    - Timestamp-Wins Conflict Resolution → mergeItems [EXTRACTED]
    - Soft Delete Pattern → ShoppingItem [EXTRACTED] — items are never truly
      removed; isDeleted = true propagates deletions to other devices through
      the sync
  3. Push — apiPushItems (RestShopping.swift:96-120) uploads the merged state
     back to the server.
  4. Persist — saveLocally (ViewModel.swift:172-178) writes the final state to
     the local JSON file. mergeItems then calls replaceItem to update the
     ViewModel's live state.

  Wire format bridge: ItemDTO (RestShopping.swift:9-53) shares data with
   ShoppingItem [EXTRACTED] — it translates between the app's model and the
   API's integer-boolean/ISO 8601 wire format.

  Trigger points: ContentView and StatusView both connect to pullMergePushSave
  in the graph. ContentView runs it via .task, .onChange(scenePhase), and a
  40-second timer. StatusView (in Settings) provides a manual
  trigger. setupNewFamily and joinFamily also call pullMergePushSave as a final
  step after family registration.

  The most interesting angle here: the Soft Delete pattern is the load-bearing
  coupling between ShoppingItem (the model) and the sync logic — if you ever
  changed ShoppingItem to hard-delete, mergeItems would silently stop
  propagating deletions. Want me to trace the path from ShoppingItem.isDeleted
  through to what happens when a remote device pulls?

/graphify query "Where in code is the Category class used? 
                 Could we drop the @Observable attribute?"

  Here's what the graph found — and where its limits are:

  Where Category is used (from the graph):

  The BFS found 10 nodes. The confirmed connections [EXTRACTED]:
  - Category → shares_data_with → ShoppingViewModel (ViewModel.swift:1-181) —
    the ViewModel holds the categories: [Category] array
  - Category.predefinedCategories (Category.swift:24-37) ↔ ShoppingViewModel —
    the ViewModel calls this at init to populate its categories
  - .predefinedCategories() → calls → Color — each category has a color
    assigned

  What the graph is missing: There are no direct edges from Category to the
  view layer (CategoriesView, CategoryButton, EditItemView,
  CategoryRadioButton). Those views access categories through vm.categories and
  mutate category.isSelected/category.isExpanded directly — but the graph
  didn't capture these view→Category property access edges since they go
  through the ViewModel and aren't explicit call-site imports.

  On dropping @Observable:

  The graph can't answer this definitively — it would require the actual
  property mutation sites. But from the CLAUDE.md rationale node captured in
  the graph: "Mutable reference-type state (isSelected, isExpanded) is mutated
  directly from views." That design decision is precisely why @Observable is
  needed. Without it, those direct mutations on the reference type wouldn't
  trigger SwiftUI view updates — CategoriesView and EditItemView would stop
  reacting to category selection changes.

  Verdict from the graph: @Observable cannot be safely dropped without a larger
  refactor (e.g., moving isSelected/isExpanded into the ViewModel as @State or
  @Published backing). The graph confirms the coupling exists; reading
  Category.swift:4-112 directly would show exactly which properties are var vs
  let.

Die Website preist den größten Vorteil von Graphify an, dass derartige Abfragen auf der Basis des lokalen Knowledge Graphs nun wesentlich weniger Token verbrauchen als wenn das KI-Tool mit find und grep die Codebasis durchsucht und (immer wieder neu) analysiert. Bei meinen Tests ließ sich das Ausmaß der Ersparnis schwer messen.

Persönliche Einschätzung

Die Idee von Graphify ist gut. Allerdings wirkt Graphify ein wenig wie ein Fremdkörper innerhalb von Claude Code. Nur /graphify-Kommandos berücksichtigen die Graph-Knowledge-Datenbank. Die Skill-Datei ist mit über 1000 Zeilen und einer Menge eingebetteten Code auch eher abschreckend.

Aus Coding-Perspektive wäre es wünschenswert, die Generierung, Aktualisierung und Auswertung der Knowledge-Datenbank direkt in Claude Code bzw. in andere KI-Tools zu integrieren. Damit könnte das in der Datenbank aggregierte Wissen bei allen Aktionen berücksichtigt werden, nicht nur bei /graphify-Kommandos.

Ganz generell stellt sich die Frage, ob und wie weit Graph Knowledge Databases das bekannte RAG-Konzept ablösen oder zumindest ergänzen kann (also Retrieval-Augmented Generation, um eigenes Wissen in Vektordatenbanken zu speichern und einem LLM zugänglich zu machen). Siehe z.B. diesen Artikel über einen ähnlichen Ansatz mit kommerziellen Hintergrund.

Alternativen

• Headroom: Wenn es primär darum geht, den Kontext zu verkleinern und so Kosten zu sparen (idealerweise ohne Qualitätsverlust), hat das Projekt Headroom ein weiteres spannendes Konzept realisiert. Headroom agiert als eine Art Kompressor zwischen Ihren Prompts und dem KI-Tool/Sprachmodell. Allerdings wäre wohl auch in diesem Fall ein in das jeweilige CLI/KI-Tool integrierte Lösung noch besser.

• CodeGraph: Auch CodeGraph erfasst die Codebasis vorweg und in der Folge bei allen Änderungen. Die Daten werden in einer SQLite-Datenbank als Graph gespeichert. Der wichtigste Unterschied besteht darin, dass die Verbindung zum KI-Tool über MCP erfolgt, was eine tiefere Integration erlaubt.

Quellen/Links

• https://graphify.net/
• https://github.com/safishamsi/graphify
• https://github.com/safishamsi/graphify/blob/v7/docs/how-it-works.md
• https://docs.astral.sh/uv/
• https://thenewstack.io/pinecone-nexus-rag-obsolete/
• https://github.com/headroomlabs-ai/headroom
• https://colbymchenry.github.io/codegraph/getting-started/introduction/

Es kommt selten vor, dass ein IT-Buch innerhalb von 18 Monaten eine zweite Auflage erfährt und dabei in großen Teilen neu geschrieben werden muss. Genau das ist uns mit diesem Buch passiert! Wir haben die Gelegenheit genutzt und das Buch komplett aktualisiert und stark erweitert. Der Fokus liegt jetzt bei Agentic Coding, MCP und Skills.

Wir haben in diesem Buch den »State of the Art« im Bereich KI und Agentic Coding abgesteckt. In unzähligen Tests haben wir ausprobiert, wie weit die Versprechen der KI-Hersteller zutreffen, aber auch, wo heutige KI-Tools versagen. Wir haben lokale Modelle und Open-Source-Tools ebenso verwendet wie kommerzielle KI-Tools von Claude, Cursor, Google und OpenAI. Ein eigenes Kapitel behandelt den neuen Trend der CLI-basierten KI-Tools, also z.B. Claude Code oder OpenAI Codex.

Hier gibt es weitere Informationen zum Buch und den obligatorischen Bestell-Link.

Glücklicherweise muss ich nicht allzu oft unter Windows arbeiten. Aber hin und wieder — aktuell für die Überarbeitung meines Scripting-Buchs — lässt es sich nicht vermeiden. Wenn schon Windows, dann wenigstens so komfortabel wie möglich! Und so habe ich in den vergangenen Wochen mein Terminal/PowerShell-Setup optimiert:

• Nerdfont installiert
• informativen Prompt eingerichtet (Oh My Posh)
• bessere Tastaturunterstützung im Terminal (mit Emacs-Tastenkürzeln!)
• Editor für den Textmodus installiert (je nach Geschmack: Edit, nano, Emacs, NeoVim)
• sudo aktiviert
• Update 27.5.2026: less installiert

Dieser Artikel liefert dazu ein paar Details. Der Text beweist gleichzeitig, dass man selbst unter Windows mit relativ wenig Mühe ein produktives Setup einrichten kann. Das erforderliche Fundament liefert Microsoft direkt aus: das Windows Terminal mit vielen High-end-Funktionen inklusive GPU-Rendering, die PowerShell sowie das Paketverwaltungskommando winget.

Nerdfonts

Moderne CLI-Tools stellen im Terminal alle erdenklichen Zeichen und Symbole dar, um auf Dateitypen, den Git-Status oder Fehlerursachen hinzuweisen. In »gewöhnlichen« Fonts fehlen diese Zeichen; im Terminal wird dann ein Rechteck, ein Fragezeichen oder ein anderes Ersatzzeichen angezeigt. Das lässt den Charme moderner Kommandos und Prompt-Frameworks ins Leere laufen. Abhilfe schafft die Installation eines Fonts, der einen Coding-Zeichensatz um Tausende Symbole und Sonderzeichen ergänzt.

Auf der Seite https://nerdfonts.com stehen ca. 100 geeignete Fonts zum freien Download zur Auswahl. Aber welcher Font ist der beste? Wenn Sie sich nicht entscheiden können, ist der beliebte JetBrainsMono Nerd Font eine gute Wahl für erste Experimente. Er basiert auf dem freien Mono-Font der Firma JetBrains (IntelliJ, PyCharm etc.). Dieser Font hat noch einen Vorteil: Er lässt sich im Handumdrehen mit winget installieren. Sie sollten die Installation in einem Terminal mit Admin-Rechten durchführen, damit die Fonts auch dann zur Verfügung stehen, wenn Sie in einem Admin-Terminal arbeiten.

# in einem Admin-Terminal
winget install -e --id DEVCOM.JetBrainsMonoNerdFont

Oh My Posh

Die Fish oder die Zsh mit der Erweiterung »Oh My Zsh« zeigen im Prompt alle erdenklichen Kontextinformationen an: den Hostnamen, den Verzeichnisnamen, den Git-Zweig und -Status etc. Genau das kann auch Oh My Posh, eine Plattform- und Shell-unabhängiges Prompt-Framework. Die Installation gelingt unter Windows am schnellsten mit winget:

winget install JanDeDobbeleer.OhMyPosh -s winget

Damit Oh My Posh in interaktiven PowerShell-Sessions aktiviert wird, bauen Sie die folgenden Anweisungen in die Profile-Datei ein (notepad $Profile, wobei Sie notepad durch Ihren Lieblingseditor ersetzen):

# Datei Documents/PowerShell/Microsoft.PowerShell_profile.ps1
# Oh My Posh nur in interaktiven PowerShell-Sessions verwenden
if (-not [Console]::IsInputRedirected -and 
  (Get-Module -Name PSReadLine -ErrorAction SilentlyContinue)) 
{
  oh-my-posh init pwsh | Invoke-Expression
}

Wenn Sie jetzt ein neues PowerShell-Tab öffnen, wird Oh My Posh erstmals aktiv. Sie werden von einem informativen und mehrfarbigen Default-Prompt begrüßt. Unter https://ohmyposh.dev/docs/themes stehen über 100 weitere Prompt-Themen zur Wahl. Zur Aktivierung bauen Sie den Themennamen in das oh-my-posh-Init-Kommando in der Profile-Datei ein, z.B. so:

# Datei Documents/PowerShell/Microsoft.PowerShell_profile.ps1
oh-my-posh init pwsh --config "easy-term" | Invoke-Expression

Um die neue Konfiguration zu aktivieren, lesen Sie die Profile-Datei neu ein:

. $PROFILE

Starship Eine Alternative zu Oh My Posh ist das Framework Starship. Es wurde in Rust entwickelt und ist schneller/effizienter als Oh My Posh. Dafür gibt es aber weniger vordefinierte Themen; generell ist die Konfiguration sperriger. Ich habe beide Frameworks ausprobiert, bin dann aber bei Oh My Posh geblieben.

Tastenkürzel in der PowerShell

In der PowerShell unterstützt Sie das Modul PSReadLine bei der Kommandoeingabe (siehe auch die Dokumentation zu Set-PSReadLineOption). Standardmäßig schlägt PSReadLine das letzte Kommando mit den selben Anfangsbuchstaben zur Vervollständigung durch Cursor rechts vor. Tab bewirkt, dass begonnenen Dateinamen oder Schlüsselwörter komplettiert werden.

Das Verhalten von PSReadLine kann durch Optionen in der Profile-Datei beeinflusst werden. Diese Datei öffnen Sie am bequemsten mit notepad $Profile, wobei Sie notepad durch Ihren Lieblingseditor ersetzen. Damit die Änderungen wirksam werden, laden Sie die Datei mit . $Profile neu.

Das folgende Listing schlägt einige Änderungen/Verbesserungen vor. Gleich das erste Kommando bewirkt den größten Unterschied: Nach der Eingabe der ersten Buchstaben haben Sie die Wahl zwischen mehreren ähnlichen zuletzt ausgeführten Kommandos, die Sie mit den Cursortasten aus einer Liste wählen. Mit F2 können Sie zwischen der Listenansicht und dem Defaultverhalten (InlineView) umschalten.

Falls Sie bei InlineView bleiben wollen, sollten Sie zumindest die beiden HistorySearch-Kommandos in Erwägung ziehen. Normalerweise blättern Cursor auf und Cursor ab durch alle bisherigen Kommandos. Mit den hier vorgeschlagenen Einstellungen können Sie dagegen git eingeben und dann durch die bisherigen git-Kommandos blättern.

Emacs- und Vi-Fans werden begeistert sein, dass die PowerShell per EditMode die vertrauten Tastenkürzel akzeptiert. Die if-Abfrage im folgenden Listing stellt sicher, dass die Einstellungen nur in interaktiven Sessions gelten, aber z.B. nicht, wenn die PowerShell ein einzelnes Kommando via SSH ausführt.

# Ergänzungen in der Profile-Datei
if (-not [Console]::IsInputRedirected -and 
  (Get-Module -Name PSReadLine -ErrorAction SilentlyContinue)) 
{
  # zeigt Vervollständigungsliste an, Auswahl per Cursortasten
  Set-PSReadLineOption -PredictionViewStyle ListView

  # Cursor auf/ab berücksichtigen die bisherige Eingabe
  Set-PSReadLineKeyHandler -Key UpArrow ` 
                           -Function HistorySearchBackward
  Set-PSReadLineKeyHandler -Key DownArrow `
                           -Function HistorySearchForward

  # Emacs- oder Vi-Tastenkürzel (per Default: Windows-Tastenkürzel)
  Set-PSReadLineOption -EditMode Emacs
  Set-PSReadLineOption -EditMode Vi

  # besser sichtbare Farbe für Inline-Vervollständigung
  Set-PSReadLineOption -Colors @{ InlinePrediction = '#884488' }

  # keine Duplikate in der Kommando-History speichern
  Set-PSReadLineOption -HistoryNoDuplicates
}

Terminal-Editoren

An GUI-Editoren herrscht unter Windows kein Mangel — die Palette reicht von notepad.exe über Notepad++ bis hin zu VS Code und anderen KI-tauglichen Programmen/IDEs. Aber oft wollen Sie einfach nur ein paar Zeilen Text ändern, eine Konfigurationsdatei vervollständigen etc. — und zwar, ohne das Terminal zu verlassen. (Das gilt insbesondere, wenn Sie via SSH remote arbeiten!) Dazu brauchen Sie einen Editor, der im Terminal ausgeführt werden kann.

edit: Durchaus nicht die schlechteste Wahl ist edit. Mitte 2025 hat Microsoft diesen Mini-Editor vorgestellt — als GitHub-Projekt in der Programmiersprache Rust! Damit liegt Microsoft voll im Zeitgeist. Zur Installation führen Sie winget install microsoft.edit aus. In der Folge lädt edit <file> die gewünschte Datei.

Bemerkenswert an edit ist die intuitive, einfache Bedienung. Text wird mit den Cursortasten markiert, mit Strg+C und Strg+V kopiert und wieder eingefügt etc. Die Cursorposition kann mit der Maus verändert werden, auch das lokalisierte Menü lässt sich per Maus bedienen und gibt IT-Veteranen ein wenig Turbo-Pascal-Vibes. Fortgeschrittene Funktionen fehlen allerdings: kein Syntaxhighlighting, keine Code-Vervollständigung, keine Einstellungen …

nano: In der Linux-Welt ist nano das Gegenstück zu edit. Der Editor hat zwar nur relativ wenige Funktionen, ist dafür aber einfach zu bedienen. Praktischerweise zeigt das Programm alle erforderlichen Tastenkürzel gleich in der Statusleiste an. Die Installation gelingt unkompliziert mit winget install -e --id GNU.Nano.

vi/NeoVim: Die einen lieben ihn, andere hassen ihn — das Editor-Urgestein vi. Vi-Fans verwenden unter Windows am besten die Variante NeoVim (siehe https://neovim.io). NeoVim ist aber nur die Basis: Damit das Programm sein ganzes Potential ausschöpfen kann, brauchen Sie diverse Erweiterungen (Git, LSP, Fuzzy Finding usw.) und Konfigurationseinstellungen. Das Setup gelingt am schnellsten mit Frameworks wie LazyVim oder AstroNvim.

Emacs: Mich hat der Vi nie überzeugen können, ich bin im Emacs-Lager. Unter Windows ist das allerdings ein Abenteuer. Von abgespeckten Emacs-Klonen wie mg, zile oder jmacs gibt es keine Windows-Ports, die im Terminal funktionieren. Also muss es die Vollversion sein: winget install -e --id GNU.Emacs. winget kümmert sich leider nicht darum, das Emacs-Installationsverzeichnis zum Path hinzuzufügen. Sie müssen sich selbst um diesen Schritt kümmern. Die ausführbare Datei befindet sich üblicherweise in C:\Program Files\Emacs\emacs-<n.n>\bin.

Beim Start des Editors müssen Sie an die Option -nw denken (no window), sonst erscheint der Emacs in einem eigenen Fenster statt im Terminal. Noch eine Besonderheit betrifft die Konfigurationsdatei ~/.emacs. Die Windows-Version des Emacs liest diese Datei normalerweise (abhängig von der HOME-Umgebungsvariablen) nicht aus C:\Users\name\.emacs, sondern aus C:\Users\name\AppData\Roaming\.emacs. Wenn Emacs Unicode-Zeichen fehlerhaft anzeigt, bauen Sie die folgenden Anweisungen in .emacs ein:

# Datei C:\Users\<name>\AppData\Roaming\.emacs
(prefer-coding-system 'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-language-environment "UTF-8")

sudo

Um unter Windows ein Kommando mit Administratorrechten auszuführen, müssen Sie zuerst umständlich ein Terminal mit Admin-Rechten öffnen. Unter Linux und macOS klappt das mit sudo viel unkomplizierter.

Ab Version 11 / 24H2 gibt es sudo auch unter Windows. Microsoft hat das Kommando komplett neu implementiert und nur den Namen übernommen. Die Funktionsweise und Optionen sind anders als unter Linux oder macOS. Insbesondere gibt es keine (Passwort-)Authentifizierung; stattdessen erscheint vor sudo-Aktivitäten nur der UAC-Bestätigungsdialog (User Account Control).

sudo muss zuerst aktiviert werden. Sie finden die Option in den Einstellungen unter System / Erweitert / Terminal.

Es gibt drei Arten, wie sudo-Kommandos ausgeführt werden können: in einem neuen Fenster (gilt per Default, forceNewWindow), mit deaktivierter Eingabe (disableInput, die Standardeingabe wird blockiert) oder inline (normal, also wie unter Linux mit der Möglichkeit, direkt im Terminal mit dem ausgeführten Kommando zu interagieren). Statt in den Einstellungen können Sie sudo auch in einem Terminal mit Admin-Rechten aktivieren:

sudo config --enable forceNewWindow|disableInput|normal

Sobald sudo zur Verfügung steht, können Sie das Kommando wie in den folgenden Beispielen anwenden. (Das erste Kommando setzt voraus, dass das Programm edit installiert ist.)

sudo edit C:\Windows\System32\drivers\etc\hosts
sudo notepad C:\Windows\System32\drivers\etc\hosts
sudo winget upgrade --all
sudo pwsh -c "Restart-Service -Name Spooler"

Beachten Sie, dass sudo Restart-Service -Name Spooler nicht funktioniert! sudo kann nur »echte« Kommandos (Executables) ausführen, keine CmdLets. Für CmdLets müssen Sie den Umweg über eine neue PowerShell-Instanz nehmen.

Der Windows-Implementierung von sudo fehlt auch die Option -s, um eine neue Shell zu starten. Stattdessen führt sudo pwsh zum Ziel.

Sicherheitsbedenken: Microsoft warnt davor, sudo ohne unmittelbare Notwendigkeit zu aktivieren. Die Warnung bezieht sich insbesondere auf die Inline-Variante. In der sudo-Implementierung von Linux wurden über den Verlauf von Jahrzehnten immer neue Sicherheitsprobleme gefunden und behoben. Vor diesem Hintergrund rate ich dazu, die Warnungen Microsofts ernst zu nehmen. sudo ist eine vergleichsweise neue, bislang eher selten genutzte Funktion.

gsudo: Eine Alternative sudo ist das schon länger verfügbare Kommando gsudo. Dieses Open-Source-Projekt bietet mehr Features als die Microsoft-Implementierung.

less

Wie man als Entwickler/Admin ohne less leben kann ist mir schleiferhaft. Unzähligen Windows-Admins scheint dies aber zu gelingen. Ich habe dazu aber keine Lust. less ist nur ein winget-Kommando entfernt!

winget install jftuga.less

Quellen/Links

• https://nerdfonts.com
• https://ohmyposh.dev
• https://starship.rs
• https://github.com/MicrosoftDocs/PowerShell-Docs/blob/main/reference/5.1/PSReadLine/Set-PSReadLineOption.md

Editoren

• https://github.com/microsoft/edit
• https://neovim.io
• https://www.lazyvim.org
• https://astronvim.com
• https://www.gnu.org/software/emacs

sudo

• https://github.com/microsoft/sudo
• https://learn.microsoft.com/windows/advanced-settings/sudo
• https://github.com/gerardog/gsudo

less

• https://github.com/jftuga/less-Windows

Ubuntu 26.04 ist fertig und stellt für die nächsten zwei Jahre die LTS-Messlatte. Im Vergleich zu Version 24.04 hat sich viel geändert. Ich habe mich bemüht, in diesem Blog-Artikel die wichtigsten Details knapp zusammenzufassen.

Noch mehr Lesestoff bieten die Release Notes sowie omgubuntu.co.uk. Einige wesentliche technische Neuerungen waren bereits in Version 25.10 präsent (Rust Core Utilities, Dracut, TPM-Verschlüsselung); diese habe ich im Detail bereits im Blog beschrieben.

Software

Die folgende Tabelle fasst die Versionen der Kernkomponenten von Ubuntu 26.04 zusammen:

Basis               Programmierung     Server
---------------     --------------     --------------------------
Kernel      7.0     bash       5.3     Apache      2.4
glibc      2.43     gcc         16     CUPS        2.4
Wayland    1.24     git       2.53     MariaDB 11.8 / MySQL 8.4
Gnome        50     Java        25     OpenSSH    10.0
Mesa       26.0     PHP        8.5     PostgreSQL   18
Systemd     250     Podman     5.7     Postfix    3.10
NetworkMan 1.54     Python    3.14     qemu/KVM   10.2
GRUB       2.14     Node.js     22     Samba      4.23

Ubuntu hat eine ganze Reihe neuer Default-Programme:

                     Bisher                 Neu
                     -----------------      -----------
Image-Viewer         Eye of Gnome           Loupe
PDF-Viewer           Evince                 Paper
System Monitor       Gnome System Monitor   Resources
Terminal Emulator    Gnome Terminal         Ptyxis
Video Player         Totem                  Showtime

Apropos Terminal Emulator: Ptyxis ist ein modernes Programm samt GPU-Rendering. Falls Sie noch höhere Ansprüche stellen, steht nun auch Ghostty in den Paketquellen zur Verfügung (Snap-frei mit apt install ghostty).

Standardmäßig nicht mehr installiert wird das Programm Anwendungen & Aktualisierung, mit dem die Paketquellen verändert und proprietäre Treiber installiert werden konnten. Vor allem letztere Funktion war sehr beliebt. Immerhin ist das Programm nur ein apt-Kommando entfernt (apt install software-properties-gtk).

Kein Durchbruch stellt Ubuntu 26.04 bezüglich des Ubuntu-eigenen Snap-Formats dar. Per Default sind überraschend wenige Apps als Snap-Pakete installiert: Firefox, der Firmware Updater, das neue Security Center und die Paketverwaltung App Zentrum alias Snap Store. Das App-Zentrum unterstützt zudem schon seit der vorigen Version auch Debian-Pakete. Die Snap-Revolution bleibt vorerst aus.

Technische Neuerungen

• Gnome ist jetzt Wayland-only, X11 wird nicht mehr unterstützt. (XWayland natürlich schon, aber nicht der Betrieb von Gnome unter X.)

• Der Kernel hat einen Sprung auf 7.0 gemacht.

• Initial-Ramdisk-Dateien werden nun mit Dracut erstellt (schon seit Version 25.10).

• Chrony ist der Default-Time-Dämon (ersetzt systemd-timesyncd).

• Rust Utilities: Die Rust-Programme/Utilities sudo-rs und rust-coreutils kommen standardmäßig zum Einsatz (schon seit Version 25.10)

• Software-Entwicklern hilft das neue Gnome-Programm Sysprof-Programm bei Debugging und Profiling (siehe https://apps.gnome.org/de/Sysprof/).

• ROCm: Ubuntu ist stolz darauf, dass die Installation der ROCm-GPU-Bibliotheken von AMD nun ganz einfach mit sudo install rocm gelingt. Praktisch ist das vor allem für KI-Anwendungen und die Ausführung von Sprachmodellen. Phoronix hat das ausprobiert und festgestellt, dass damit die sechs Monate alte Version 7.1 auf der SSD landet. (Aktuell wäre 7.2.2.) Das stiftet wenig Vertrauen in die zukünftige Wartung dieser Pakete …

• Das neue Sicherheitszentrum (security_center, ein Snap-Paket) hilft bei der Ubuntu-Pro-Aktivierung und der Verwaltung weiterer Sicherheitsfunktionen. Die App hat noch Luft nach oben, würde ich sagen.

Vier GByte RAM sind nicht genug

In der Vergangenheit waren 4 GiB RAM bei den meisten Distributionen zumindest für erste Tests ausreichend. Ubuntu verlangt für Desktop-Installationen nun offiziell 6 GiB. Eine praxisnahe Nutzung unter 8 GiB RAM ist sicher nicht zu empfehlen; das galt auch schon für frühere Versionen. Andererseits waren die 4 GiB lange absolut ausreichend, um Ubuntu zumindest in virtuellen Maschinen einfach schnell mal auszuprobieren. (Und bei vielen anderen Distributionen reicht das noch immer.) Insofern stellt sich die Frage, warum Ubuntu so viel mehr Arbeitsspeicher braucht. (Snap?)

Im Internet gibt es unterschiedliche Angaben, ob der Betrieb nicht doch mit 4 GiB gelingt. Vermutlich. In einer meiner Testinstallationen (6 GiB RAM in einer virtuellen Maschine) sind nach dem Desktop-Login noch 3 GiB verfügbar.

free -h
               gesamt       benutzt     frei      gemns.  Puffer/Cache verfügbar
Speicher:      5,3Gi       2,2Gi       1,7Gi       108Mi       1,6Gi       3,0Gi
Auslager:      4,0Gi          0B       4,0Gi

Andererseits blieb eine virtuelle Installation auf einem MacBook mit UTM vor ein paar Tagen hängen (schon während der Installation, nicht im Betrieb). In der Folge habe ich auf weitere 4-GiB-Tests verzichtet. So relevant ist das Limit für mich nun auch wieder nicht. Meine Rechner sind mit ausreichend RAM ausgestattet :-)

Letzte Anmerkung zu diesem Thema: Für Ubuntu Server empfehlen die Release Notes ein Minimum von 1,5 GiB. Zur Einordnung: Im Linux-Unterricht verwende ich dutzendweise Alma-Linux-10-VMs mit 1 GiB RAM, die absolut rund laufen.

Gnome Middle-Click

Ich wechsle berufsbedingt viel zwischen Linux und macOS hin und her. Der für mich auf dem Desktop irritierendste Nachteil von macOS besteht darin, dass das Markieren und Einfügen mit der mittleren Maustaste nicht funktioniert (im Terminal schon, aber nicht mit anderen Programmen). Unter Linux verwende ich diese Funktion ständig, sicher mehrere Male pro Stunde.

Die Gnome-Entwickler sind naturgemäß anderer Meinung und wollen Gnome auch in dieser Hinsicht auf das niedrigere macOS-Niveau angleichen. Die Funktion Einfügen per mittlerer Maustaste ist seit Gnome 50 deaktiviert. Wem fällt so ein Wahnsinn ein? Wer keine Maus bzw. kein Trackpad mit drei Tasten hat, konnte die Funktion schon bisher nicht nutzen. Gut, das ist dann nicht zu ändern. Aber warum muss Gnome alle anderen Anwender ohne jede Not gängeln?

Zum Glück kann der Mittelklick in gnome-tweaks (Optimierungen) oder mit dem folgenden Kommando reaktiviert werden:

gsettings set org.gnome.desktop.interface gtk-enable-primary-paste true

Ubuntu hat die Gnome-Entscheidung einfach nachvollzogen, scheint also irgendwie einverstanden zu sein. Merkwürdig.

Fazit

Bei meinen nicht allzu intensiven Tests hat Ubuntu 26.04 einen runden Eindruck gemacht. Optisch glänzt der Ubuntu-Desktop: Ich kenne keine andere Distribution, die mir out of the box so gut gefällt.

Davon losgelöst klingt mein Fazit schon seit Jahren ziemlich ähnlich: Linux-Einsteiger können mit Ubuntu nicht viel falsch machen. Für mich persönlich ist Ubuntu aber schon eine Weile nicht mehr die erste Wahl.

Quellen/Links

• https://ubuntu.com/desktop
• https://documentation.ubuntu.com/release-notes/26.04/
• https://gitlab.gnome.org/GNOME/gsettings-desktop-schemas/-/merge_requests/119
• https://www.phoronix.com/news/Ubuntu-26.04-With-ROCm

Andere Tests

• https://www.omgubuntu.co.uk/2026/04/ubuntu-26-04-lts-changes-since-24-04
• https://www.derstandard.at/story/3000000317985/ubuntu-2604-lts-die-neue-generation-der-beliebten-linux-distribution-unter-der-lupe
• https://kofler.info/ubuntu-25-10/

Vor zwei Jahren half »Prompt Engineering« zu besseren Ergebnissen bei KI-Tools. Heute ist der Weg ein anderer:

• Die Datei AGENTS.md (für die meisten KI-Tools) bzw. CLAUDE.md (für Claude Code) im Projektverzeichnis fasst wichtige Projektinformationen und Coding-Anweisungen zusammen. IDEs wie Cursor bzw. CLIs wie Claude Code oder Codex berücksichtigen diese Datei bei jedem Session-Start automatisch. Damit bietet diese Datei eine großartige Möglichkeit, das Default-Verhalten von KI-Tools den eigenen Ansprüchen anzupassen. (AGENTS.md können CLAUDE.md auf verschiedenen Ebenen gespeichert werden, um z.B. allgemeine Coding-Anweisungen mit spezifischen Projektinformationen zu kombinieren.)

• Skills ermöglichen es, Anweisungen für bestimmte Bearbeitungsschritte im Markdown-Format zu formulieren. Während AGENTS.md immer berücksichtigt wird, werden Skills nur bei Bedarf ausgewertet. Skills können auch Anweisungen für den Aufruf externer Tools beinhalten und ersetzen dann in manchen Fällen die MCP-Server-Konfiguration. (Auch Skills können wahlweise projektspezifisch oder auf globaler Ebene eingerichtet werden.)

Dieser Beitrag zeigt die Anwendung von AGENTS.md und Skills speziell für die Programmiersprache Swift — losgelöst davon, ob Sie in Xcode arbeiten oder eine externe CLI verwenden. Der Artikel hat einen leichten Claude-Fokus, weil ich mich persönlich in der Anthropic-Welt wohler fühle als in der von OpenAI. Qualitativ gibt es keine großen Unterschiede zwischen beiden Systemen, beide funktionieren mittlerweile herausragend gut.

Ich setze hier voraus, dass Sie grundlegende Erfahrung mit KI-Tools haben und zumindest ein CLI-Tool (ich empfehle Claude Code, aber auch Codex CLI, Gemini CLI, Copilot CLI usw.) ausprobiert haben.

AGENTS.md bzw. CLAUDE.md auf Projekt-Ebene

Wenn Sie in Xcode mit Claude Agent oder Codex arbeiten, sollte Ihr erster Prompt in einem neuen Projekt /init lauten. Der Claude Agent bzw. Codex analysiert dann Ihren Code und erzeugt die Datei CLAUDE.md bzw. AGENTS.md. (AGENTS.md ist ein generischer Name. Die Datei wird von den meisten KI-Tools berücksichtigt, absurderweise aber nicht von Anthropic-Tools, die auf CLAUDE.md bestehen.)

Die Datei wird im Projektverzeichnis gespeichert; sie ist im Projektnavigator unsichtbar, weil dieser eine Verzeichnisebene tiefer ansetzt. Im Regelfall lohnt es sich, diese Datei in einem Editor nachzubearbeiten und dort bei Bedarf eigene Coding-Anweisungen hinzuzufügen.

Beachten Sie, dass die Datei bei jeder Session in den Kontext gelesen wird. Halten Sie sich daher kurz!

Die von Claude Code ohne meine Mithilfe generierte Datei CLAUDE.md für das Cart-Beispielprogramm (Kapitel 25 in meinem Swift-Buch) sieht beispielsweise so aus:

# CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

## Build & Run

This is an Xcode project (`family-cart.xcodeproj`). Build and run through Xcode or use the `BuildProject` MCP tool. There are no tests, no linter, and no package dependencies.

## Architecture

**Family Cart** is a SwiftUI shopping list app that syncs across family members via a REST API. The codebase follows a strict three-layer structure reflected in the folder naming:

### 1_model
- **ShoppingItem** — Immutable `struct` (Codable, Identifiable). All mutations produce new copies via the `with(...)` helper. Persisted locally as JSON in the Documents directory (`shoppingItems.json`). The `[ShoppingItem].save()` extension handles local persistence.
- **Category** — `@Observable class` with 10 predefined grocery categories. Each has a `shortcut` string (e.g. `"bread"`, `"veg"`, `"dairy"`) used as the foreign key in ShoppingItem. Categories are not persisted — they are recreated from `predefinedCategories()` on every launch. `Color(hex:)` extension lives here.

...
## Key Patterns

- **No Combine**: The app uses `@Observable` (Observation framework) and Swift concurrency (async/await). Avoid introducing Combine.
- **Immutable model pattern**: `ShoppingItem` is a struct. Always use `with(...)` to create modified copies, then `replaceItem(_:with:)` on the view model. Never mutate items in place.
- **Single ViewModel**: All state flows through `ShoppingViewModel`. Views receive it as a parameter (not via `@Environment`).
- **Categories as constants**: The 10 categories and their shortcuts are hardcoded. Category images use custom assets with `-fill` suffix variants for selected state.
- **Localization**: Strings are localized via `Localizable.xcstrings` (English + German). Category names use `LocalizedStringKey`.
- **Soft delete**: Items are never removed from the array — `deleteItem()` sets `isDeleted = true` and title to `"deleted"`.

## REST API

Backend at `cart.kofler.info:443`. Authentication via HMAC-SHA256 tokens that rotate every 5 minutes. Key endpoints:

- `GET /version` — connectivity test
- `GET/PUT /items/{family_id}` — pull/push shopping items
- `PUT /newfamily`, `PUT /newmember` — family setup
- `GET /family/{code}`, `GET /members/{family_id}` — family lookup

AGENTS.md bzw. CLAUDE.md auf Xcode-Ebene

Während AGENTS.md bzw. CLAUDE.md im Projektverzeichnis eben nur für dieses Projekt gilt, können Sie die gleichnamige Datei auch in speziellen Xcode-Verzeichnissen speichern. Die dort formulierten Regeln gelten dann für alle Projekte in Xcode, in denen Sie den jeweiligen Agenten zu Hilfe nehmen.

Die aktuelle KI-Integration sieht die folgenden beiden Verzeichnisse zur Konfiguration von Claude Agent bzw. Codex vor (Quelle):

~/Library/Developer/Xcode/CodingAssistant/codex
~/Library/Developer/Xcode/CodingAssistant/ClaudeAgentConfig

Die dort gespeicherten Dateien werden — parallel zu eventuell ebenfalls vorhandenen gleichnamigen Dateien auf Projektebene — automatisch berücksichtigt, sobald Xcode Codex oder Claude Agent startet.

Vorsicht! Das ClaudeAgentConfig-Verzeichnis gilt nicht, wenn Sie in Xcode Claude verwenden. Es wird nur von Claude Agent berücksichtigt. Diese verwirrende Differenzierung zwischen zwei fast gleichnamigen KI-Features hat mir anfangs eine Menge Zeit gekostet.

Systemweite AGENTS.md-Dateien sind also der ideale Ort, um Swift- bzw. Xcode-spezifische Anweisungen zu speichern, die nichts mit einem konkreten Projekt zu tun haben. Es ist empfehlenswert, den Coding-Agenten dort Hinweise zu geben, dass diese ausschließlich moderne Swift-Sprachmerkmale (z.B. Concurrency) und SwiftUI-Features nutzen sollen.

Warum ist das so wichtig? Sprachmodelle werden mit im Internet verfügbaren Informationen trainiert. Dort überwiegen aber veraltete Informationen, die sich auf ältere Swift/SwiftUI-Versionen beziehen. Deswegen ist der von KI-Sprachmodellen generierte Code oft sub-optimal. (Dass Apple den Coding-Agenten via MCP Zugriff auf die aktuelle Dokumentation gibt, hilft nicht viel. Die KI erkennt gar nicht die Notwendigkeit, dort nachzusehen.)

Es gibt im Internet mehrere Vorlagen für AGENTS.md/CLAUDE.md. Die beste stammt meiner Ansicht nach von Paul Hudson (Hacking with Swift):

https://github.com/twostraws/SwiftAgents/blob/main/AGENTS.md

Laden Sie die Datei herunter, und speichern Sie diese unter einem der beiden folgenden Pfade:

~/Library/Developer/Xcode/CodingAssistant/codex/AGENTS.md
~/Library/Developer/Xcode/CodingAssistant/ClaudeAgentConfig/CLAUDE.md

Lesenswert ist dazu auch Hudsons Blog-Artikel What to fix in AI-generated Swift code!

AGENTS.md bzw. CLAUDE.md auf Systemebene

Die Dateien .claude/CLAUDE.md bzw. .codex/AGENTS.md erfüllen die gleiche Funktion, aber auf Systemebene und losgelöst von Xcode. Dort durchgeführte Einstellungen gelten allerdings für ALLE Programmiersprachen. Insofern ist es keine gute Idee, hier Swift- oder Xcode-spezifische Anweisungen zu speichern.

Wenn die Dateien CLAUDE.md bzw. AGENTS.md auf mehreren Ebenen (System, Xcode, Projekt) existieren, werden alle Dateien berücksichtigt und kombiniert. Umso wichtiger ist es, die Dateien nicht unnötig aufzublähen.

Swift-spezifische Skills

Skills verfolgen die gleiche Idee wie AGENTS-Dateien, formulieren also Regeln im Markdown-Format. Aber während die AGENTS-Dateien immer berücksichtigt werden, werden Skills nur bei Bedarf ausgewertet. Beispielsweise kann ein Skill-Dateiset Refactoring-Regeln enthalten. Erst wenn Sie in einem Prompt explizit Refactoring erwähnen (manchmal müssen Sie ganz explizit auf den Skill hinweisen), werden die dort gespeicherten Zusatzregeln berücksichtigt. Skills können auch Anweisungen für den Aufruf externer Tools beinhalten. Das ist an dieser Stelle aber kein Thema.

In den letzten Monaten haben einige Blogger Skill-Sets für Swift und SwiftUI zusammengestellt (siehe die Links am Ende dieses Beitrags). Ich greife an dieser Stelle den besonders nützlichen Skill SwiftUI Pro heraus:

https://github.com/twostraws/SwiftUI-Agent-Skill

Dieser Skill ist dazu gedacht, um in vorhandenen SwiftUI-Projekten einen Code Review durchzuführen — wahlweise via Claude Code, Codex CLI oder Xcode. Das KI-Sprachmodell durchsucht den Code dann nach veraltetem Code und macht Verbesserungsvorschläge. Das funktioniert großartig!!

Ein konkretes Anwendungsbeispiel im Zusammenspiel mit Claude Code folgt gleich. Vorerst geht es aber um die Installation, bei der es mehrere Varianten gibt, je nachdem ob Sie den Skill in einer CLI (Claude Code, Codex CLI) oder direkt in Xcode nutzen möchten.

Beginnen wir mit der Installation für CLI-Tools: Dazu öffnen Sie ein Terminalfenster und wechseln in das Projektverzeichnis. (Das Installationskommando setzt Node.js voraus. Führen Sie gegebenenfalls vorher brew install node aus.)

cd my-swiftui-project
npx skills add https://github.com/twostraws/swiftui-agent-skill --skill swiftui-pro

Während der Installation werden Sie gefragt, welche KI-Tools/Agenten Sie verwenden (z.B. Antigravity, Claude Code, Codex, Cursor usw.). Das hat Einfluss auf den Installationsort. Viele KI-Tools berücksichtigen das Verzeichnis .agents/skills, aber manche Tools wollen ihr eigenes Verzeichnis (z.B. .agent/skills oder .claude/skills). Dort werden standardmäßig Links auf die Dateien in .agents eingerichtet.

Außerdem müssen Sie sich entscheiden, ob die Skills universell für alle Projekte gelten sollen (Installation relativ zum Home-Verzeichnis) oder nur für ein Projekt (Installation im Projekt-Verzeichnis). Vor allem wenn Sie auf Ihrem Rechner Projekte in verschiedenen Programmiersprachen entwickeln, ist die projektspezifische Installation sicherer.

Die Xcode-Installation ist leider etwas umständlicher. Ich gehe davon aus, dass Sie vorher eine CLI-Installation in ein Projektverzeichnis durchgeführt haben. Von dort kopieren Sie nun das gewünschte Skills-Unterverzeichnis in das passende Xcode-Verzeichnis:

# für Claude Code
mkdir -p ~/Library/Developer/Xcode/CodingAssistant/ClaudeAgentConfig/skills
cd my-swiftui-project
cp -a .claude/skills/swiftui-pro ~/Library/Developer/Xcode/CodingAssistant/ClaudeAgentConfig/skills

# für Codex
mkdir -p ~/Library/Developer/Xcode/CodingAssistant/codex/skills
cd my-swiftui-project
cp -a .agents/skills/swiftui-pro ~/Library/Developer/Xcode/CodingAssistant/codex/skills

Jetzt sollten Sie sich noch vergewissern, dass der neue Skill wirklich im KI-Agenten Ihrer Wahl innerhalb von Xcode verfügbar ist (hier für Claude Code).

Der Aufruf des Skills variiert je nach Coding-Agent:

• Claude Agent: /swiftui-pro funktioniert nicht. (Dieses Claude-Code-Kommando klappt nur in der CLI.) Vielmehr müssen Sie in Xcode einen Prompt formulieren, der so ähnlich wie diese Anweisung aussieht: »Use the SwiftUI Pro skill to look for problems in this project.«

• Codex: $swiftui-pro

Anwendungsbeispiel mit Claude Code

Im Folgenden gehe ich davon aus, dass Sie mit Claude Code arbeiten. Nach dem Start vergewissern Sie sich mit dem Kommando /skills, dass Claude die Skill-Regeln swiftui-pro kennt. Den Code Audit starten Sie nun mit /swiftui-pro (bzw. in Codex mit $swiftui-pro).

cd my-swiftui-project
claude

> /skills

  ...

> /swiftui-pro 

  ...

  Summary

  1. Accessibility (high): Multiple icon-only buttons throughout
    (PlanTabView:66, SettingsTabView:159, CategoriesView:23/37) are invisible
    to VoiceOver. The CategoryHeader uses onTapGesture instead of Button, also
    problematic for VoiceOver.

  2. Deprecated API (high): foregroundColor() used in 6+ locations should be
    foregroundStyle().  cornerRadius() used in 3 locations should be
    clipShape(.rect(cornerRadius:)). tabItem() should be the modern Tab
    API. .autocapitalization() should be .textInputAutocapitalization(). Style
    struct instances (PlainButtonStyle(), etc.) should use static member
    syntax.

  3. Code organization (medium): Multiple type definitions per file throughout
     the view layer (PlanTabView has 3 types, SettingsTabView has 3,
     EditItemView has 3, CategoriesView has 2). Each should be in its own
     file. The itemsForEach method returning some View should be a dedicated
     View struct.

  4. Data flow (medium): Category class is @Observable but missing
     @MainActor. @State var vm in ShoppingTabView, PlanTabView, and
     CategoriesView is not marked private.

  5. Modern Swift (low): Use Date.now over Date(), URL.documentsDirectory over
     FileManager lookups, !items.isEmpty over items.count > 0, modern ISO 8601
     date parsing, and the Tab enum pattern for tab selection.

  The review is complete above. Would you like me to fix any of these issues?

Alle Probleme auf einmal zu beheben ist keine gute Idee. Besser gehen Sie schrittweise vor und erstellen nach jedem Fix und dem nachfolgenden Test Ihrer App Xcode einen Commit.

> fix foregroundColor()

  Done. Replaced all .foregroundColor() with .foregroundStyle() across 3 files:                            

  - ContentView.swift - 4 occurrences (debug overlay text colors)                                          
  - PlanTabView.swift - 2 occurrences (toggle button labels)              
  - SettingsTabView.swift - 3 occurrences (error text, warning text, sync time indicator) 

> ! git commit -a -m 'fixed foregroundColor -> foregroundStyle'  

Lesetipps

AGENT-Dateien und Skills bestehen aus Markdown-Dateien. Selbst wenn Sie keine KI-Tools verwenden wollen, lohnt sich die Lektüre dieser Regeldateien. Sie werden nirgendwo sonst so kompakte Regeln zur richtigen Swift/SwiftUI-Programmierung finden! Lesen Sie beispielsweise die Anweisungen zur richtigen Verwendung von Actors aus dem Concurrency-Skill von Paul Hudson.

Quellen/Links

Grundlagen zu AGENTS.md/CLAUDE.md/Skills

• https://agents.md
• https://developers.openai.com/codex/guides/agents-md
• https://code.claude.com/docs/en/features-overview
• https://support.claude.com/en/articles/12512176-what-are-skills

Agentic Coding mit Xcode

• https://kofler.info/xcode-26-3-kann-endlich-ki
• https://developer.apple.com/documentation/Xcode/setting-up-coding-intelligence#Customize-the-Codex-and-Claude-Agent-environments
• https://www.hackingwithswift.com/articles/281/what-to-fix-in-ai-generated-swift-code
• https://www.hackingwithswift.com/articles/282/swiftui-agent-skill-claude-codex-ai
• https://www.hackingwithswift.com/articles/283/how-to-install-and-use-ai-agent-skills-in-xcode
• https://www.hackingwithswift.com/articles/283/how-to-install-and-use-ai-agent-skills-in-xcode
• https://developer.apple.com/documentation/xcode/giving-agentic-coding-tools-access-to-xcode

Für Swift optimierten AGENTS.md-Dateien und Skills von Paul Hudson

• https://github.com/twostraws/swiftagents (AGENTS.md)
• https://github.com/twostraws/SwiftUI-Agent-Skill (Swift-Basics und SwiftUI)
• https://github.com/twostraws/swiftdata-agent-skill (SwiftData)
• https://github.com/twostraws/swift-concurrency-agent-skill (Concurrency)
• https://github.com/twostraws/Swift-Testing-Agent-Skill (Unit-Tests)

Ähnliche Dateien/Skills von anderen Entwicklern

• https://github.com/AvdLee/SwiftUI-Agent-Skill
• https://github.com/AvdLee/Swift-Concurrency-Agent-Skill

Videos

• https://www.youtube.com/watch?v=QdpaI_j0FRU (Stewart Lynch)
• https://www.youtube.com/live/sc6pvW6vQzA (Paul Hudson)

Rund um die Integration von KI-Tools in Xcode hat sich Apple bisher nicht mit Ruhm bekleckert (siehe auch meinen Blog-Artikel zu Xcode 26.1 und 26.2). Aber mit Version 26.3 ist Xcode endlich doch im KI-Zeitalter angekommen. Der Schlüssel zum Erfolg: die Einhaltung offener Standards.

KI funktioniert in Xcode 26.3, weil Apple mit mcpbridge einen MCP-Server mit ca. 20 Tools für Xcode implementiert hat. Damit können Sprachmodelle direkt mit Xcode kommunizieren, Code ändern, auf aktuelle Apple-spezifische Dokumentation zugreifen, Apps ausprobieren und Fehler beheben.

Konfiguration

Der Konfigurationsdialog Intelligence sieht simpel aus, stiftet in Wirklichkeit aber Verwirrung. Auf den ersten Blick könnte man meinen, es gäbe zwei vordefinierte KI-Provider: OpenAI mit ChatGPT und Codex auf der einen Seite, Anthropic mit Claude auf der anderen Seite. Es sind aber VIER!

• ChatGPT: simple KI-Unterstützung, in begrenztem Ausmaß kostenlos
• OpenAI Codex: Agentic Coding mit Codex
• Claude: simple KI-Unterstützung
• Claude Agent: Agentic Coding mit Claude (vergleichbar mit der CLI Claude Code)

Ich gehe im Folgenden davon aus, dass Sie ein ChatGPT- oder Claude-Abo haben und dieses für Xcode nutzen möchten. Dazu installieren Sie zuerst das entsprechende Zusatzprogramm OpenAI Codex bzw. Claude Agent (Button Get). Ärgerlicherweise scheint die KI-Integration auch ohne diese Zusatzinstallation zu funktionieren — aber dann landen Sie bei den eingeschränkten Varianten ChatGPT oder Claude, die nur mittelmäßig funktionieren, keine Skill-Unterstützung aufweisen usw.

Im nächsten Schritt müssen Sie die Verbindung zum jeweiligen KI-Konto herstellen. Die Authentifizierung erfolgt in einem Webbrowser-Fenster. Die konfigurierten KI-Tools bekommen automatisch Zugang zu den MCP-Diensten von Xcode.

Es besteht auch die Möglichkeit, andere externe sowie lokale KI-Provider zu nutzen. Am interessantesten wäre sicherlich Google Gemini, aber ich habe aus Zeitgründen von Tests abgesehen. (Freie, lokale Modelle sind nach meinen Erfahrungen mit anderen IDEs eher ungeeignet. Sie sind für Agentic Coding nicht leistungsfähig genug. Außerdem basieren sie meist auf relativ altem Trainingsmaterial, was bei Swift/SwiftUI besonders ungünstig ist.)

Die Option Allow external agents to use Xcode tools ist nur dann relevant, wenn Sie ein externes (nicht in Xcode eingebettetes) KI-Tool verwenden, z.B. Claude Code oder Codex. Diese externen Tools können dann den in Xcode integrierten MCP-Server nutzen und z.B. Apps ausführen, davon Screenshots erstellen und auf diese Weise UI-Fehler erkennen/beheben.

In der KI-Seitenleiste wählen Sie den gewünschten, zuvor konfigurierten KI-Dienst aus. Alle Agentic Coding Funktionen gibt es aber nur mit Codex oder Claude Agent!

Erster Versuch (ChatGPT)

Als ersten Versuch habe ich mit dem Modell ChatGPT (ohne OpenAI-Konto) eine minimale Variante des Break-Out-Spiels als iOS-App entwickelt (siehe die erste Abbildung dieses Artikels).

Prompt: create a simple break out game as an iOS app

Zwei Minuten später war die App fertig. 170 Zeilen Code, alle in ContentView.swift. Xcode zeigte allerdings einen Build-Error an und wies auch gleich auf die Ursache hin: Es fehlte import Combine, worum ich mich selbst kümmerte. Danach war die App prinzipiell verwendbar.

Einerseits ist das Ergebnis beeindruckend, andererseits ist die Code-Qualität aber nicht großartig: Xcode bemängelte zwei onChange-Aufrufe, deren Syntax veraltet ist. Aber auch davon losgelöst ist der Code nicht effizient. Die Spielelemente sind alle in SwiftUI abgebildet (kein SpriteKit). Das ist die einfachste Lösung, aber die Implementierung ist langsam. Das Spiel wird stotternd langsam, sobald das Paddel mit der Maus verschoben wird.

Ich habe mit ein paar Folge-Prompts versucht, das Spiel zu verbessern:

Prompt: the onChange() modifiers are deprecated; please fix

Prompt: ok. it works, but it is extremely slow if I move the paddle. (As long as there is no user input, speed is OK)

Das KI-Tool ersetzte zuerst onChange durch task (OK) und baute dann @GestureState ein, um die Geschwindigkeit zu verbessern (ohne Erfolg).

Zweiter Versuch (Claude Agent)

Für den zweiten Versuch habe ich zuerst den Claude Agent heruntergeladen und mit meinem Claude-Konto verknüpft. Gleicher Prompt, also:

Prompt: create a simple break out game as an iOS app

Der erste Unterschied zum vorigen Beispiel besteht darin, dass der Claude Agent über das Problem zuerst nachdenkt und eine To-do-Liste erstellt. Diese arbeitete er dann Punkt für Punkt ab.

Der Code fällt mit ca. 350 Zeilen deutlich umfangreicher aus. Er ist in den beiden neuen Dateien BreakOutGame.swift und BreakOutGameView.swift deutlich besser organisiert. Der Code trennt zwischen Datenmodell und View. (Auf eine vollständige Realisierung des MVVM-Musters hat der Claude Agent aber verzichtet.) Der Code funktioniert auf Anhieb und ist frei von offensichtlich veralteten Funktionen. Auch die Performance ist deutlich besser.

Xcode kritisiert allerdings zwei Main-actor-Isolation-Probleme (Warnungen, keine Errors).

Prompt: there are two main actor isolation warnings; fix them

Claude gelingt es auf Anhieb, die Probleme zu beheben (Respekt!).

Eine weitere Analyse des Codes ergibt: Der Code ist OK, aber nicht ausgezeichnet. Der SwiftUI-Pro-Skill (mehr dazu in einem zweiten Blog-Artikel) kritisiert z.B. die Verwendung eines Timers für den GameLoop und schlägt stattdessen TimeLineView(.animation) vor.

Beispiel 3: Vorhandenen Code bearbeiten/erweitern (Claude Agent)

Im dritten Beispiel habe ich das einigermaßen komplexe Cart-Projekt aus meinem Swift-Buch geladen (siehe Kapitel 25). In ca. 2000 Zeilen Code, die über ein Dutzend Dateien verteilt sind, realisiert die App die Verwaltung einer Einkaufsliste, die mittels eines Backends (REST-API) über mehrere Familienmitglieder synchronisiert wird.

Mein erster Prompt sah so aus:

Prompt: /init

Dieses Claude-Code-typische Kommando analysiert die Code-Basis und erstellt die Datei CLAUDE.md mit einer Zusammenfassung über die Organisation des Codes. Damit tut sich der Claude Agent bei weiteren Aufrufen leichter, sich im Code zu orientieren, und muss diesen Schritt nicht wiederholen. Die Datei landet direkt im Projektverzeichnis und ist deswegen im Projektnavigator (der eine Ebene tiefer ansetzt) unsichtbar.

Der Claude Agent lädt diese Datei bei zukünftigen Sessions automatisch. In der Regel ist es zweckmäßig, die Datei durchzulesen und bei Bedarf eigene Erweiterungen durchzuführen. Ich habe bei diesem Test aber darauf verzichtet.

Als Nächstes habe ich in den Projekteinstellungen Default Actor Isolation = MainActor eingestellt (siehe auch den Blog-Artikel Swift 6.2 und Xcode 26.1).

Prompt: This app now uses Default Actor Isolation = MainActor. Remove no longer necessary main actor attributes.

Es gibt nur eine Stelle im Code. Claude Agent findet sie und entfernt das nun überflüssige Attribut.

In der Praxis haben sich die Synchronisationseinstellungen der App als zu groß herausgestellt. Die App speichert Änderungen alle 40 Sekunden. Wenn lokal nichts geändert wird, werden Remote-Änderungen sogar nur alle 10 Minuten durchgeführt. Der folgende Prompt führt direkt zum Ziel, obwohl ich Claude keinerlei Informationen gebe, wo sich die relevanten Einstellungen befinden.

Prompt: change the sync settings; I want to write changes after 20 seconds, read remote changes every 30 seconds

Die UI der App ist in einer TabView über drei Tabs verteilt. Ich möchte, dass die App auch bei jedem Tab-Wechsel eine Synchronisation durchführt. Wiederum findet der Claude Agent sofort die richtige Stelle im Code und baut dort einen asynchronen Aufruf der Sync-Methode ein.

Prompt: I also want to sync on every tab change.

Prompt: I want the app to also sync when it is disabled (switch to another app). There is already code for this, but it does not work reliable.

Claude Agent verbessert den Code entsprechend.

Prompt: update the version to 1.0.2

Prompt: ok. can you also update it in the target settings?

Hier kommt Claude an seine Grenzen. Er findet zwar eine Zeichenkette im Code, die er von 1.0.1 auf 1.0.2 ändert. Aber die Xcode-Einstellungen Target / Identity / Bundle Identifier kann es nicht ändern und bittet darum, diesen Schritt selbst zu erledigen.

Meine relativ einfachen Prompts verschleiern, wie weit Agentic Coding geht. Paul Hudson geht in seinem YouTube-Video aufs Ganze und beginnt mit einem Prompt, um eine Schach-Spiel-App zu programmieren. Eine viertel Stunde später ist die App soweit fertig, dass ein erstes Spiel möglich ist. Derartige Mammut-Prompts sind aber selten zweckmäßig. Gehen Sie Schritt für Schritt vor (wobei ein Schritt durchaus die Implementierung eines neuen Features sein kann), testen Sie die App, führen Sie einen Commit durch!

Xcode vs. Claude Code

Apple hat sich mit der Integration von KI-Tools in Xcode viel Zeit gelassen. Außerhalb des Apple-Universums hat sich mehr bewegt. Der aus meiner Sicht gerade spannendste Weg zur Programmierung von Swift-Apps ist heute das Command Line Interface (CLI) Claude Code.

Die Vorgehensweise sieht so aus: Sie erzeugen/laden mit Xcode Ihr Projekt. Gleichzeitig öffnen Sie ein Terminal, wechseln in das Projektverzeichnis und starten dort Claude Code. Durch Prompts weisen Sie Claude Code an, welche Funktionen es entwickeln soll. Xcode bleibt offen, Sie verwenden die IDE aber nicht (oder nur in Ausnahmefällen) zum Programmieren, sondern dazu, den von Claude Code produzierten Code zu lesen und die resultierende App zu testen bzw. auszuprobieren.

Diese Vorgehensweise ist ungewohnt, aber effizient. Manche Entwickler sind der Ansicht, der größte Vorteil moderner KI-Tools bestünde darin, dass Xcode nicht oder zumindest nur noch am Rande benötigt wird.

Im Vergleich zu den integrierten KI-Tools in Xcode bietet Claude Code diverse Zusatzfunktionen. Enorm hilfreich ist die Möglichkeit, Skills und MCP-Server zu nutzen. Das für mich wichtigste Feature ist aber der Planungsmodus (Ein-/Ausschalten mit Shift+Tab): Er gibt Ihnen die Möglichkeit, ein neues Feature in Ruhe zu planen, ohne den Code dabei anzurühren. Erst wenn Sie mit dem von Claude Code präsentiertem Plan vollständig zufrieden sind, beginnen Sie mit der Realisierung.

Erfreulicherweise unterstützt Xcode ab Version 26.3 auch externe KI-Tools und stellt diesen via MCP dieselben Funktionen wie internen KI-Tools zur Verfügung. Dazu müssen Sie in den Xcode-Einstellungen Intelligence / Allow external agents to use Xcode tools aktivieren. Die Kommandos, um den Xcode-Server in Claude Code bzw. in Codex einmalig einzurichten, sehen so aus (Dokumentation von Apple):

claude mcp add --transport stdio xcode -- xcrun mcpbridge
codex mcp add xcode -- xcrun mcpbridge

Damit der Aufruf von mcpbridge funktioniert, muss in den Xcode-Einstellungen unter Locations die richtige Xcode-Version eingestellt sein. Bei mir war der Eintrag ursprünglich leer (keine Ahnung warum), der MCP-Aufruf scheiterte deswegen.

Wenn Claude Code oder ein anderes externes KI-Tool MCP-Funktionen nutzen will, müssen Sie das vorher bewilligen.

Sind alle Voraussetzungen erfüllt, schreiben Sie die Prompts in Claude Code und verwenden Xcode nur noch, um den Code anzusehen bzw. Ihre App zu testen.

Sonstiges

• Auch Xcode 26.3 verwendet Swift 5 per Default. Wenn Sie Swift 6 wünschen, müssen Sie die Build Settings ändern. (Update 31.3.2026: Auch Xcode 26.4 bleibt bei Swift 5.)
• Der in Xcode 26 eliminierte Attribute Inspector ist nicht zurückgekommen. Das gilt auch für diverse andere UI-Elemente (z.B. die Refactor-Kommandos Extract Subview oder Embed in Xxx), die es früher in Xcode gab und die mit Version 26 verschwunden sind.
• Die aktuelle Swift-Version lautet — unverändert seit September 2025 — 6.2. (Genau genommen sind wir bei 6.2.4, aber es gibt seit einem halben Jahr keine nennenswerten Neuerungen.)

Quellen/Links

• https://developer.apple.com/documentation/xcode-release-notes/xcode-26_3-release-notes
• https://www.apple.com/newsroom/2026/02/xcode-26-point-3-unlocks-the-power-of-agentic-coding
• https://developer.apple.com/documentation/Xcode/setting-up-coding-intelligence
• https://developer.apple.com/documentation/xcode/giving-agentic-coding-tools-access-to-xcode
• https://zenvanriel.com/ai-engineer-blog/apple-xcode-agentic-coding-mcp-guide/
• https://kofler.info/ki-skills-fuer-swift/

Videos zum Thema »Agentic Coding mit Xcode 26.3«

• https://developer.apple.com/videos/play/tech-talks/111428/ (KI-Crashkurs, 5 Minuten)
• https://www.youtube.com/watch?v=QdpaI_j0FRU (30-minütiges Video von Stewart Lynch)
• https://www.youtube.com/live/sc6pvW6vQzA (zweistündiges Video von Paul Hudson, zwar mit einigem Leerlauf, aber dennoch empfehlenswert; behandelt auch Claude Code)