GitHub Copilot CLI nutzen: Schritt-für-Schritt-Anleitung

Um GitHub Copilot CLI zu nutzen, installierst du es (npm install -g @github/copilot, Homebrew, WinGet oder das Installationsskript), startest copilot in einem Projektordner, bestätigst, dass du dem Ordner vertraust, meldest dich mit /login an und beschreibst die Aufgabe in normaler Sprache. Copilot liest deinen Code, schlägt Edits und Befehle vor und fragt, bevor es etwas ausführt.

Das ist der Grundablauf. Diese Anleitung deckt ab, was du nach der ersten Session brauchst: welchen Tarif du brauchst, interaktive und programmatische Nutzung, Tool-Berechtigungen, die wichtigsten Slash-Befehle, Modelle, MCP-Server und eigene Anweisungen. Alles hier folgt der offiziellen GitHub-Dokumentation auf docs.github.com mit Stand Oktober 2026. Wenn du noch einen Agenten auswählst, vergleicht Copilot CLI vs. Claude Code die beiden direkt; dieser Artikel ist die Anleitung.

Was Copilot CLI ist

Copilot CLI ist der Coding-Agent von GitHub für das Terminal. Er arbeitet in dem Ordner, in dem du ihn startest: Er kann Dateien lesen und ändern, Shell-Befehle ausführen und über einen eingebauten GitHub-MCP-Server mit GitHub sprechen, sich also auch Issues und Pull Requests ansehen. Er läuft unter Linux, macOS und Windows (PowerShell und WSL).

Schritt 1: deinen Tarif prüfen

Mit Stand Oktober 2026 enthalten laut GitHubs Tarifseite alle Copilot-Tarife Copilot CLI. Die Nutzung wird in GitHub AI Credits gezählt, und wie schnell du sie verbrauchst, hängt vom Modell und vom Umfang der Arbeit ab.

Kommt dein Copilot von einer Organisation, kann ein Admin das CLI deaktivieren. Prüfe das zuerst, wenn es nicht starten will. Der Vergleichsartikel geht genauer auf Credits und Preise ein.

Schritt 2: Copilot CLI installieren

Unter Windows brauchst du PowerShell 6 oder neuer. Ist in deiner npm-Konfiguration ignore-scripts gesetzt, installierst du mit npm_config_ignore_scripts=false npm install -g @github/copilot. /update in einer Session aktualisiert das CLI.

Schritt 3: starten und anmelden

cd ~/code/my-project
copilot

Wenn du Copilot zum ersten Mal in einem Ordner startest, fragt es, ob du den Dateien darin vertraust. Du kannst ihm für diese Session vertrauen, vertrauen und die Wahl merken lassen, oder ablehnen. In vertrauenswürdigen Verzeichnissen darf Copilot lesen, ändern und ausführen, starte es also im Projektordner und nicht in deinem Home-Ordner.

Bist du nicht angemeldet, tippst du /login und folgst dem Ablauf im Browser. Aus einer normalen Shell macht copilot login dasselbe, mit --device-code für Rechner ohne Browser. Für Automatisierung liest Copilot einen Token aus COPILOT_GITHUB_TOKEN, dann GH_TOKEN, dann GITHUB_TOKEN; ein Fine-grained Personal Access Token braucht die Berechtigung „Copilot Requests“. /user zeigt oder wechselt den angemeldeten Account, /logout meldet dich ab.

Schritt 4: interaktiv arbeiten

Tippe, was du willst:

Finde die Stelle, an der wir E-Mail-Adressen validieren, füge einen Test
für Adressen mit Pluszeichen hinzu und führe die Testsuite aus.

Ein paar Eingabe-Tricks:

• @path/to/file fügt eine Datei in den Prompt ein.
• !command führt einen Shell-Befehl direkt aus, ohne ihn an das Modell zu schicken.
• Shift+Tab schaltet durch die Modi. Im Plan-Modus stellt Copilot Rückfragen und erstellt einen Plan, bevor es Code schreibt. /plan macht dasselbe aus dem Prompt heraus.
• /autopilot lässt Copilot selbstständig weiterarbeiten, bis die Aufgabe erledigt ist, und /ask (oder /btw) stellt eine Nebenfrage, ohne die Aufgabe zu unterbrechen.

Bei allem, was mehr als ein paar Dateien betrifft, planst du zuerst:

/plan Teile den 900 Zeilen langen OrderService in kleinere Services auf.
Lass die öffentliche API gleich und liste jede Datei auf, die du anfasst.

