Kiro CLI verwenden: Schritt-für-Schritt-Anleitung

Um Kiro CLI zu verwenden, installierst du es mit curl -fsSL https://cli.kiro.dev/install | bash (auf macOS auch mit brew install kiro-cli), meldest dich im Browser an, startest kiro-cli in einem Projektordner und beschreibst, was du willst. Kiro liest deinen Code, bearbeitet Dateien und führt Befehle aus. Bevor es ein Tool nutzt, dem du noch nicht vertraust, fragt es nach. Mit /model wählst du ein Modell, oder du lässt Auto eingestellt und Kiro entscheiden.

Das ist der Grundablauf. Diese Anleitung behandelt den Rest: Anmeldung, die Chat-Befehle für jeden Tag, Modelle und Credits, Steering-Dateien, eigene Agenten, MCP-Server, Specs, Kiro in der CI und Kiro neben anderen Agenten. Alles hier folgt der offiziellen Kiro-Dokumentation mit Stand Oktober 2026.

Was Kiro ist

Kiro ist die agentische Entwicklungsumgebung von AWS. Es gibt sie in mehreren Formen, die sich ein Konto teilen: eine Desktop-IDE, die CLI und Kiro Web. Die CLI ist die Terminal-Seite. Sie bietet einen interaktiven Chat mit Vollbild-Terminal-Oberfläche, einen Headless-Modus für Skripte und CI, und sie kann als Agent für Editoren dienen, die das Agent Client Protocol (ACP) sprechen.

Was Kiro von anderen Coding-Agenten unterscheidet, ist der Fokus auf Specs. Bevor Kiro Code für ein Feature schreibt, kann es deine Idee in Anforderungen, ein Design und eine Aufgabenliste verwandeln und die Aufgaben dann abarbeiten. Ist dir der Ansatz neu, erklärt Spec-Driven Development mit KI-Agenten die Idee und vergleicht Kiro mit anderen Tools, die das können.

Ein Hinweis zu den Versionen: Der Installer liefert Kiro CLI 2.x. Version 3 ist eine frühe Version, die du mit kiro-cli --v3 ausprobieren kannst. Sie läuft neben deiner 2.x-Installation, und dein Setup bleibt, wie es ist, bis du wechselst. Diese Anleitung folgt 2.x und weist darauf hin, wo V3 abweicht.

Schritt 1: Kiro CLI installieren

Unter Linux gibt es außerdem ein .deb-Paket, ein AppImage und eine Zip-Datei. Die CLI braucht glibc 2.34 oder neuer; auf älteren Distributionen nimmst du die musl-Variante der Zip-Datei. Unter Windows führst du den Installer in PowerShell oder im Windows Terminal aus; die alte Eingabeaufforderung wird nicht unterstützt.

Prüfe, ob alles läuft:

kiro-cli doctor

kiro-cli update sucht nach einer neuen Version, und kiro-cli settings app.disableAutoupdates true schaltet die automatischen Updates ab. Mit Homebrew aktualisierst du über brew upgrade --greedy kiro-cli.

Schritt 2: anmelden

Nach der Installation öffnet Kiro den Browser zur Anmeldung. Zur Wahl stehen:

• GitHub oder Google: der schnellste Weg für Einzelpersonen.
• AWS Builder ID: eine kostenlose persönliche AWS-Identität.
• AWS IAM Identity Center: für Unternehmen, die Kiro über AWS verwalten. Du gibst die Start-URL und die Region deiner Organisation ein.
• Ein externer Identitätsanbieter: etwa Okta oder Microsoft Entra ID, wenn dein Unternehmen das eingerichtet hat.

Mit kiro-cli login meldest du dich jederzeit neu an. Auf einem entfernten Rechner ohne Browser gibt kiro-cli login --use-device-flow eine URL und einen Code aus, die du auf einem anderen Gerät öffnest. Der Device Flow funktioniert mit Builder ID, IAM Identity Center, Google und GitHub, aber nicht mit einem externen Identitätsanbieter. kiro-cli whoami zeigt, mit welchem Konto du angemeldet bist, kiro-cli logout meldet dich ab.

Gut zu wissen: Im Free-Tarif und in den Einzeltarifen darf Kiro deine Inhalte zur Verbesserung des Dienstes nutzen. Du kannst widersprechen; wie das geht, steht in der Kiro-Dokumentation.

