Git in der IDE: VS Code, Neovim und JetBrains im Vergleich

Im GitLab-Workflow-Post haben wir Git auf der Kommandozeile genutzt – Branches erstellt, Commits geschrieben, Merge Requests angelegt. Alles funktioniert, aber der Workflow hat einen Haken: du springst ständig zwischen Terminal und Editor hin und her.

Im CI/CD-Post ging es um Automatisierung – Pipelines, Runner, Deployment. Aber auch dort hast du wahrscheinlich die Pipeline-Ergebnisse im Browser geprüft, während der Code im Editor offen war.

Dieses ständige Kontextwechseln kostet Zeit und Konzentration. Die Lösung: Git direkt im Editor nutzen. Statt git diff, git add -p und git commit im Terminal einzutippen, kannst du alles in deiner IDE erledigen – mit visuellen Diffs, Inline-Blame und sogar Merge-Conflict-Resolution.

In diesem Post vergleichen wir die drei großen Editoren – VS Code, Neovim (mit LazyVim) und JetBrains IDEs – und schauen uns an, wie gut sie Git integrieren. Dazu kommen Terminal-Tools wie LazyGit und delta, die den Workflow nochmals verbessern.

Wir schauen uns für jeden Editor an:

• Wie sieht der tägliche Git-Workflow aus?
• Welche Plugins brauchst du?
• Wie löst du Merge-Konflikte?
• Wie gut ist die GitLab-Integration?
• Welche Keyboard-Shortcuts solltest du kennen?

Alle Konfigurationen sind praxiserprobt und laufen in meinem Homelab. Die GitLab-Integration bezieht sich auf eine self-hosted Instanz, funktioniert aber genauso mit gitlab.com.

Warum Git-Integration im Editor?

Jeder Kontextwechsel zwischen Editor und Terminal kostet dich mentale Energie. Studien zeigen, dass Entwickler nach einer Unterbrechung bis zu 15 Minuten brauchen, um wieder in den Flow zu kommen. Ein kurzer git status im Terminal klingt harmlos – aber wenn du das 50 Mal am Tag machst, summiert sich das.

Dabei geht es nicht nur um die Sekunden, die du für den Fensterwechsel brauchst. Es geht um den mentalen Kontextwechsel: Du denkst gerade über eine Funktion nach, wechselst ins Terminal, tippst git diff, siehst den Output, musst dich erinnern welche Dateien du stagen wolltest, gehst zurück zum Editor… und hast vergessen, was du gerade machen wolltest.

Manueller vs. integrierter Workflow

graph LR
    subgraph "Manueller Workflow"
        A1[Code schreiben] --> B1[Zum Terminal wechseln]
        B1 --> C1[git diff]
        C1 --> D1[git add -p]
        D1 --> E1[git commit]
        E1 --> F1[Zurück zum Editor]
        F1 --> G1[Browser: MR prüfen]
        G1 --> H1[Zurück zum Editor]
    end

    subgraph "Integrierter Workflow"
        A2[Code schreiben] --> B2[Gutter: Änderungen sehen]
        B2 --> C2[Hunks stagen]
        C2 --> D2[Commit im Editor]
        D2 --> E2[Pipeline-Status in Statusbar]
    end

Was macht gute Git-Integration aus?

Eine IDE sollte diese Git-Funktionen bieten:

• Visual Diff – Änderungen nicht nur als Text, sondern farblich hervorgehoben
• Partial Staging – Einzelne Zeilen oder Hunks stagen, nicht nur ganze Dateien
• Inline Blame – Sofort sehen, wer welche Zeile wann geändert hat
• Merge-Conflict-Resolution – 3-Way-Merge mit visueller Unterstützung
• Branch Management – Branches erstellen, wechseln, löschen ohne Terminal
• Commit History – Log und Graph im Editor navigieren
• Remote Integration – Push, Pull, Fetch ohne Terminal
• GitLab/GitHub-Integration – Merge Requests, Issues, Pipeline-Status direkt im Editor

Je weniger du den Editor verlassen musst, desto besser. Das Ziel ist nicht, das Terminal abzuschaffen – sondern den häufigsten Workflow zu beschleunigen.

VS Code

VS Code ist der Einstieg für die meisten Entwickler – und die Git-Integration ist ein großer Grund dafür. Schon out-of-the-box bekommst du eine solide Basis, die sich mit Extensions massiv erweitern lässt.

Built-in Source Control

VS Code bringt von Haus aus einen Source-Control-View mit (Ctrl+Shift+G). Das ist der schnellste Weg, um den aktuellen Git-Status zu sehen – ohne das Terminal zu öffnen. Dort siehst du:

