· via Hacker News – Front Page (native)
Jujutsu primer shows Git users a VCS with undo, auto-rebase and no staging area
Ethan Lowman's hands-on Jujutsu primer, now on Hacker News's front page, walks Git users through a VCS that auto-snapshots the working copy, tracks stable change IDs and runs side-by-side with Git.

What happened
A practical introduction to Jujutsu, the Git-compatible version control system also known as jj, has reached the front page of Hacker News. Written by Ethan Lowman, the primer targets developers who already know Git and want to understand what jj changes about day-to-day version control, from installing the tool to evolving commits without a staging area.
Coexisting with Git
Lowman's core pitch is that trying jj does not require abandoning existing work. Running jj git init inside an existing Git repository sets the two tools up to operate side by side, with repository state synchronized automatically between them. That makes it possible, he writes, to experiment on a real project without fully ejecting from Git.
Installation is simple on the systems he covers: Homebrew on macOS, pacman on Arch Linux, nix-shell on NixOS, or building the binary from source with cargo. Configuration lives in TOML files that can be opened in an editor (jj config edit --user) or set key by key (jj config set --user user.name), with user, repo and workspace scopes that merge into a single viewable configuration via jj config list.
Change IDs and the auto-snapshot model
Much of the primer explains how jj's mental model differs from Git's. A commit, which jj also calls a revision, is a snapshot of repository state descending from one or more parents, and when the Git backend is in use the commit ID is literally the same hash as Git's. The genuinely new concept is the change ID: a stable identifier for a logical change that persists while the underlying commits are rewritten. Commit hashes shift whenever content or messages change, but the change ID does not.
Any ID can be typed as its shortest unambiguous prefix, and jj highlights that prefix in its own output, so a revision whose change ID begins kpqxywon can be referenced with just k.
The working copy is also treated as a first-class commit, marked with @ in jj log output. Because jj has no staging area, there is nothing equivalent to git add: whenever a jj command inspects or modifies repository state, the working copy is automatically snapshotted as a new physical commit belonging to the same logical change. Editing a file and running jj show immediately displays the resulting diff, with the change ID unchanged even though the commit hash is new.
From there, Lowman walks through the core verbs. jj desc attaches a description to the current change, either opening an editor or accepting a message with -m. jj new creates a fresh empty change on top of the current one so work can continue, and jj commit bundles the two steps together for the common case of describing finished work and moving on.
Why it matters
The friction points jj targets are familiar ones: rebasing by hand, staging-area bookkeeping and the anxiety of an unrecoverable mistake. Its answers are automatic rebasing and a native undo command, which Lowman credits with making stacked-diff workflows practical enough to use routinely. His broader claim is cognitive rather than mechanical: because jj handles the bookkeeping itself, version-control state stops occupying his working memory. Given that the tool interoperates with ordinary Git repositories, the cost of evaluating it is close to zero, and primers like this one, by translating jj's model into terms Git users already know, lower the barrier further.
- #version-control
- #git
- #jujutsu
- #developer-tools