Schritt 5: Freigaben und Tool-Berechtigungen

Will Copilot ein Tool ausführen, das etwas verändern kann (einen Shell-Befehl, einen Dateischreibvorgang, einen URL-Abruf), fragt es nach. Du kannst einmal freigeben, das Tool für den Rest der Session freigeben oder ablehnen und sagen, was es stattdessen tun soll.

Um vorab zu entscheiden, nutzt du Berechtigungsmuster der Form Kind(argument):

# git is fine, pushing is not
copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'

# allow everything except deleting files and pushing
copilot --allow-all-tools --deny-tool='shell(rm)' --deny-tool='shell(git push)'

Deny-Regeln gewinnen immer, sogar gegen --allow-all. In einer Session wechselt /permissions zwischen den Berechtigungsmodi (default, assisted, allow-all), und /permissions show zeigt den aktuellen Modus; /sandbox enable schaltet die Sandbox ein. --allow-all (Alias --yolo) entfernt jede Rückfrage, heb dir das also für Wegwerf-Container auf. Sicherheit von KI-Coding-Agenten erklärt, warum.

Schritt 6: programmatische Nutzung mit -p

Für Skripte und CI führt -p einen Prompt aus und beendet sich. -s gibt nur die Antwort aus, und weil niemand da ist, der freigibt, erlaubst du die Tools vorab:

copilot -p 'Write a commit message in plain text for the staged changes' \
  -s --allow-tool='shell(git:*)'

copilot -p 'Write unit tests for src/utils/validators.ts' \
  --allow-tool='write, shell(npm:*), shell(npx:*)'

Du kannst einen Prompt auch per Pipe übergeben: echo "Explain this file: ./complex.ts" | copilot. Nützliche Extras: --no-ask-user verhindert, dass Copilot Fragen stellt, --output-format=json gibt JSON-Zeilen aus, und --share=PATH speichert die Session als Markdown. Am Ende eines Laufs gibt Copilot einen Hinweis copilot --resume=SESSION-ID aus, damit du interaktiv weitermachen kannst.

In GitHub Actions legst du einen Token mit der Berechtigung Copilot Requests in COPILOT_GITHUB_TOKEN ab:

- name: Coverage summary
  env:
    COPILOT_GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
  run: copilot -p "Run the test suite and produce a coverage summary" -s --allow-tool='shell(npm:*), write' --no-ask-user

Schritt 7: die Slash-Befehle, die du kennen solltest

Aus der Shell macht copilot --resume (oder --continue für die letzte Session) dort weiter, wo du aufgehört hast, und -n NAME benennt eine Session, damit du sie per Name fortsetzen kannst.

Schritt 8: ein Modell wählen

/model öffnet die Modellauswahl; --model=NAME oder die Umgebungsvariable COPILOT_MODEL setzt es beim Start, und mit auto wählt Copilot selbst. --effort (oder --reasoning-effort) setzt low, medium, high, xhigh oder max für Modelle, die das unterstützen. Verschiedene Modelle verbrauchen AI Credits unterschiedlich schnell, und lange Kontexte und mehr Reasoning kosten mehr, ein gelegentlicher Blick auf /usage lohnt sich also.

Du kannst auch deinen eigenen Modellanbieter mitbringen. Setze COPILOT_PROVIDER_BASE_URL, COPILOT_PROVIDER_TYPE (openai, azure oder anthropic), COPILOT_PROVIDER_API_KEY und COPILOT_MODEL. Das funktioniert mit Ollama für lokale Modelle, solange das Modell Tool-Calling und Streaming unterstützt; GitHub empfiehlt ein Kontextfenster von 128k Tokens oder mehr. copilot help providers listet die Details.

Schritt 9: MCP-Server hinzufügen

Der GitHub-MCP-Server ist schon eingerichtet. Weitere fügst du über das CLI oder mit /mcp add in einer Session hinzu:

# a local server started with a command
copilot mcp add my-server -- npx -y @example/mcp-server

# a remote server over HTTP
copilot mcp add --transport http my-remote https://mcp.example.com/mcp

Server werden in ~/.copilot/mcp-config.json gespeichert, und eine .mcp.json im Repository fügt Server für dieses Projekt hinzu:

{
  "mcpServers": {
    "my-internal-server": {
      "command": "npx",
      "args": ["-y", "@example/mcp-server"],
      "tools": ["*"]
    }
  }
}

