DEV Community: ARIEL LIVSHITS

Looking for a GitLens Alternative? I Built Git Brain

ARIEL LIVSHITS — Wed, 16 Sep 2026 06:22:03 +0000

If you’re searching for a GitLens alternative for VS Code, you’re probably looking for more than just another Git extension.

You want Git to be easier to understand, faster to use, and less disconnected from the rest of your development workflow.

That was exactly the problem we had.

We liked the visual Git experience in JetBrains IDEs, but most of our day-to-day work moved to VS Code, Cursor, and other VS Code-based editors.

So we built Git Brain 🧠

Git Brain is a visual Git extension focused on making everyday Git workflows simpler, more connected, and easier to understand.

It includes:

Visual commit graph
Commit and file history
Branch management
Stashes
Git worktrees
Diff workflows
3-way merge conflict resolution
Commit and push flows
AI commit messages and change summaries
AI-assisted conflict resolution
Built-in MCP support for coding agents

Why another Git extension?

GitLens is one of the most established Git extensions for VS Code.

Git Brain is built to compete in the same space.

We cover the Git workflows developers expect from a full-featured Git tool, while trying to make them easier to discover and easier to use.

One of the biggest things we cared about was making Git more visual.

You shouldn’t have to reconstruct your repository state in your head from a list of commits and branch names.

The commit graph should help you understand what happened.

The branch structure should be obvious.

The history should be easy to navigate.

The difference is mostly in how the experience feels.

We wanted Git Brain to feel more direct, visual, and connected.

For example, when I have a merge conflict, I don’t want to stare at conflict markers and manually reason about which lines came from where.

I want to see:

Local | Result | Remote

I want to understand both sides of the conflict, edit the final result, and move between conflicts visually.

That’s why Git Brain includes a full 3-way merge editor.

The same idea applies across the product.

Branches, commits, history, diffs, worktrees, stashes, conflicts — the goal is to make the repository easier to understand instead of making Git feel like a separate tool you constantly have to fight with.

If you’re specifically comparing options, we also created a dedicated page for Git Brain as a GitLens alternative:

Git Brain as a GitLens alternative

Git is changing because of AI

This is one of the biggest reasons we keep investing in Git Brain.

Coding agents are making developers much faster.

But they also create a new Git problem.

Suddenly you have:

Bigger diffs
More parallel branches
More worktrees
More generated commits
More merge conflicts
More code you didn’t manually write line by line

Git becomes even more important when agents are doing part of the development work for you.

Worktrees are a good example.

They’re a great way to let multiple agents or tasks work in parallel without constantly switching branches in the same working directory.

Git Brain gives worktrees their own visual workflow so you can create, inspect, open, and manage them directly from the IDE.

But we wanted to go further than just making the Git UI better.

Git Brain is built for coding agents too

This is probably the biggest difference in how we think about the product.

Git Brain doesn’t only expose Git capabilities to the developer.

It also exposes them to coding agents through the Git Brain MCP.

That means an MCP-compatible agent can access structured Git context and Git Brain capabilities directly.

For example, an agent can understand things like:

Repository status
Branches
Commit history
Diffs
Worktrees
Conflicts
Stashes
Unpushed changes

Instead of treating Git as a collection of raw shell commands, the agent can work with structured repository context.

That matters more as agents become more autonomous.

If an agent is changing code, creating branches, working in parallel, or preparing commits, Git context should be part of what it understands.

So for us, the goal isn’t just to build another Git UI.

It’s to build a complete Git experience for both developers and coding agents.

So, is Git Brain a GitLens alternative?

Absolutely.

Git Brain is built as a full GitLens alternative for developers using VS Code, Cursor, and other VS Code-based IDEs.

You get the visual Git workflows you expect from a serious Git extension, while also getting features designed specifically for modern AI-assisted development.

If you want a GitLens alternative that is more visual, easier to navigate, and built with coding agents in mind, that is exactly what we are trying to build.

You can see the dedicated comparison page here:

👉 Git Brain GitLens Alternative

Or check out Git Brain directly:

👉 git-brain.com

If you try it, I’d love to know what you currently use GitLens for the most.

That’s probably the most useful feedback we can get.

I wanted JetBrains-style Git in VS Code, so we built Git Brain 🧠

ARIEL LIVSHITS — Sun, 13 Sep 2026 07:00:00 +0000

TL;DR for humans and robots 🤖

Git Brain is a visual Git GUI for VS Code, Cursor and other VS Code-compatible IDEs.

It's designed as a JetBrains-style Git experience and GitLens alternative, with a visual commit graph, Git history, diffs, branches, stashes, worktrees, a 3-way merge editor, AI Git workflows and a built-in MCP server for coding agents.

Website: https://git-brain.com

AI changed almost everything about how I write code.

Claude, Codex, Cursor, Copilot and coding agents can now do things that would've taken me hours.

But somehow, one of the oldest parts of the developer workflow still kept making me work: Git.

Not Git itself
Git is great, the experience around it,