• Changes – Alle geänderten Dateien
• Staged Changes – Bereits zum Commit vorgemerkte Dateien
• Merge Changes – Dateien mit Konflikten

Du kannst Dateien per Klick stagen (+), unstagen (-) und committen. Die Commit-Message schreibst du direkt im Input-Feld.

# Diese Aktionen kannst du alle im Source Control View erledigen:
git add file.txt          # → Klick auf "+"
git reset HEAD file.txt   # → Klick auf "-"
git commit -m "message"   # → Message eingeben + Ctrl+Enter
git push                  # → "..." Menü → Push

Diff Viewer

Der integrierte Diff Viewer ist einer der Stärken von VS Code. Du kannst zwischen zwei Modi wechseln:

• Inline Diff – Änderungen direkt im Code, rot/grün markiert
• Side-by-Side Diff – Alter und neuer Stand nebeneinander

Das Besondere: Partial Staging funktioniert direkt im Diff View. Du kannst einzelne Zeilen oder Hunks stagen, ohne git add -p im Terminal zu nutzen. Einfach den gewünschten Bereich markieren und mit Rechtsklick „Stage Selected Ranges” wählen.

Partial Staging im Diff View ist ein Game-Changer. Du kannst sauber getrennte Commits erstellen, auch wenn du an mehreren Stellen gleichzeitig gearbeitet hast.

GitLens Extension

GitLens ist die wichtigste Git-Extension für VS Code. Sie erweitert die Git-Integration massiv:

Inline Blame: Am Ende jeder Zeile siehst du, wer sie wann geändert hat – dezent in grau. Hover zeigt den kompletten Commit mit Message und Diff.

File History: Zeigt die komplette Geschichte einer Datei mit allen Commits und Diffs.

Repository Graph: Eine visuelle Darstellung des Git-Graphen mit Branches, Merges und Tags. Vergleichbar mit git log --graph, aber interaktiv.

Interactive Rebase: GitLens bietet einen visuellen Editor für Interactive Rebase. Du kannst Commits per Drag & Drop umsortieren und Aktionen (pick, squash, reword, drop) per Dropdown auswählen.

{
  "gitlens.currentLine.enabled": true,
  "gitlens.currentLine.format": "${author}, ${agoOrDate}",
  "gitlens.codeLens.enabled": true,
  "gitlens.codeLens.authors.enabled": true,
  "gitlens.hovers.currentLine.over": "line",
  "gitlens.hovers.annotations.details": true,
  "gitlens.graph.layout": "editor",
  "gitlens.views.repositories.branches.layout": "tree"
}

Merge Conflict Resolution

VS Code erkennt Merge-Konflikte automatisch und zeigt oberhalb jedes Konflikts Buttons:

• Accept Current Change – Deine lokale Version
• Accept Incoming Change – Die Version aus dem Branch
• Accept Both Changes – Beide Versionen behalten
• Compare Changes – Side-by-Side-Vergleich

Für komplexere Konflikte gibt es seit VS Code 1.69 den 3-Way Merge Editor. Du aktivierst ihn über:

{
  "git.mergeEditor": true
}

Der 3-Way Merge Editor zeigt drei Panels:

1. Current (links) – Dein Branch
2. Incoming (rechts) – Der andere Branch
3. Result (unten) – Das Ergebnis, das du bearbeitest

Der 3-Way Merge Editor in VS Code hat sich massiv verbessert. Für die meisten Konflikte brauchst du kein externes Tool mehr.

GitLab Workflow Extension

Die GitLab Workflow Extension verbindet VS Code direkt mit deiner GitLab-Instanz:

• Merge Requests erstellen und reviewen
• Pipeline-Status in der Statusbar
• Issues durchsuchen und zuweisen
• Snippets erstellen und abrufen
• CI/CD-Variablen verwalten

{
  "gitlab.instanceUrl": "https://gitlab.example.com",
  "gitlab.token": "glpat-xxxxxxxxxxxxxxxxxxxx",
  "gitlab.showPipelineUpdateNotifications": true,
  "gitlab.pipelineGitRemoteName": "origin"
}

Speichere den GitLab-Token nicht direkt in settings.json, sondern nutze den VS Code Secret Storage. Die Extension fragt beim ersten Start automatisch danach.

Git Graph Extension

Git Graph bietet einen interaktiven Git-Log-Graphen. Im Vergleich zu GitLens’ Graph ist er leichtgewichtiger und schneller. Du kannst:

