jj: Version Control That Actually Makes Sense

jj: Version Control That Actually Makes Sense

Git has trained us to think in patches, staging areas, and merge conflicts. We've accepted that version control should be painful — that you need to memorize forty commands and understand the difference between HEAD~1 and HEAD^ to use it properly.

jj doesn't buy into that. It's a Git-compatible version control system that thinks differently about what version control should be.

What It Is

jj (Jujutsu) is a version control system that uses Git repositories for storage but reimagines the user experience. Every change you make is automatically committed. Your working directory is always a commit. Conflicts aren't errors that break your workflow — they're first-class objects you can reason about and manipulate.

Think of it as Git with the complexity surgically removed and replaced with sensible defaults.

Why It's Worth Your Time

Most version control systems make you think like the computer. jj makes the computer think like you.

The automatic commit model means no more "oh shit, I need to stash this before I can switch branches." No more losing work because you forgot to commit. No more git add . ceremonies before every commit. Changes just... exist. As commits. Like they should.

The conflict handling is what sold me. Instead of Git's "stop everything, fix conflicts, continue" dance, conflicts are just another type of commit. You can rebase past them, move them around, even commit new changes on top of conflicted commits. The conflict resolution propagates automatically when you fix it.

And the operation log — every action you take is recorded. Made a mistake? jj undo. Want to see what happened when your coworker "fixed" the repo? jj op log. It's version control that actually versions its own operations.

Hands On

Installation is straightforward — binaries available for most platforms, or cargo install jj-cli if you have Rust.

To start with an existing Git repo:

cd your-git-repo
jj git init --colocate

This creates a "colocated" workspace where you can use both jj and git commands interchangeably.

The basic workflow feels familiar but cleaner:

# Edit files — they're automatically committed to working-copy commit
echo "new feature" >> README.md

# Describe what you did
jj describe -m "Add new feature documentation"

# Create a new change (like git checkout -b, but simpler)
jj new

# More editing happens automatically in the new commit

The revset language is surprisingly intuitive. Want commits from the last week? jj log -r "today - (today - 7d)". Want to see what changed between two commits? jj diff -r "commit1::commit2".

The automatic rebase took some getting used to. Edit an old commit and every descendant automatically rebases on top. This sounds chaotic but works beautifully in practice. No more "I fixed a typo in an old commit and now I have to manually rebase 8 commits."

Honest Verdict

This isn't a toy project. Google developers use it daily, and the GitHub repo itself is developed with jj. The Git interoperability is genuine — your commits look like normal Git commits, and you can push/pull from any Git remote without issue.

The learning curve exists but it's different from Git's. Instead of memorizing arcane commands, you unlearn Git assumptions. The working copy is a commit, not a staging area. Conflicts are data, not errors. Operations are recorded, not fire-and-forget.

Performance is solid. The operation log means slightly more disk usage, but nothing dramatic. The automatic rebases are fast — faster than doing them manually in Git.

Some rough edges remain. Documentation is good but Git refugees need to adjust their mental model. The ecosystem is smaller — fewer Stack Overflow answers, fewer third-party tools. Email-based workflows aren't supported yet.

But for interactive development? Code review workflows? Branch-heavy feature work? It's genuinely better than Git. Not just different — better.

Go Try It

Start with a test repo: jj git clone <any-git-url>. Edit files, run jj log -r 'all()', break things and jj undo them. See how the automatic commit model feels.

If you're curious about the deeper concepts, the Git comparison doc explains exactly how jj differs from Git workflows.

Fair warning: once you experience version control without the ceremony, going back to Git feels like using punch cards.

GitHub Repository | Official Documentation

Compiled by AI. Proofread by caffeine. ☕