Pi Coding Agent Schulung: Open-Source-Agent selbst erweitern

Pi verstehen: Warum noch ein Coding Agent?

• Was Pi von umfangreichen Coding-Werkzeugen unterscheidet: kurzer Systemprompt, wenige Grundwerkzeuge
• Das Prinzip des schlanken Agenten: was bewusst fehlt und per Erweiterung nachrüstbar ist
• Pi im Vergleich mit Claude Code und Codex: Erweiterbarkeit, Modellwahl, Voreinstellungen
• Grundbegriffe im Zusammenspiel: Modell, Werkzeuge, Kontext und Session
• Wo Pi im Entwicklungsalltag nützt: Terminalarbeit, Skripte, maßgeschneiderte Abläufe
• Einsatzszenarien für Einzelne und für Teams mit gemeinsamer Konfiguration im Repository
• Grenzen und realistische Erwartungen: was ein kleiner Kern nicht von selbst mitbringt
• Vom Chatbot zum Werkzeug, das Dateien liest, schreibt, bearbeitet und Befehle ausführt
• Quelloffener Code: Pi lesen, nachvollziehen und Verhalten bei Bedarf selbst anpassen

Pi – Installation, Modelle und Konfiguration

• Pi per Installationsskript oder über npm installieren, Node.js-Voraussetzungen und Terminal vorbereiten
• Unterstützte Modellanbieter anbinden: große Cloud-Anbieter und Modell-Router
• Cloud-Modelle und lokale Modelle, etwa über Ollama, nach Qualität, Kosten und Datenschutz einordnen
• API-Schlüssel konfigurieren oder per Anmeldung ein vorhandenes Abonnement nutzen
• Modelle je Aufgabe wählen und während der Session mit /model wechseln
• Thinking Levels einstellen: wann mehr Nachdenken lohnt und was es an Zeit und Tokens kostet
• Globale Einstellungen im Benutzerverzeichnis versus Projektkonfiguration im Ordner .pi
• Persönliche Pi-Arbeitsumgebung aufbauen: Standardmodell, Tastenkürzel, Themes
• Eigene Modelle und OpenAI-kompatible Endpunkte in der Modellkonfiguration eintragen

Sicherheit und kontrollierter Agentenzugriff in Pi

• Das Sicherheitsmodell von Pi: Befehle laufen standardmäßig ohne Rückfrage mit Ihren Benutzerrechten
• Vertrauen auf Projektebene bewusst vergeben: projektlokale Erweiterungen erst nach Prüfung laden
• Dateizugriffe kontrollieren: Arbeitsverzeichnis, Schreibrechte, Sicherung über Git
• Terminalzugriffe und ausführbare Befehle bewerten: harmlos, riskant, zerstörerisch
• Verfügbare Werkzeuge beim Start gezielt einschränken, etwa auf rein lesende Arbeit
• Risiken autonom arbeitender Agenten erkennen: Löschbefehle, Datenabfluss, Prompt Injection
• Berechtigungen passend zum Projekt gestalten: Freigabeprüfung statt Vollzugriff
• Pi optional in Docker isolieren: eingehängte Volumes, Netzwerk, Zugangsdaten
• Was beim Modellanbieter ankommt: Dateiinhalte, Befehlsausgaben und Sitzungsverlauf

Pi im täglichen Development Workflow

• Bestehende Projekte mit Pi erschließen: Struktur, Build, Einstiegspunkte
• Dateien und Verzeichnisse als Kontext verwenden und mit @ gezielt referenzieren
• Terminalbefehle durch den Agenten ausführen lassen und Ausgaben auswerten
• Code analysieren und Zusammenhänge über Module hinweg verstehen
• Features strukturiert entwickeln: kleiner Schritt, Test, nächster Schritt
• Bugs systematisch untersuchen: reproduzieren, eingrenzen, beheben, absichern
• Refactoring mit Pi durchführen: Umbenennen, Extrahieren, Abhängigkeiten lösen
• Ergebnisse prüfen statt KI-Code blind übernehmen: Diff, Tests, eigene Lektüre
• Bilder und Screenshots in die Session geben, z. B. Fehlermeldungen einer Oberfläche
• Pi nicht interaktiv im Druckmodus für Skripte und kleine Automatisierungen nutzen