tools legt fest, welche Tools des Servers Copilot aufrufen darf; ["*"] bedeutet alle. copilot mcp list zeigt, was eingerichtet ist, und --additional-mcp-config fügt Server für eine einzelne Session hinzu. Neu bei MCP? Fang mit was ist ein MCP-Server an.

Schritt 10: eigene Anweisungen

Copilot CLI führt Anweisungen aus mehreren Quellen zusammen:

• AGENTS.md, CLAUDE.md und GEMINI.md im Root des Repositorys und im aktuellen Ordner
• .github/copilot-instructions.md
• .github/instructions/**/*.instructions.md, die sich mit applyTo: im Frontmatter auf bestimmte Pfade begrenzen lassen
• ~/.copilot/copilot-instructions.md für persönliche Regeln über alle Projekte hinweg

/init (oder copilot init) schreibt anhand deines Repos eine erste .github/copilot-instructions.md. Halte sie kurz: Build- und Testbefehle, Konventionen und Dinge, die der Agent nicht tun darf. Pflegst du schon eine AGENTS.md für andere Agenten, nutzt Copilot sie so, wie sie ist. CLAUDE.md und AGENTS.md gibt Tipps, wie du Regeln schreibst, an die sich Agenten wirklich halten. Um eine Session ohne diese Dateien zu starten, übergib --no-custom-instructions.

Häufige Stolperfallen

• Im Home-Ordner starten. Vertraue nur dem Projektverzeichnis; Copilots Dateizugriff folgt den vertrauenswürdigen Verzeichnissen.
• In CI zu viel erlauben. --allow-all in einer Pipeline mit Secrets fordert Ärger heraus. Erlaube nur die Tools, die der Job braucht, und verbiete git push, außer der Job soll pushen.
• Die Token-Berechtigung vergessen. Ein Personal Access Token ohne „Copilot Requests“ authentifiziert nicht, und Tokens im Besitz einer Organisation werden nicht unterstützt.
• Eine endlose Session. Lange Unterhaltungen kosten mehr Credits. Nutze /compact oder /clear zwischen Aufgaben, die nichts miteinander zu tun haben.
• MCP-Tools ohne tools erwarten. Ein Server-Eintrag braucht eine tools-Liste; mit ["*"] gibst du alles frei.

Copilot CLI in AgentVera ausführen

AgentVera ist eine Desktop-App für macOS, Windows und Linux, die CLI-Agenten nebeneinander in echten Terminals ausführt, mit deinen eigenen Installationen und Logins. Copilot CLI ist einer der unterstützten Agenten; die Seite Copilot CLI in AgentVera hat die Details:

• Dein GitHub-Login. Copilot nutzt seine eigene Anmeldung. Ist es abgemeldet, führst du /login im Terminal des Agenten aus; ein bestehendes Copilot-Abo reicht.
• Modell und Effort pro Agent. Das Modell wird mit --model übergeben, der Effort von minimal bis max mit --reasoning-effort.
• Sessions, die zurückkommen. Jeder Agent bekommt eine eigene Session-ID, und eine gespeicherte Session öffnet sich nach einem Neustart mit --resume wieder. /compact funktioniert wie gewohnt.
• MCP ohne Konfiguration bearbeiten. Server aus dem MCP-Manager von AgentVera und seinem Browser werden bei jedem Start mit --additional-mcp-config hinzugefügt, deine mcp-config.json bleibt also unberührt. Die Rolle des Agenten kommt als zusätzlicher Anweisungsordner dazu.
• Panels, Worktrees und Review. Lass Copilot im Raster des Workspace neben Claude Code oder Aider laufen, gib jedem Agenten aus dem Git-Panel einen eigenen Worktree und bekomm am Ende jedes Turns ein automatisches Code-Review. Copilot-Agenten funktionieren auch in Flows (Pro und Team), Broadcasts und geplanten Aufgaben.

Raster, Worktrees, Code-Review und MCP-Manager gehören zum Free-Tarif. Lade AgentVera herunter und probiere es aus.

Fazit

Installiere Copilot CLI, starte copilot in deinem Projekt, vertraue dem Ordner und melde dich mit /login an. Plane größere Änderungen mit Shift+Tab oder /plan, erlaube nur die Tools, bei denen du dich wohlfühlst, und nutze copilot -p mit expliziten --allow-tool-Regeln für Skripte und CI. Schreib deine Regeln in die AGENTS.md oder .github/copilot-instructions.md und füge MCP-Server hinzu, wenn du sie brauchst. Wenn du außerdem einen Git-zentrierten Agenten willst, der mit jedem Modell arbeitet, lies Aider nutzen.