• Branches visuell verfolgen
• Commits anklicken und Details sehen
• Cherry-Pick, Revert und Reset direkt ausführen
• Tags erstellen und löschen
• Branches vergleichen

Keyboard Shortcuts

Aktion	Shortcut
Source Control öffnen	Ctrl+Shift+G
Datei stagen	Ctrl+Shift+G, dann +
Commit	Ctrl+Enter (im SCM Input)
Git Graph öffnen	Ctrl+Shift+P → “Git Graph”
Inline Diff anzeigen	Klick auf Gutter-Indicator
Nächste Änderung	Alt+F5
Vorherige Änderung	Shift+Alt+F5
Blame anzeigen (GitLens)	Ctrl+Shift+P → “Toggle File Blame”

Empfohlene Git-Settings

{
  "git.autofetch": true,
  "git.autofetchPeriod": 120,
  "git.confirmSync": false,
  "git.enableSmartCommit": true,
  "git.smartCommitChanges": "tracked",
  "git.pruneOnFetch": true,
  "git.pullBeforeCheckout": true,
  "git.mergeEditor": true,
  "diffEditor.renderSideBySide": true,
  "diffEditor.ignoreTrimWhitespace": false,
  "scm.defaultViewMode": "tree"
}

git.enableSmartCommit sorgt dafür, dass bei einem Commit ohne gestage Dateien automatisch alle geänderten tracked Files gestaged werden. Praktisch für schnelle Commits, aber Vorsicht bei großen Repos.

Neovim / LazyVim

Neovim mit LazyVim ist das Setup für Leute, die das Terminal lieben und trotzdem eine vollwertige IDE wollen. Die Git-Integration ist nicht built-in, sondern wird über Plugins zusammengestellt – was maximale Flexibilität bietet.

LazyVim ist eine Neovim-Konfiguration, die die besten Plugins vorkonfiguriert mitbringt. Du bekommst ein IDE-ähnliches Erlebnis, ohne alles selbst konfigurieren zu müssen.

fugitive.vim

fugitive.vim von Tim Pope ist das Git-Plugin für Vim/Neovim. Es ist seit Jahren der Standard und bietet eine nahtlose Integration:

Git Status mit :Git (oder :G):

Head: feature/new-api
Push: origin/feature/new-api

Staged (2)
M  src/api/handler.go
A  src/api/routes.go

Unstaged (1)
M  src/config/settings.yaml

In diesem Buffer kannst du:

• s – Datei stagen
• u – Datei unstagen
• = – Inline-Diff anzeigen
• cc – Commit starten
• ca – Commit amend
• dd – Diff in Split öffnen
• X – Änderungen verwerfen (checkout)

Git Blame mit :Git blame:

# Zeigt Blame-Annotations am linken Rand
:Git blame

# Blame für eine bestimmte Zeile -- Enter auf der Annotation öffnet den Commit

Git Diff mit :Gvdiffsplit:

# Diff der aktuellen Datei gegen HEAD
:Gvdiffsplit

# Diff gegen einen bestimmten Branch
:Gvdiffsplit main

# Diff gegen einen bestimmten Commit
:Gvdiffsplit HEAD~3

Merge Conflicts mit fugitive

Für Merge-Konflikte bietet fugitive einen 3-Way-Diff:

# 3-Way-Merge-Diff öffnen
:Gvdiffsplit!

Das öffnet drei vertikale Splits:

1. Links – Target-Branch (ours)
2. Mitte – Working Copy (das Ergebnis)
3. Rechts – Merge-Branch (theirs)