Context Engineering in Pi statt Prompt-Zufall

• Warum guter Kontext mehr bewirkt als lange Prompts – gerade bei kurzem Systemprompt
• Relevante Dateien gezielt bereitstellen statt das ganze Repository einzulesen
• Anforderungen eindeutig formulieren: Ziel, Grenzen, Prüfbefehl
• Kontext klein und aussagekräftig halten: lange Ausgaben kürzen, Irrwege abschneiden
• Große Codebasen navigierbar machen: Übersichtsdateien, Modulgrenzen, Suchbefehle
• Arbeitsaufträge in Schritte zerlegen, die jeweils mit einem Test enden
• Planen ohne eingebauten Plan Mode: Plan als Markdown-Datei schreiben lassen und prüfen
• Kontextverlust und unnötigen Tokenverbrauch vermeiden; Kosten je Session beobachten
• Systemprompt projektweise ergänzen oder ersetzen – und die Folgen abschätzen

AGENTS.md als Betriebsanleitung für den Pi-Agenten

• Die Aufgabe der AGENTS.md: Projektwissen, das Pi bei jedem Start einliest
• Globale und lokale Instruktionen: Benutzerverzeichnis, übergeordnete Ordner, Projekt
• Projektregeln dauerhaft hinterlegen: Build, Tests, gesperrte Verzeichnisse
• Architekturkonventionen beschreiben: Schichten, Abhängigkeitsrichtung, Namensregeln
• Coding Standards definieren und auf Linter- und Formatter-Konfiguration verweisen
• Test- und Qualitätsanforderungen festlegen: was vor dem Abschluss grün sein muss
• Kurze Instruktionen statt überladener Regelwerke: jede Zeile kostet Kontext
• AGENTS.md als Teil einer agentenfreundlichen Codebasis, die auch andere Werkzeuge lesen

Pi Packages und zusätzliche Fähigkeiten

• Das Erweiterungskonzept: Packages bündeln Extensions, Skills, Prompt Templates und Themes
• Sinnvolle Packages auswählen und mit pi install aus npm oder Git einbinden
• Webzugriffe ergänzen: Suche und Seitenabruf als zusätzliche Werkzeuge
• Guardrails per Package: Freigabeabfragen und Sperrlisten für Befehle
• Subagents für komplexere Aufgaben über Erweiterungen nachrüsten
• Erweiterungen kontrolliert in Workflows einführen: global oder nur im Projekt, Versionen festhalten
• Nutzen und Risiken zusätzlicher Fähigkeiten bewerten: Quellcode vor der Installation lesen
• Einen eigenen Werkzeugkasten für typische Projekte zusammenstellen
• MCP-Server mit pi mcp add oder per mcp.json anbinden – seit Pi 0.99 eingebaut

Wiederverwendbare Pi-Agent-Skills entwickeln

• Vom einmaligen Prompt zum Skill: Anleitung, die Pi bei Bedarf nachlädt
• Geeignete Aufgaben für Skills finden: wiederkehrend, mehrschrittig, fehleranfällig
• Skills strukturiert beschreiben: SKILL.md mit Name, Beschreibung und Arbeitsschritten
• Entwicklungswissen mit Skripten und Referenzdateien im Skill-Ordner bündeln
• Projektworkflows als Skills modellieren: Release, Datenbankmigration, Changelog
• Skills für Analyse, Entwicklung und Qualitätssicherung einsetzen
• Persönliche und projektspezifische Skills trennen und passend ablegen
• Eigene Skill-Bibliothek aufbauen und im offenen Skill-Format mit anderen Agenten teilen

Prompt Templates für wiederkehrende Aufgaben

• Wiederkehrende Prompts sammeln und systematisieren
• Prompt Templates als Markdown-Dateien anlegen und per Slash-Befehl aufrufen
• Templates für Code-Reviews: Prüfkriterien, Ausgabeformat, Schweregrade
• Templates für Refactoring und Fehlersuche entwickeln
• Projektkontext einbeziehen: Dateiverweise und Hinweise auf Befehle im Template
• Anforderungen parametrisieren: Argumente beim Aufruf an das Template übergeben
• Templates mit Skills und AGENTS.md abstimmen: was gehört wohin?
• Vom improvisierten Prompting zum reproduzierbaren Ablauf im ganzen Team

