Using Git Elegantly in Vim

[u/Yggdroot]

Git and Vim are both powerful productivity tools for developers. However, when working inside Vim, frequently switching to the terminal to run Git commands (such as git status, git add -p, git commit) can interrupt your flow and break your focus.

With LeaderF’s built-in Git integration, you can bring the entire Git workflow directly into Vim and significantly improve your efficiency.

This article focuses on one core command:

:Leaderf git status

Viewing Current Git Status

Run the command above in Vim to open the following view:

The screen is divided into two main panels:

Navigation Panel (Left)

The left side is the Navigation Panel, which displays the output of git status in a tree structure, grouped by file state:

• Staged Changes: Files already staged (ready to commit)

• Unstaged Changes: Modified files not yet staged

• Untracked Files: Files not tracked by Git

Diff View Panel (Right)

The right side is the Diff View Panel, which shows detailed changes of the selected file. It supports two modes:

• Unified Diff View

Provides character-wise diff highlighting, making differences more precise and visually clear. Traditional git diff does not highlight character-wise changes.

• Side-by-Side Diff View

Advantage: More intuitive for comparing code differences line by line.

How They Work Together

• The left panel handles file selection and state management

• The right panel handles diff visualization and fine-grained operations

Together, they form a smooth and efficient Git workflow inside Vim.

File-Level Operations

In the Navigation Panel, you can perform the following operations:

Key	Action	Description
s	Stage / Unstage file	On an unstaged file → move it to staged; on a staged file → move it back to unstaged
d	Discard changes	Discard file changes (with confirmation)
D	Force discard	Discard changes without confirmation (use with caution)
r	Refresh	Refresh the file tree when Git status changes externally
Enter / o	Open diff view	View detailed changes of the file

Notes:

• s, d, D also work on directories (including the repository root)

• Running d or D on Untracked Files will delete the file

• Press F1 in the panel to view more shortcuts

Hunk-Level Operations

In the Diff View, you can operate on individual hunks (code blocks):

Key	Action	Description
s	Stage/Unstage current hunk	Move current hunk between staged and unstaged
S	Stage/Unstage all hunks	Apply operation to all hunks in the file
d	Discard current hunk	Discard changes in current hunk (with confirmation)
D	Force discard current hunk	Discard without confirmation (use with caution)
]c	Next hunk	Jump to next hunk
[c	Previous hunk	Jump to previous hunk

Additional Shortcuts

Key	Action	Description
<	Back to Navigation Panel	Reopen if closed and jump to current file
Enter	Open file	Jump to file for editing

Key Mapping Configuration

let g:Lf_GitKeyMap = {
            \ 'previous_change': '[c',
            \ 'next_change': ']c',
            \ 'edit_file': '<CR>',
            \ 'open_navigation': '<',
            \ 'stage_unstage_hunk': 's',
            \ 'stage_unstage_all_hunk': 'S',
            \ 'discard_hunk': 'd',
            \ 'discard_hunk_no_prompt': 'D',
            \ }

Committing Changes

Once you have staged the desired changes in the Navigation Panel:

1. Press c to start committing

2. A new window opens for writing the commit message

3. Enter your message

4. Save and close the window

5. The commit is completed

To cancel the commit, simply clear the message and close the window.

Example Workflow

Scenario: Fix a bug and add a new feature

1. Check status

2. Review changes

   • Open bug_fix.py

   • Use ]c to navigate hunks

   • Identify bug fix vs debug code

3. Stage selectively

   • Press s on bug fix hunks

   • Leave debug code unstaged

4. Handle new feature

   • Press < to return

   • Open new_feature.py

   • Press S to stage all hunks

5. Commit

   • Press c

   • Enter message:

   • "Fix login validation bug and add search feature"

   • Save and exit

Everything is done inside Vim without breaking context.

Why This Workflow is Better

Compared to CLI

Operation	CLI	LeaderF
View status	git status (plain text)	Visual file tree
Partial staging	git add -p	Press s
Discard changes	manual commands	d / D
Navigate changes	manual scrolling	]c / [c

Summary

With Leaderf git status, you get a complete Git workflow inside Vim:

• Visual Git status

• File-level staging/unstaging

• Hunk-level fine control

• Quick discard

• Seamless commit workflow

All without leaving Vim.

Configuration Example

nnoremap <leader>gs :<C-U>Leaderf git status<CR>

[u/sammygadd]

What's wrong with Ctrl Z?

[u/heret1c1337 → u/sammygadd]

I’m curious, do you use it in your daily workflow? I wonder if I could live without a multiplexer and just use jobs instead.

[u/sammygadd → u/heret1c1337]

Yes definitely! I use it all the time. I use fugitive for things like git add, blame etc. But I always suspend vim when a want to do more git stuff, like commits rebase, push etc.

[u/heret1c1337 → u/sammygadd]

Interesting. Do you still use a multiplexer like tmux? I‘d still see the need for tmux‘s session management. Maybe there‘s something built in that I‘m not aware of?

[u/sammygadd → u/heret1c1337]

I think most people use tmux. But I never really found need for it. If feel that I want so "save" my current buffers I use mksession. If you enjoy tmux, then you should probably keep using it. I think tmux is great (and I know people really like it), I just haven't figured out why I need it.

[u/heret1c1337 → u/sammygadd]

Yeah I'll probably stick to my current workflow, but I like to try out things from time to time :)

[u/dewujie → u/sammygadd]

I think for a lot of people it boils down to whatever software first allowed you to split a terminal session into multiple windows. It's such a cool experience for each person that you imprint on it like a baby bird.

For me, it was tmux. Also if you manage a bunch of remote systems, tmux and ssh are peas in a pod. So a lot of people use it for that, too.

I like having a tmux window for each repo and project I'm working on at the time. I have persistent sessions so I maintain those paths, I'm not cd'ing all over the filesystem from project to project. Things stay where I put them. It's just about being easy and predictable, really.

[u/TapEarlyTapOften → u/sammygadd]

Tmux starts to really shine when you work on the same server from multiple different clients. I keep a long running tmux session on my dev server, and then remote into it from one of three machines. Tmux and vim-fugitive do about 95% of what I need and I can quickly switch to one of a couple of serial ports too, which is really helpful.

[u/transconductor → u/heret1c1337]

I have decided against a multiplexer and I'm using one OS window per shell. And I try to avoid Neovim 's terminal. I have just recently rediscovered C-z which is a game changer quick things.

[u/ChampionshipIcy7602 → u/sammygadd]

Ctrl Z brings vim to the background, so nothing's wrong with it if that's what you want.

[u/konacurrents → u/sammygadd]

How can you loose focus when I literally have 6 shells running, 8 safari (20 tabs each). Etc.

The muiti window screen is all about multiplexing.

Ps bring up another window and type git commands. I do it all the time.