Du navigierst mit ]c und [c zwischen Konflikten und übernimmst Änderungen mit:

" Änderung vom linken Buffer (ours) übernehmen
:diffget //2

" Änderung vom rechten Buffer (theirs) übernehmen
:diffget //3

" Nach dem Lösen aller Konflikte
:Gwrite
:Git commit

Der 3-Way-Diff in fugitive braucht Eingewöhnung, ist aber extrem mächtig. Tipp: Nutze :diffupdate wenn die Hervorhebung nach Änderungen nicht mehr stimmt.

gitsigns.nvim

gitsigns.nvim zeigt Git-Änderungen direkt im Gutter (am linken Rand) an:

• Grüne Linie – Neue Zeilen
• Rote Linie – Gelöschte Zeilen
• Blaue Linie – Geänderte Zeilen

LazyVim bringt gitsigns bereits vorkonfiguriert mit. Die wichtigsten Keybindings:

Aktion	Keybinding
Nächster Hunk	]h
Vorheriger Hunk	[h
Hunk stagen	<leader>ghs
Hunk unstagen	<leader>ghu
Hunk-Vorschau	<leader>ghp
Blame der Zeile	<leader>ghb
Diff gegen Index	<leader>ghd
Alle Hunks stagen	<leader>ghS
Hunk zurücksetzen	<leader>ghr

-- Erweiterte gitsigns-Konfiguration (optional)
return {
  "lewis6991/gitsigns.nvim",
  opts = {
    signs = {
      add          = { text = "▎" },
      change       = { text = "▎" },
      delete       = { text = "▁" },
      topdelete    = { text = "▔" },
      changedelete = { text = "▎" },
    },
    current_line_blame = true,
    current_line_blame_opts = {
      delay = 300,
      virt_text_pos = "eol",
    },
    current_line_blame_formatter = "<author>, <author_time:%R> - <summary>",
  },
}

diffview.nvim

diffview.nvim ist ein Diff-Browser, der an die Diff-Ansicht von VS Code erinnert:

" Diff aller uncommitted Änderungen
:DiffviewOpen

" Diff gegen einen Branch
:DiffviewOpen main

" Diff zwischen zwei Commits
:DiffviewOpen HEAD~3..HEAD

" File History der aktuellen Datei
:DiffviewFileHistory %

" File History des gesamten Repos
:DiffviewFileHistory

Die Ansicht zeigt links eine Dateiliste und rechts den Diff. Du navigierst mit Tab zwischen den Dateien und ]x / [x zwischen den Konflikten.

diffview.nvim ist besonders nützlich für Code Reviews: Du öffnest den Diff gegen den Main-Branch (DiffviewOpen main) und siehst alle Änderungen übersichtlich aufgelistet – genau wie in einer Merge Request auf GitLab, aber direkt in Neovim.

-- diffview.nvim Konfiguration
return {
  "sindrets/diffview.nvim",
  cmd = { "DiffviewOpen", "DiffviewFileHistory" },
  keys = {
    { "<leader>gd", "<cmd>DiffviewOpen<cr>", desc = "Diff View" },
    { "<leader>gh", "<cmd>DiffviewFileHistory %<cr>", desc = "File History" },
    { "<leader>gH", "<cmd>DiffviewFileHistory<cr>", desc = "Repo History" },
  },
  opts = {
    enhanced_diff_hl = true,
    view = {
      merge_tool = {
        layout = "diff3_mixed",
      },
    },
  },
}

Telescope Git Integration

Telescope ist der Fuzzy Finder in LazyVim und bietet mehrere Git-Picker:

Befehl	Keybinding (LazyVim)	Beschreibung
git_commits	<leader>gc	Commits durchsuchen
git_bcommits	<leader>gC	Commits der aktuellen Datei
git_branches	<leader>gb	Branches wechseln
git_status	<leader>gs	Geänderte Dateien
git_stash	<leader>gS	Stash-Liste

LazyGit im Floating Terminal

Das Killer-Feature für Neovim-Nutzer: LazyGit direkt im Floating Terminal. In LazyVim ist das bereits konfiguriert:

# LazyGit öffnen
<leader>gg

Das öffnet LazyGit in einem Floating Terminal über dem Editor. Du hast die volle LazyGit-Funktionalität, ohne Neovim zu verlassen. Nach dem Schließen bist du sofort wieder im Code.

Das ist der effizienteste Git-Workflow in Neovim: Code schreiben, <leader>gg drücken, stagen, committen, pushen, q zum Schließen – und du bist wieder im Code. Keine Kontextwechsel, keine Mausbewegungen.

graph TD
    A[Neovim: Code schreiben] --> B{"Änderung committen?"}
    B -->|Einzelner Hunk| C[gitsigns: leader+ghs]
    B -->|Mehrere Dateien| D[LazyGit: leader+gg]
    B -->|Komplexer Merge| E[fugitive: Gvdiffsplit!]
    C --> F[Commit via fugitive :Git commit]
    D --> G[Stage + Commit in LazyGit]
    E --> H[diffget + Gwrite]
    F --> A
    G --> A
    H --> F

Neovim + LazyGit ist ideal für die Arbeit auf Homelab-VMs per SSH. Kein X-Server nötig, kein Port-Forwarding, kein Remote-Desktop. Du brauchst nur eine SSH-Verbindung.

Neovim Git-Workflow zusammengefasst

-- Alle Git-bezogenen Keybindings in LazyVim (Auswahl)
-- <leader>gg    → LazyGit (Floating Terminal)
-- <leader>gG    → LazyGit (cwd)
-- <leader>gb    → Git Blame (Zeile)
-- <leader>gB    → Git Browse
-- <leader>gf    → LazyGit File History
-- <leader>gl    → LazyGit Log
-- <leader>ghs   → Stage Hunk
-- <leader>ghr   → Reset Hunk
-- <leader>ghS   → Stage Buffer
-- <leader>ghR   → Reset Buffer
-- <leader>ghp   → Preview Hunk
-- <leader>ghb   → Blame Line
-- <leader>ghd   → Diff This

JetBrains

JetBrains IDEs (IntelliJ, WebStorm, PyCharm, GoLand, etc.) haben die beste Git-Integration aller Editoren – out of the box, ohne Plugins. Alles ist nahtlos integriert und visuell aufbereitet.

Git Tool Window

Das Git Tool Window (Alt+9) ist die Zentrale für alle Git-Operationen. Du siehst:

• Log Tab – Interaktiver Git-Graph mit allen Branches und Tags
• Console Tab – Die tatsächlich ausgeführten Git-Befehle (praktisch zum Lernen)
• Repository Tab – Remote-Informationen

Der Log-Graph ist einer der besten auf dem Markt. Du kannst:

• Commits filtern (nach Autor, Datum, Branch, Pfad)
• Commits vergleichen (Diff zwischen zwei Commits)
• Cherry-Pick, Revert, Reset direkt per Rechtsklick
• Branches erstellen und mergen

Commit Dialog

Der Commit Dialog (Ctrl+K) zeigt dir:

• Alle geänderten Dateien mit Diff-Vorschau
• Checkboxen zum selektiven Stagen
• Commit-Message-Feld mit Autovervollständigung
• Code-Analyse-Warnungen vor dem Commit
• Amend-Option
• Author-Override

Das Besondere: JetBrains führt vor jedem Commit automatisch Code-Inspections durch. Du wirst gewarnt, wenn du TODO-Kommentare, ungelöste Merge-Konflikte oder Code-Style-Probleme committen willst.

Die automatischen Inspections vor dem Commit sind unbezahlbar. Sie fangen Fehler ab, bevor sie ins Repository gelangen – besser als jeder Pre-Commit-Hook.

Local History

Ein Feature, das kein anderer Editor hat: Local History. JetBrains speichert automatisch jede Änderung an einer Datei – unabhängig von Git. Du kannst jederzeit zu einem früheren Stand zurückkehren, auch wenn du nie committed hast.

Rechtsklick auf Datei → Local History → Show History

Das hat mir schon mehrfach den Tag gerettet, wenn ich nach einem git reset --hard gemerkt habe, dass ich etwas verloren habe.

VS Code hat mittlerweile ein ähnliches Feature: Timeline (im Explorer Panel). Es ist aber nicht so mächtig wie JetBrains’ Local History, da es auf Git-Commits basiert statt auf automatischen Snapshots.

Shelve und Changelist

Zwei weitere Features, die den Alltag erleichtern:

Shelve Changes: Ähnlich wie git stash, aber mächtiger. Du kannst Änderungen in benannte Shelves speichern, teilweise Dateien shelven und mehrere Shelves gleichzeitig verwalten.

Changelists: Du kannst geänderte Dateien in verschiedene Changelists gruppieren. Das ist praktisch, wenn du an mehreren Features gleichzeitig arbeitest und nur bestimmte Dateien committen willst. JetBrains mapped Changelists automatisch auf Git’s Staging Area.

Visual Diff und Annotate

Diff: Klicke auf die farbigen Markierungen im Gutter, um den Diff für einzelne Hunks zu sehen. Du kannst direkt Rollback, Stage oder Copy-Old-Text wählen.

Annotate (Blame): Rechtsklick im Gutter → „Annotate with Git Blame”. Zeigt für jede Zeile Autor, Datum und Commit-Message. Klick auf eine Annotation öffnet den Commit-Diff.

Merge Conflicts – der beste 3-Way-Merge

JetBrains hat den besten visuellen Merge-Conflict-Editor aller IDEs. Wenn ein Konflikt auftritt:

1. Eine Liste aller Dateien mit Konflikten erscheint
2. Für jede Datei öffnet sich ein 3-Way-Merge-Dialog:
   • Links – Deine Version (Yours)
   • Rechts – Die andere Version (Theirs)
   • Mitte – Das Ergebnis (Result)
3. Du kannst per Klick auf >> und << einzelne Änderungen übernehmen
4. Magic Resolve: JetBrains löst non-overlapping Änderungen automatisch
5. Du kannst das Ergebnis direkt in der Mitte editieren

Wenn du häufig Merge-Konflikte lösen musst, ist JetBrains die beste Wahl. Der 3-Way-Merge-Editor ist der intuitivste und mächtigste auf dem Markt.

Branch Management

Unten rechts in der Statusbar siehst du den aktuellen Branch. Klick darauf öffnet das Branch-Popup:

• Branches wechseln (Checkout)
• Neuen Branch erstellen
• Branches vergleichen
• Branches mergen
• Branches löschen
• Remote Branches fetchen

Interactive Rebase: Im Git Log kannst du Commits markieren und „Interactively Rebase from Here” wählen. Der visuelle Rebase-Editor zeigt:

• Alle Commits in der Reihenfolge
• Dropdown pro Commit: Pick, Edit, Squash, Fixup, Drop, Reword
• Drag & Drop zum Umsortieren

Git Log Graph View

Der Git Log (Alt+9 → Log Tab) ist einer der Hauptgründe, warum viele Entwickler bei JetBrains bleiben:

• Farbkodierte Branches – Jeder Branch hat eine eigene Farbe
• Filter – Nach Branch, User, Datum, Pfad oder Text
• Commit-Details – Klick zeigt Diff aller geänderter Dateien
• Vergleiche – Zwei Commits auswählen → Rechtsklick → Compare
• Performance – Auch bei Repos mit 100k+ Commits flüssig

GitLab Plugin

Das GitLab Plugin für JetBrains ermöglicht:

• Merge Requests erstellen und reviewen
• Pipeline-Status sehen
• Code-Reviews mit Inline-Kommentaren
• Issues durchsuchen

Die Konfiguration erfolgt unter Settings → Version Control → GitLab:

1. Instance URL eingeben (z.B. https://gitlab.example.com)
2. Personal Access Token hinterlegen
3. Projekt auswählen

Keyboard Shortcuts

Aktion	Shortcut
Commit Dialog	Ctrl+K
Push	Ctrl+Shift+K
Pull / Update	Ctrl+T
Git Log	Alt+9
Branches	Ctrl+Shift+ `
Annotate (Blame)	Alt+Shift+A (Custom)
Nächste Änderung	Ctrl+Alt+Shift+↓
Vorherige Änderung	Ctrl+Alt+Shift+↑
Rollback Hunk	Ctrl+Alt+Z
Show Diff	Ctrl+D
Shelve Changes	Ctrl+Shift+H
VCS Operations Popup	Alt+ `

JetBrains IDEs sind nicht kostenlos (außer Community Editions). Für Open-Source-Projekte und Studenten gibt es aber kostenlose Lizenzen.

Terminal-Tools

Auch wenn du hauptsächlich in einer IDE arbeitest – manchmal ist das Terminal einfach schneller. Diese Tools machen Git im Terminal deutlich komfortabler.

LazyGit

LazyGit ist eine Terminal-UI für Git, die quasi alles abdeckt. Fünf Panels zeigen Status, Dateien, Branches, Commits und Stash.

# Installation
# macOS
brew install lazygit

# Arch Linux
sudo pacman -S lazygit

# Ubuntu (via PPA)
LAZYGIT_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazygit/releases/latest" | grep -Po '"tag_name": "v\K[^"]*')
curl -Lo lazygit.tar.gz "https://github.com/jesseduffield/lazygit/releases/latest/download/lazygit_${LAZYGIT_VERSION}_Linux_x86_64.tar.gz"
tar xf lazygit.tar.gz lazygit
sudo install lazygit /usr/local/bin

Die wichtigsten Keybindings in LazyGit:

Taste	Aktion
Space	Datei stagen/unstagen
a	Alle stagen/unstagen
c	Commit
C	Commit mit Editor
p	Push
P	Pull
s	Squash
r	Reword Commit
e	Edit Commit (Rebase)
d	Drop Commit
f	Fixup
m	Merge
Enter	Diff anzeigen

Custom Commands machen LazyGit noch mächtiger:

customCommands:
  - key: "G"
    command: "glab mr create --fill --yes"
    context: "global"
    description: "GitLab MR erstellen"
    loadingText: "Erstelle Merge Request..."
  - key: "V"
    command: "glab mr view --web"
    context: "global"
    description: "MR im Browser öffnen"

LazyGit ist das perfekte Bindeglied zwischen Terminal und IDE. Es bietet 90% der IDE-Funktionalität in einer Terminal-UI.

tig

tig ist ein Text-Mode-Interface für Git. Es ist leichtgewichtiger als LazyGit und fokussiert sich auf das Lesen:

# Installation
sudo apt install tig  # Debian/Ubuntu
brew install tig       # macOS

# Log-Ansicht (Standard)
tig

# Status-Ansicht
tig status

# Blame einer Datei
tig blame src/main.go

# Stash-Liste
tig stash

tig eignet sich besonders gut, um schnell durch die Git-History zu navigieren, Blame-Informationen zu lesen oder den Stash zu durchsuchen. Es ist das ideale Tool, wenn du “nur mal schnell gucken” willst, ohne eine volle TUI wie LazyGit zu starten.

Die wichtigsten Keybindings in tig:

Taste	Aktion
Enter	Commit-Details öffnen
t	Tree-Ansicht
d	Diff-Ansicht
l	Log-Ansicht
s	Status-Ansicht
c	Stage-Ansicht
y	Stash-Ansicht
r	Refs-Ansicht
/	Suche
q	Zurück / Beenden

delta

delta ersetzt den Standard-Diff-Output von Git durch syntax-highlighted Diffs:

# Installation
sudo apt install git-delta  # Debian/Ubuntu
brew install git-delta       # macOS

# Git-Konfiguration
git config --global core.pager delta
git config --global interactive.diffFilter "delta --color-only"
git config --global delta.navigate true
git config --global delta.side-by-side true
git config --global delta.line-numbers true
git config --global delta.syntax-theme "Dracula"

[core]
    pager = delta

[interactive]
    diffFilter = delta --color-only

[delta]
    navigate = true
    side-by-side = true
    line-numbers = true
    syntax-theme = Dracula
    file-style = bold yellow ul
    hunk-header-style = omit

[merge]
    conflictstyle = diff3

delta + diff3 conflictstyle ist eine Kombination, die du nicht mehr missen willst. Merge-Konflikte werden deutlich übersichtlicher.

glab CLI

glab ist die offizielle GitLab-CLI. Du kannst damit Merge Requests, Issues und Pipelines direkt im Terminal verwalten:

# Installation
brew install glab  # macOS
# oder: https://gitlab.com/gitlab-org/cli/-/releases

# Konfiguration
glab auth login --hostname gitlab.example.com

# Merge Request erstellen
glab mr create --fill

# Pipeline-Status anzeigen
glab ci status

# Offene MRs auflisten
glab mr list

# MR im Browser öffnen
glab mr view --web

Vergleichstabelle

Alltags-Operationen

Feature	VS Code	Neovim/LazyVim	JetBrains	LazyGit
Stage/Unstage	Klick / +	s/u (fugitive)	Checkbox	Space
Partial Stage	Diff View	gitsigns Hunks	Diff View	Enter → Lines
Commit	Ctrl+Enter	:Git commit	Ctrl+K	c
Push	SCM Menü	:Git push	Ctrl+Shift+K	p
Pull	SCM Menü	:Git pull	Ctrl+T	P
Inline Blame	GitLens	gitsigns/fugitive	Annotate	–
File History	GitLens	diffview.nvim	Git Log	–
3-Way Merge	Merge Editor	:Gvdiffsplit!	Merge Dialog	–
Interactive Rebase	GitLens	LazyGit	Built-in	e
Branch Switch	Statusbar	Telescope	Statusbar	Space
Git Graph	Git Graph Ext.	LazyGit	Built-in	–

GitLab-spezifische Features

Feature	VS Code	Neovim/LazyVim	JetBrains	glab CLI
MR erstellen	GitLab Ext.	glab / LazyGit	GitLab Plugin	glab mr create
MR reviewen	GitLab Ext.	–	GitLab Plugin	glab mr view
Pipeline-Status	Statusbar	–	GitLab Plugin	glab ci status
Issues	GitLab Ext.	–	GitLab Plugin	glab issue list
Inline-Kommentare	GitLab Ext.	–	GitLab Plugin	–

Gesamtvergleich

Kriterium	VS Code	Neovim/LazyVim	JetBrains
Lernkurve	Niedrig	Hoch	Mittel
Git out-of-the-box	Gut	Minimal	Hervorragend
Git mit Plugins	Hervorragend	Hervorragend	Hervorragend
Merge Conflicts	Sehr gut	Gut	Beste
Performance	Gut	Beste	Mittel
Remote/SSH	Remote SSH Ext.	Nativ	Gateway (Beta)
RAM-Verbrauch	~300-500 MB	~50-100 MB	~1-2 GB
Kosten	Kostenlos	Kostenlos	Ab 25€/Monat
Homelab-Eignung	Sehr gut	Beste	Gut
Erweiterbarkeit	Extensions	Lua Plugins	Plugins

Empfehlungen

Für Einsteiger: VS Code + GitLens

Wenn du gerade erst mit Git anfängst, nimm VS Code. Die Git-Integration funktioniert out of the box, die UI ist intuitiv, und GitLens zeigt dir sofort, was in deinem Repository passiert. Der Diff Viewer und der 3-Way Merge Editor sind für Anfänger viel zugänglicher als die Terminal-basierten Alternativen.

# VS Code Extensions installieren
code --install-extension eamodio.gitlens
code --install-extension mhutchie.git-graph
code --install-extension GitLab.gitlab-workflow

Mit diesen drei Extensions hast du alles, was du brauchst. GitLens für Blame und History, Git Graph für den visuellen Log, und die GitLab Extension für Merge Requests und Pipelines.

Für Terminal-Fans: Neovim + LazyGit

Wenn du sowieso im Terminal lebst, ist Neovim mit LazyVim + LazyGit die natürliche Wahl. Du bleibst in deiner gewohnten Umgebung, hast volle Kontrolle über jedes Plugin, und die Performance ist unschlagbar. Besonders auf remote Maschinen per SSH gibt es keine bessere Option.

In meinem Homelab nutze ich Neovim + LazyGit auf allen VMs. Per SSH verbinden, nvim starten, <leader>gg für LazyGit – fertig. Kein VS Code Remote nötig.

Für Profis: JetBrains

Wenn du professionell entwickelst und bereit bist, für deine Tools zu zahlen, bietet JetBrains das beste Gesamtpaket. Der Git Log Graph, der Merge-Conflict-Editor und die automatischen Inspections vor dem Commit sind Features, die kein anderer Editor in dieser Qualität bietet.

Besonders in Teams, die häufig mit Merge-Konflikten arbeiten, spart der 3-Way-Merge-Editor von JetBrains enorm viel Zeit. Die Kombination aus automatischer Auflösung einfacher Konflikte und der visuellen Darstellung komplexer Konflikte ist unübertroffen.

Für das Homelab: Mix

Die pragmatische Lösung für Homelab-Betreiber:

• VS Code auf dem lokalen Rechner für die Hauptentwicklung
• VS Code Remote SSH wenn du auf einer VM mit grafischem Komfort arbeiten willst
• Neovim auf den VMs für schnelle Edits per SSH
• LazyGit überall dort, wo du Git im Terminal brauchst
• glab CLI für GitLab-Interaktion direkt im Terminal

So hast du für jede Situation das richtige Tool. In der Praxis sieht das bei mir so aus:

# Auf dem lokalen Rechner: VS Code mit GitLens
code ~/projects/my-app

# Auf einer Homelab-VM per SSH: Neovim + LazyGit
ssh 192.168.60.89
cd /opt/app && nvim .

# Schneller MR-Check im Terminal
glab mr list --assignee=@me

Installiere auf deinen Homelab-VMs ein einheitliches Setup: Neovim, LazyGit, delta und glab. Am besten über dein Dotfiles-Repo, dann ist jede neue VM sofort einsatzbereit.

Fazit

Git in der IDE zu nutzen ist kein Luxus – es ist ein Produktivitäts-Boost. Egal ob du VS Code, Neovim oder JetBrains nutzt: die visuelle Darstellung von Diffs, Inline Blame und der 3-Way Merge Editor machen dich schneller und reduzieren Fehler.

Im GitLab-Workflow-Post haben wir die Git-Grundlagen gelegt – Branches, Commits, Merge Requests. Im CI/CD-Post kam die Automatisierung dazu. Mit der IDE-Integration schließen wir den Kreis: Du arbeitest im Editor, siehst die Änderungen sofort, committest ohne Kontextwechsel und beobachtest die Pipeline-Ergebnisse direkt in der Statusbar.

Der Workflow sieht dann so aus:

graph LR
    A[Code im Editor] --> B[Gutter zeigt Änderungen]
    B --> C[Stage & Commit im Editor]
    C --> D[Push zum Remote]
    D --> E[Pipeline-Status in Statusbar]
    E --> F[MR erstellen via Extension]
    F --> G[Review im Editor]
    G --> A

Am Ende des Tages ist das beste Tool das, mit dem du am produktivsten bist. Probier die verschiedenen Setups aus und finde deinen eigenen Workflow. Die Konfigurationen aus diesem Post sind ein guter Startpunkt – kopier sie in dein Setup und pass sie an deine Bedürfnisse an.

Tipp: Starte mit einem Tool und lerne es richtig, bevor du zum nächsten wechselst. Ein gut beherrschtes Tool schlägt drei halb gelernte.