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

URL: https://agentvera.dev/de/blog/how-to-use-copilot-cli/ · Veröffentlicht: 2026-10-27

Copilot CLI nutzen: installieren, anmelden, Tarif prüfen, interaktiv oder mit -p ausführen, Tool-Berechtigungen setzen, Modelle wählen, MCP-Server und Regeln hinzufügen.

**Kurz gesagt:**

- Installiere Copilot CLI mit npm, Homebrew, WinGet oder dem Installationsskript, starte copilot in einem Projektordner, vertraue dem Ordner und melde dich mit /login an.
- Copilot fragt, bevor es Tools ausführt; Muster für --allow-tool und --deny-tool wie shell(git:*) legen Berechtigungen fest, und copilot -p führt einen einzelnen Prompt für Skripte und CI aus.
- /model wechselt das Modell, copilot mcp add verbindet MCP-Server, und AGENTS.md oder .github/copilot-instructions.md enthalten deine Projektregeln.

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](/de/blog/copilot-cli-vs-claude-code/ "Copilot CLI vs. Claude Code") die beiden direkt; dieser Artikel ist die Anleitung.

## Was Copilot CLI ist

Copilot CLI ist der [Coding-Agent](/de/glossary/coding-agent/ "Was ist ein 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.

| Tarif | Preis | Hinweise |
| --- | --- | --- |
| Copilot Free | Kostenlos | Begrenztes Kontingent an AI Credits |
| Copilot Student | Kostenlos | Für verifizierte Studierende |
| Copilot Pro | 10 $/Monat | Mehr Credits |
| Copilot Pro+ | 39 $/Monat | Mehr Credits |
| Copilot Max | 100 $/Monat | Das größte persönliche Kontingent |
| Business / Enterprise | 19 $ / 39 $ pro Platz | Von einer Organisation verwaltet |

Kommt dein Copilot von einer Organisation, kann ein Admin das CLI deaktivieren. Prüfe das zuerst, wenn es nicht starten will. Der [Vergleichsartikel](/de/blog/copilot-cli-vs-claude-code/ "Copilot CLI vs. Claude Code") geht genauer auf Credits und Preise ein.

## Schritt 2: Copilot CLI installieren

| Methode | Befehl |
| --- | --- |
| npm (Node.js 22 oder neuer) | `npm install -g @github/copilot` |
| Homebrew (macOS, Linux) | `brew install --cask copilot-cli` |
| WinGet (Windows) | `winget install GitHub.Copilot` |
| Installationsskript (macOS, Linux) | `curl -fsSL https://gh.io/copilot-install \| bash` |

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

```bash
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:

```text
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:

```text
/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)`:

| Muster | Trifft auf |
| --- | --- |
| `shell(git:*)` | Jeden `git`-Befehl (`git status`, `git log`…) |
| `shell(git push)` | Genau `git push` |
| `write` oder `write(src/*.ts)` | Dateischreibvorgänge, optional auf einen Pfad begrenzt |
| `read(.env)` | Lesen einer bestimmten Datei |
| `url(github.com)` | Abrufe von einer Domain |
| `MyMCP(create_issue)` | Ein Tool eines MCP-Servers |

```bash
# 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](/de/blog/ai-coding-agent-security/ "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:

```bash
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:

```yaml
- 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

| Befehl | Was er tut |
| --- | --- |
| `/model` | Wählt ein Modell oder `auto` |
| `/plan`, `/autopilot` | Erst planen oder bis zum Ende durchlaufen lassen |
| `/review` | Prüft die aktuellen Änderungen |
| `/diff` | Zeigt, was sich geändert hat |
| `/undo` (`/rewind`) | Kehrt zu einem früheren Punkt zurück |
| `/compact` | Fasst die Unterhaltung zusammen, um Kontext freizumachen |
| `/context`, `/usage` | Zeigt Kontext- und Credit-Verbrauch |
| `/clear` (`/new`) | Startet eine frische Unterhaltung |
| `/resume` | Setzt eine frühere Session fort |
| `/pr` | Zeigt, erstellt oder repariert einen Pull Request |
| `/delegate` | Übergibt die Aufgabe an Copilot auf GitHub, das einen Pull Request öffnet |
| `/mcp` | Listet, ergänzt und verwaltet MCP-Server |
| `/init` | Erstellt eine Datei mit eigenen Anweisungen |
| `/permissions` | Ändert die Freigaberegeln |

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:

```bash
# 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:

```json
{
  "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](/de/blog/what-is-mcp-server/ "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](/de/blog/claude-md-agents-md/ "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](/de/agents/copilot-cli/ "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](/de/features/mcp-manager/ "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](/de/features/workspace/ "Workspace") neben Claude Code oder Aider laufen, gib jedem Agenten aus dem [Git-Panel](/de/features/git-and-github/ "Git und GitHub") einen eigenen Worktree und bekomm am Ende jedes Turns ein [automatisches Code-Review](/de/features/code-review/ "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](/de/download/ "AgentVera herunterladen") 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](/de/blog/how-to-use-aider/ "Aider nutzen").

## Häufige Fragen

**Brauche ich einen kostenpflichtigen Tarif für Copilot CLI?** Nein. Mit Stand Oktober 2026 enthalten laut GitHub alle Copilot-Tarife Copilot CLI, auch Copilot Free und Copilot Student. Free bringt ein begrenztes Kontingent an GitHub AI Credits mit; Pro, Pro+, Max, Business und Enterprise enthalten mehr. Bekommst du Copilot über eine Organisation, kann ein Admin das CLI abschalten.

**Wie melde ich mich bei Copilot CLI an?** Starte copilot und tippe /login, oder führe copilot login in deiner Shell aus. Es öffnet eine Anmeldung im Browser mit deinem GitHub-Account. Für Skripte und CI kannst du einen Fine-grained Personal Access Token mit der Berechtigung Copilot Requests in COPILOT_GITHUB_TOKEN setzen.

**Wie verhindere ich, dass Copilot CLI jedes Mal um Freigabe bittet?** Wähle bei der Rückfrage „Yes, and approve for the rest of the session“, oder erlaube bestimmte Tools vorab mit --allow-tool, zum Beispiel --allow-tool='shell(git:*)'. --allow-all entfernt alle Rückfragen, was außerhalb einer Sandbox oder eines Containers riskant ist. Eine --deny-tool-Regel hat immer Vorrang vor einer Allow-Regel.

**Kann Copilot CLI auch andere Modelle als die von GitHub nutzen?** Ja. Neben den Modellen in /model unterstützt Copilot CLI Anbieter mit eigenem Key. Setze COPILOT_PROVIDER_BASE_URL, COPILOT_PROVIDER_TYPE, COPILOT_PROVIDER_API_KEY und COPILOT_MODEL, um einen OpenAI-kompatiblen, Azure- oder Anthropic-Endpoint zu nutzen, auch ein lokales Modell über Ollama.

**Wohin gehören Projektanweisungen für Copilot CLI?** In .github/copilot-instructions.md oder AGENTS.md im Root des Repositorys. Copilot CLI liest auch CLAUDE.md, GEMINI.md und Dateien unter .github/instructions/. Persönliche Regeln gehören in ~/.copilot/copilot-instructions.md. Mit /init erzeugst du eine erste Datei.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/