Schritt 3: Chat-Grundlagen

Wechsle in ein Projekt und starte Kiro:

cd my-project
kiro-cli

Standard ist die Terminal-Oberfläche. Ein paar Dinge brauchst du ständig:

• @pfad hängt eine Datei an deine Nachricht.
• ! am Zeilenanfang führt einen Shell-Befehl direkt aus, zum Beispiel !npm test.
• Shift+Tab wechselt in den Plan-Modus, in dem Kiro eine Änderung durchdenkt, bevor es Code anfasst.
• Shift+Enter oder Ctrl+J beginnt eine neue Zeile, Ctrl+O klappt lange Ausgaben auf, Ctrl+C beendet.
• /paste fügt ein Bild aus der Zwischenablage ein.

Chats werden pro Ordner gespeichert. kiro-cli chat --resume setzt den letzten Chat im aktuellen Ordner fort, mit --resume-picker wählst du einen aus, --list-sessions listet sie auf. Wer die ältere zeilenweise Oberfläche mag, startet mit kiro-cli chat --classic.

Schritt 4: Modelle und Credits

Standardmäßig nutzt Kiro Auto, das jede Anfrage an ein passendes Modell weiterleitet. Die Dokumentation empfiehlt es für die meisten Aufgaben. Willst du selbst wählen, tippe im Chat /model oder liste die Modelle in der Shell auf:

kiro-cli chat --list-models

Ein Modell machst du in den Einstellungen zum Standard:

kiro-cli settings chat.defaultModel "claude-sonnet-4.6"

Kiro rechnet in Credits ab, und jedes Modell hat einen Multiplikator. Stand Oktober 2026 kostet Claude Opus 5 das 2,2-Fache, Claude Sonnet 5.5 das 1,3-Fache, DeepSeek 3.2 das 0,25-Fache und Qwen3 Coder Next das 0,05-Fache. Dieselbe Aufgabe kostet je nach Modell sehr unterschiedlich viel, also wirf ab und zu einen Blick auf /usage.

Bezahlte Tarife können über ihre Credits hinaus für 0,04 $ pro Credit weiterlaufen, und es gibt Zusatzpakete. Der Free-Tarif umfasst Open-Weight-Modelle und Claude Sonnet 4.5; für die neuesten Claude-Modelle brauchst du einen bezahlten Tarif. Preise und Modelle ändern sich oft, schau vor der Entscheidung auf kiro.dev/pricing.

Schritt 5: Steering-Dateien und AGENTS.md

Steering-Dateien sind Markdown-Dateien mit deinen Projektregeln: was das Produkt tut, der Tech-Stack, wo was liegt, was zu vermeiden ist. Kiro sucht sie an zwei Orten:

• Workspace: .kiro/steering/ im Projekt, zusammen mit dem Code eingecheckt.
• Global: ~/.kiro/steering/, für Regeln, die überall gelten sollen. Widersprechen sich beide, gewinnt der Workspace.

Die Dokumentation empfiehlt drei Dateien als Start: product.md, tech.md und structure.md. Eine Steering-Datei wird standardmäßig in jeden Chat einbezogen. Per Front Matter lässt sie sich auf bestimmte Dateien beschränken:

---
inclusion: fileMatch
fileMatchPattern: "components/**/*.tsx"
---

- Komponenten sind Funktionskomponenten mit benannten Exporten.
- Styles nutzen CSS-Module; keine Inline-Styles.

