Solving Git's Pain Points with Jujutsu (with Martin von Zweigbergk)

October 9, 2025

AI Summary

5 min read

Solving Git's Pain Points with Jujutsu

Martin von Zweigbergk spent a decade working on source control at Google before he started pulling on a single design thread: what would happen if you automatically snapshot the working copy every time you run a command? That thought experiment became Jujutsu (jj), a version control system that is Git-compatible but approaches commits, conflicts, and undo in fundamentally different ways. The result is a tool that makes rebasing, merging, and moving through history feel less like wrestling with machinery and more like algebra.

The Commit-Everything Model

The core insight that drove the project is deceptively simple. Instead of having a staging area where changes sit before being committed, Jujutsu treats the working copy itself as a commit. Every time you run any jj command, it automatically snapshots whatever state your files are in and creates a commit. If nothing changed, no commit is created.

This means there is no such thing as a "dirty working copy" in the traditional Git sense. You can freely move between commits because there is always a clean slate underneath you. "The commit is just a way of storing the state," von Zweigbergk explains. "It doesn't mean that you're ready to send it for review or anything."

Continue reading the full summary in the app — free to try.

Read Full Summary →

Free • No credit card required

Listen to Audio Summary Open in App

Never miss an episode of Developer Voices

Get every new episode summarized in your inbox — free, ~5 minutes to read.

No spam. Unsubscribe anytime.

What you'll learn

1 (02:54) **Why Build Another VCS?** - Martin explains his motivation: years working on Google’s internal Mercurial integration sparked the idea of automatically snapshotting the working copy to improve UX.
2 (07:35) **The Mental Model: No Staging Area** - Martin contrasts JJ’s model with Git’s, explaining that committing is just storing state, not a final action.
3 (10:42) **The Working Copy as a Commit** - JJ snapshots the working copy automatically before every command, so you can always move freely between commits.
4 (17:34) **Performance: Snapshotting and Rebasing** - Creating commits and rebasing is surprisingly fast because JJ does it in memory, not by touching the working copy.
5 (19:42) **Storage: Git-Compatible but Extended** - JJ uses Git’s object model for files/trees but adds custom headers (like a stable change ID) to Git commit objects.
6 (25:49) **The Operation Log (Oplog): Infinite Undo** - The Oplog records a snapshot of all branches after every command, enabling you to restore the repo to any past state.
7 (28:52) **Fine-Grained Undo for Working Copy Changes** - Since JJ snapshots every change, you can step back through individual edits, not just commits.

+ Full timestamped outline available in the app

Show Notes

Git might be the most ubiquitous tool in software development, but that doesn't mean it's perfect. What if we could keep Git compatibility while fixing its most frustrating aspects—painful merges, scary rebases, being stuck in conflict states, and the confusing staging area?

This week we're joined by Martin von Zweigbergk, creator of Jujutsu (JJ), a Git-compatible version control system that takes a fundamentally different approach. Starting from a simple idea—automatically snapshotting your working copy—Martin has built a tool that reimagines how we interact with version control. We explore the clever algebra behind Jujutsu's conflict handling that lets you store conflicts as commits and move freely through your repository even when things are broken. We discuss why there's no staging area, how the operation log gives you powerful undo/redo capabilities, and why rebasing becomes trivially easy when you can edit any commit in your history and have changes automatically propagate forward.

Whether you're a Git power user frustrated by interactive rebases, someone who's lost work to a botched merge, or just curious about how version control could work differently, this conversation offers fresh perspectives on a tool we all take for granted. And if you're working with large monorepos or game development assets, Martin's vision for the future of Jujutsu might be exactly what you've been waiting for.

---

Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices

Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join

Jujutsu (JJ): https://github.com/martinvonz/jj

Jujutsu Documentation: https://martinvonz.github.io/jj/

Git: https://git-scm.com/

Mercurial: https://www.mercurial-scm.org/

Rust: https://www.rust-lang.org/

Watchman: https://facebook.github.io/watchman/

Google Piper: https://research.google/pubs/why-google-stores-billions-of-lines-of-code-in-a-single-repository/

Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social

Kris on Mastodon: http://mastodon.social/@krisajenkins

Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/