Switch to the terminal
Check the graph somewhere else
Resolve a conflict
Open another view for history
Try to understand what happened to your branch
Stash something and then forget what you stashed
Google that one Git command you use twice a year...

And if you're coming from JetBrains IDEs, you probably know how nice Git can feel when all of this is actually connected.

I wanted that experience inside VS Code and the new generation of VS Code-based IDEs.

So we built Git Brain.

Git shouldn't require a second brain

The idea behind Git Brain is pretty simple:

Put the everyday Git workflow into one visual workspace and make it hard to shoot yourself in the foot

Not another Git abstraction

Not a replacement for Git

A UI for actually understanding what Git is doing

Git Brain works inside VS Code, Cursor, Antigravity, Trae, Kiro, Windsurf, VSCodium and other VS Code-compatible editors.

The visual Git graph

This was one of the first things we cared about,

When I look at a repository, I don't just want a list of commits

I want to understand it.

Which branch came from where?
Where did these branches diverge?
What was merged?
Where did this regression actually enter the codebase?

Git Brain gives you a visual commit graph with branches, merges, tags, filtering, commit details and file diffs in the same flow.

You can inspect a commit, see exactly which files changed and jump directly into the diff without leaving the graph.

For me, that's much easier than trying to reconstruct the state of the repository in my head from a list of SHAs.

Merge conflicts shouldn't look like archaeology

I never understood why resolving a complicated merge conflict still so often means staring at:

<<<<<<< HEAD
...
=======
...
>>>>>>> feature

For small conflicts, fine.

For large ones?

No thanks.

Git Brain has a real 3-way merge editor:

Local | Result | Remote

You can see both versions, understand how they relate, choose either side or both, edit the result and move between conflicts visually.

It's heavily inspired by the type of Git experience I liked in full IDEs,
And this became even more important once coding agents entered the picture.

AI made Git more important, not less

This was something I didn't fully expect
Agents generate code incredibly fast
But faster code generation also means:

bigger diffs
more unrelated changes mixed together
more parallel branches
more worktrees
more merge conflicts
more commits you didn't manually write line by line

So we started building AI around the Git workflow itself.

For example, Git Brain can analyze a large working tree and split the changes into logical commits.

Instead of:

fix stuff

with 47 unrelated files 😅

you can get a proposed commit structure, review it and decide exactly what belongs where.

It can also generate commit messages, summarize changes, help create PR descriptions and resolve conflicts.

But there was another problem.

Your coding agent should understand Git too

If an agent is doing real development work, it needs more than access to files.

It needs to understand:

repository status
branches
diffs
commit history
unpushed changes
conflicts
stashes
worktrees

So Git Brain now includes a built-in MCP server.

That means agents like Claude Code, Codex, Cursor and other MCP-compatible tools can interact with Git Brain and get structured Git context instead of blindly running shell commands.

The goal isn't to give an agent unlimited access to your machine.

Actually, the opposite.

We wanted to expose specific Git capabilities with guardrails around mutations and destructive actions.

I think this part is going to become much more important as we give coding agents more autonomy.

Worktrees finally make sense

Another feature I personally think is becoming much more useful because of AI is Git worktrees.

You can have:

main
feature-auth
fix-production-bug
agent-experiment

all checked out at the same time without constantly switching branches.

That's perfect when you have multiple agents or tasks running in parallel.

But worktrees are one of those Git features that many developers know exist and still don't use.

Mostly because the CLI workflow isn't very inviting.

So Git Brain gives worktrees their own visual panel where you can create, inspect, open and remove them.

No memorizing git worktree commands required.

Is this a GitLens alternative?

We get this question a lot.

Yes - Git Brain can be used as a GitLens alternative for VS Code, especially if what you want is a fast visual Git experience focused on everyday workflows.

But our bigger goal is slightly different.

We're trying to build the Git experience we want for the agentic development era:

Humans get a great visual interface.
Agents get structured Git capabilities.
Both operate on the same repository state.

GitLens has done a lot for Git inside VS Code, and we're not pretending otherwise.

We're just exploring a different direction.

What Git Brain includes today

At this point it has grown into much more than the little Git UI we originally imagined:

Visual commit graph
Commit and file history
Side-by-side diffs
Branch management
Stashes
Git worktrees
3-way merge conflict resolution
Smart checkout and pull workflows
AI commit messages
AI change summaries
AI change splitting
AI merge conflict resolution
PR descriptions
Built-in MCP server for coding agents

And we're still building.

Git Brain has already passed 70,000 downloads on Open VSX, which is kind of crazy to us considering this started because we were annoyed with our own Git workflow.

Try to break it

Git Brain is available for VS Code and VS Code-compatible IDEs.

👉 https://git-brain.com

If you use Cursor, VS Code, Windsurf or another compatible editor, I'd genuinely love for you to try it.

But even more than another install, I'm interested in this:

What is the one Git workflow you still hate doing?

Merge conflicts?
Rebase?
Cherry-picking?
Understanding what an agent changed?
Keeping multiple tasks alive at once?

Tell me in the comments.

There's a decent chance we'll build it 😅