Es gibt vier Modi: always (Standard), fileMatch, manual (du holst die Datei mit #dateiname dazu) und auto (Kiro entscheidet anhand von Name und Beschreibung der Datei). Kiro CLI 2.x lädt nur always-Dateien automatisch; V3 unterstützt alle vier.

Kiro liest außerdem AGENTS.md und behandelt sie als Steering-Datei, die immer einbezogen wird. Pflegt dein Team schon eine für Codex, opencode oder andere Agenten, nutzt Kiro sie unverändert. Was hineingehört, steht in CLAUDE.md Best Practices.

Schritt 6: eigene Agenten

Ein eigener Agent ist ein gespeichertes Setup mit eigenem Prompt, Modell, Tools und Kontextdateien. Du legst ihn so an:

kiro-cli agent create my-agent

Agenten liegen in .kiro/agents/ (pro Projekt) oder ~/.kiro/agents/ (global), als JSON oder in V3 auch als Markdown. Ein kurzes Beispiel:

{
  "name": "my-agent",
  "description": "Reviews backend changes",
  "prompt": "You are a careful backend reviewer.",
  "model": "claude-sonnet-4.6",
  "includeMcpJson": true,
  "resources": ["file://.kiro/steering/**/*.md", "file://./ARCHITECTURE.md"]
}

Einen Chat mit ihm startest du per kiro-cli --agent my-agent, im Chat wechselst du mit /agent, und mit kiro-cli settings chat.defaultAgent my-agent wird er zum Standard. kiro-cli agent list zeigt deine Agenten, kiro-cli agent validate prüft eine Datei.

Zwei Stolperfallen. Erstens beziehen eigene Agenten Steering-Dateien nicht von selbst ein; deshalb steht .kiro/steering/**/*.md im Beispiel unter resources. Zweitens werden Agenten aus einem Projektordner erst geladen, wenn du diesem Workspace vertraust. Die Felder für Tool-Berechtigungen unterscheiden sich zwischen 2.x und V3; /upgrade-agent konvertiert einen Agenten beim Wechsel auf V3.

Schritt 7: MCP-Server

MCP-Server geben Kiro neue Tools: Doku-Suche, einen Browser, deinen Issue-Tracker. Sie gehören in eine mcp.json, entweder .kiro/settings/mcp.json im Projekt oder ~/.kiro/settings/mcp.json für alle Projekte:

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "disabled": false
    },
    "my-remote": {
      "url": "https://mcp.example.com/mcp"
    }
  }
}

Ein lokaler Server ist ein Befehl, den Kiro startet; ein entfernter Server ist eine URL (HTTPS oder HTTP auf localhost), optional mit headers und OAuth-Anmeldung. kiro-cli mcp add fügt in der Shell einen Server hinzu, kiro-cli mcp list zeigt die Konfiguration und kiro-cli mcp status, ob jeder Server läuft. Im Chat erledigt /mcp dasselbe und kümmert sich um Server, die eine Anmeldung verlangen.

Ist derselbe Server an mehreren Stellen definiert, schlägt die Einstellung eines Agenten die Workspace-Datei und die Workspace-Datei die globale. Jeder Server bringt Tools in den Kontext, also schalte nicht benötigte mit "disabled": true ab.

Schritt 8: Specs

Specs sind Kiros Markenzeichen. Für alles, was größer ist als ein schneller Fix, legst du eine an:

/spec new user-invitations

Kiro schreibt drei Dateien nach .kiro/specs/user-invitations/: requirements.md mit User Stories und Akzeptanzkriterien in EARS-Notation („Wenn X, soll das System Y“), design.md mit dem technischen Ansatz und tasks.md mit einer nummerierten Aufgabenliste. Lies und korrigiere jede Datei, bevor es weitergeht; genau diese Prüfung ist der Sinn der Sache. Dann lässt du Kiro die Aufgaben abarbeiten:

/spec run user-invitations

Die Spec-Dateien sind schlichtes Markdown. Checkst du sie ein, werden sie zur Dokumentation für die nächste Änderung. Bei kleineren Änderungen bietet der Plan-Modus (Shift+Tab oder /plan) eine leichtere Variante derselben Gewohnheit.

Schritt 9: Headless-Modus und CI

Für Skripte und CI läuft Kiro ohne Chat-Oberfläche:

export KIRO_API_KEY=your-key
kiro-cli chat --v3 --no-interactive --trust-tools=read_file,grep_search "Summarize the risky changes in this branch"

--trust-tools listet die Tools, die Kiro ohne Nachfrage nutzen darf (die Namen hier stammen aus V3, deshalb nutzt das Beispiel --v3, wie auch das GitHub-Actions-Beispiel der Dokumentation). --trust-all-tools erlaubt alles, also nur in einer Sandbox verwenden. --require-mcp-startup lässt den Lauf scheitern, wenn ein MCP-Server nicht startet. API-Schlüssel gibt es in den Tarifen Pro, Pro+, Pro Max und Power. Für Editoren mit ACP-Unterstützung startet kiro-cli acp Kiro als deren Agenten.