Pi Extensions: den Coding Agent selbst erweitern

• Architektur der Extensions: TypeScript-Module mit Zugriff auf Ereignisse, Session und Oberfläche
• Eigene Tools registrieren: Parameter-Schema, Ausführung, Rückgabe an das Modell
• Benutzerdefinierte Commands entwickeln, z. B. für Deployment-Vorschau oder Ticketabruf
• Verhalten der Oberfläche beeinflussen: Statuszeile, Dialoge, eigene Darstellungen
• Permission Checks integrieren: Werkzeugaufrufe vor der Ausführung abfangen und bestätigen
• Projektwerkzeuge zugänglich machen: Testlauf, Datenbankabfrage, interne API
• Extensions sicher konzipieren: minimale Rechte, keine Geheimnisse im Code, saubere Fehler
• Pi mit Pi erweitern: Extensions und Konfiguration vom Agenten selbst schreiben lassen
• Extensions während der Entwicklung neu laden und testen, ohne die Session zu verlieren

Fortgeschrittenes Session-Management in Pi

• Sessions als Arbeitskontext: gespeicherter Verlauf mit Verzweigungen als Baum
• Bestehende Arbeit wieder aufnehmen: letzte Session fortsetzen oder aus der Liste wählen
• Nachrichten gezielt steuern: während der Arbeit eingreifen, korrigieren, abbrechen
• Folgeaufträge in eine Warteschlange stellen, die Pi nach dem aktuellen Schritt abarbeitet
• Sessions klonen, um vom gleichen Stand aus neu anzusetzen
• Alternative Lösungswege über Forks untersuchen und vergleichen
• Session Trees navigieren und zu einem früheren Punkt im Verlauf zurückspringen
• Lange Sessions durch Zusammenfassungen und Compaction beherrschbar halten
• Sessions exportieren und teilen, z. B. als HTML-Protokoll für Review oder Dokumentation

Pi ohne eingebaute Freigaben absichern

• Pi zuerst im Container starten: nur der Projektordner eingehängt, keine SSH-Schlüssel des Hosts
• Fremde Pi-Packages vor pi install lesen – Extensions laufen als Code mit vollen Rechten
• Eigene Freigabe-Extension für rm -rf, git push und Schreibzugriffe außerhalb des Projekts
• API-Schlüssel für Pi je Projekt trennen und Ausgabenlimits beim Anbieter setzen
• Vertrauliche Repositorys in Pi nur mit lokalem Modell bearbeiten

Praxisprojekt: Bootsreservierung für einen Ruderverein

• Bestehende Reservierungs-App des Vereins analysieren: Boote, Mannschaften, Sperrzeiten bei Hochwasser
• Projektregeln und Kontext definieren und eine eigene AGENTS.md erstellen
• Skills für Testlauf und Migration auswählen oder entwickeln, Review als Prompt Template anlegen
• Freigabe-Extension einbinden und ein Feature mit Fork für zwei Lösungswege umsetzen
• Die eigene Pi-Konfiguration als Package für künftige Projekte sichern und verbessern

Lernziele

• Sie installieren Pi, binden Cloud- und lokale Modelle an und wählen Modell und Thinking Level je Aufgabe
• Sie begrenzen Werkzeuge und Zugriffe von Pi und isolieren den Agenten bei Bedarf in einem Container
• Sie halten Projektregeln kurz in einer AGENTS.md fest und liefern Kontext so, dass Pi ohne eingebauten Plan Mode planvoll arbeitet
• Sie erstellen Skills und Prompt Templates und stellen Ihre Erweiterungen als Package zusammen
• Sie entwickeln eine Extension in TypeScript mit eigenem Tool, Command und Freigabeprüfung
• Sie steuern lange Arbeitssitzungen mit Warteschlange, Forks, Session Tree und Compaction

Zielgruppe

• Entwickler:innen, die einen anpassbaren Coding Agent mit eigenen Modellen und eigenen Regeln einsetzen wollen
• Entwickler:innen, die verstehen möchten, wie Coding-Agenten intern arbeiten, und eigene Werkzeuge dafür bauen
• Voraussetzungen: sicherer Umgang mit Terminal und Git; Grundkenntnisse in TypeScript für die Extensions