Häufige Stolperfallen

• Der Installer scheitert unter Windows. Du bist in der Eingabeaufforderung. Nutze PowerShell oder das Windows Terminal unter Windows 11.
• Das Programm startet auf einem älteren Linux nicht. glibc ist älter als 2.34. Nimm die musl-Zip-Datei.
• Deine Steering-Regeln werden ignoriert. Die Datei nutzt fileMatch oder auto, was 2.x nicht automatisch lädt, oder du bist in einem eigenen Agenten ohne die Steering-Ressource.
• Credits schmelzen schnell. Ein teures Modell oder ein langer Chat. Prüfe /usage, probier Auto und nutze /compact.
• AWS-Befehle funktionieren in V3 nicht mehr. V3 hat das eingebaute AWS-Tool entfernt; nutze stattdessen einen AWS-MCP-Server.
• Keine Option für einen API-Schlüssel. Der Headless-Modus braucht einen bezahlten Tarif.

Kiro CLI oder ein anderer Agent?

Kiro passt gut, wenn du gern mit Specs planst, wenn dein Unternehmen den Zugriff schon über AWS IAM Identity Center verwaltet oder wenn du Premium-Modelle und günstige Open-Weight-Modelle über eine Rechnung abdecken willst. Weniger passt es, wenn du deinen eigenen API-Schlüssel mitbringen oder lokale Modelle nutzen willst; das kann opencode mit jedem Anbieter. Zahlst du schon für Claude oder ChatGPT, nutzen Claude Code oder Codex CLI dieses Abo direkt. Die besten Claude-Code-Alternativen vergleicht die wichtigsten CLI-Agenten nebeneinander.

Kiro CLI neben anderen Agenten ausführen

Viele Teams entscheiden sich nicht für nur einen Agenten. Kiro schreibt die Spec, Claude Code oder Codex baut einen Teil, ein weiterer Agent prüft. Mit Terminal-Tabs wird das schnell unübersichtlich. AgentVera ist eine Desktop-App, die diese CLIs nebeneinander in echten Terminals ausführt, mit deinen eigenen Installationen und Logins. Die Kiro-CLI-Unterstützung funktioniert so:

• Dein Kiro-Login. AgentVera öffnet kiro-cli chat in einem echten Terminal. Du meldest dich mit kiro-cli login an; bist du abgemeldet, fordert dich das Terminal des Agenten zur Anmeldung auf.
• Modell und Effort pro Agent. Lass das Modell leer für Kiros Standard oder wähle pro Agent eines. Der Effort reicht von niedrig bis max.
• Regeln aus deinen Dateien. Kiro CLI hat kein Flag für zusätzliche Anweisungen, dauerhafte Anweisungen kommen also aus AGENTS.md oder Regeldateien im Projekt.
• Deine mcp.json bleibt deine. Die MCP-Server, die du in AgentVera hinzufügst, und der Browser von AgentVera werden bei jedem Start mit deiner eigenen Kiro-mcp.json zusammengeführt.
• Sessions laufen weiter. Setzt du einen Agenten fort, öffnet er sich mit seiner Session-ID oder der letzten Session des Ordners.
• Panes, Flows und Review. Lass Kiro im Raster des Workspace neben Claude Code oder Codex laufen, jeden in seinem eigenen Git-Worktree. Kiro-Agenten funktionieren in Flows, Broadcasts und geplanten Aufgaben und bekommen ein automatisches Code-Review, wenn ein Turn endet.

Raster, Worktrees, Code-Review und MCP-Manager gehören zum Free-Tarif; Flows gibt es in Pro und Team. Lade AgentVera herunter und probiere es aus.

Fazit

Um Kiro CLI zu verwenden, installierst du es, meldest dich an, startest kiro-cli in einem Projekt und beschreibst die Änderung. Lass das Modell auf Auto, bis du einen Grund hast, es zu ändern, und behalte /usage im Blick. Projektregeln kommen nach .kiro/steering/ oder in AGENTS.md, Tools in die mcp.json, wiederkehrende Setups in eigene Agenten. Für alles, was größer ist als ein schneller Fix, beginnst du mit /spec new: Anforderungen und eine Aufgabenliste zu prüfen, bevor Code entsteht, kann Kiro am besten.