I wrote a piece on what specific advantages jj brings over git, and what kind of development workflows deserve it. Give it a read if you are debating internally whether jj deserves a place in your toolbox: https://sarthakag.bearblog.dev/from-git-to-jj-jujutsu/
Have to say staging area is one feature that makes people better programmers. Especially using GUI tooling to pick hunks or discard parts you don’t want to go to a commit was always super useful for me. (CLI of staging hunks is not convenient at all for me)
I keep running into people who “just commit stuff” and they don’t know what they are doing.
Downside is we are heading into direction where people don’t even read code anymore so I might be just old man screaming at the clouds or agents.
Think of it this way: you still have a staging area in jj, but now it's a commit instead of something unique and separate. There's zero obstacle to picking and discarding hunks with jj.
Someone already said this, but you just use jj split. Either split the whole file or use interactive mode to split the exact lines. You could also use squash if you want to move it to an existing revision/commit.
Jj makes it vastly more efficient and ergonomic to perform surgery across commits - no staging area to think about, remember, stumble over, etc. Conflicts don't stop the world.
It's all dead simple if you use jjui - don't even need to learn any jj syntax
The stuff you wrote is always captured in a commit and never in some weird lingering (uncommitted) state.
Treat the HEAD commit like your staging area. Split it as you will, pick stuff you like, remove stuff you don't want and push it to a different commit, etc. Feel free to rewrite history as you will (that you haven't exposed publicly, for others to depend on).
In jj you create a new commit for the staged parts, you can name it "wip: foobariating", and then the gui tooling allows you to move files between both commits, for me it's the equivalent of a staging area/stash that you can name
At first the auto-staging (or whatever it's called) is annoying. It sure is if one is used to dump random files in the repository, that haven't been ignored.
After some time, I realised it gives a lot of freedom. Working on something but not in a workspace, and need to do something else for the day? Just jump somewhere else. Everything will still be there when you get back.
In other words, it's hard to lose things by mistake. In those situations it's also cool to describe (name) the work being done, prior to making a normal commit.
A bit odd but one can also push `@` to a remote (e.g. iterating on something and piggy backing on a CI-system), avoiding having to squash and then push.
Having a stack of PR's, then rebasing it all to see a conflict, and only having to deal with it one is also magical.
Moving bookmarks around can be annoying.
Workspaces work fine, and there's two options:
- the normal ones, where a full .git isn't created. That works fine, unless having tooling that expects the workspace to also work as a git repository, in which case ..
- you can make the workspace collocated, less lightweight, but git tooling works
As others have said, the head commit is effectively a staging area, it just contains everything that you've done which you can then split/squash/rebase as you see fit. `jj split -i` felt like magic the first time I used it.
Automatic bookmark naming is 100% cursed, I always name them, and also don't subscribe to this weird one commit per-bookmark/PR thing people seem to have adopted. You can use bookmarks just like git branches in practice.
Rebasing is so much nicer than doing the same thing with git because its going to do its best to finish the job, then leave you with a coherent set of conflicts you can clean up one commit at a time. Its still conflict resolution, and it still sucks, but at least you feel less like you're fighting the tooling.
Finally, workspaces exist and work reasonably well. Annoyingly Claude Code specifically has real trouble interacting with them, and last I tried in agent mode refused to accept that a jj workspace is just as valid a mechanism as a git workspace. They may have fixed that by now, its been a while since I tried.
At the start of the day, I resumed working on a feature; there's no staging, so modifications I make are all stored as the current change.
Later that day I realised I needed to actually save the version of the feature that existed when I started work that morning.
So into the evolog I go (`jj evolog`). It's a record of all commits that a change has been; I could scroll back through the recorded changes, find the first change made that day, and then 'jj new' to create a change that represents that work.
It felt magical, to just be able to jump back to a project state that I didn't explicitly record, then save it.
The evolog doesn’t track explicit commits. It is a list of snapshots of the codebase. JJ creates a new snapshot every time you run a command (or edit a file, depending on how you configure it).
I recently created a project which utilizes FUSE to serve git files directly from object store without a checkout. Main motivation was to sepeedup a worktrees creation (I work on a huge monorepo). In my case it helps a lot - now I wait a second instead of a minute.
But then I realised there are other interesting features which having vfs opened:
- tree structure of related branches (simplest case of that are stacked PRs) which rebases itself
- live preview of merge state or any node of such tree
- on demand creation of a new branch which merges any of the existing ones very cheaply (e.g for a throwaway build check)
- quick and simple comand which shows conflicting files between selected worktree and all others
- agents gets notified about such conflicts when they happen
I was able to design it in a way so git sees those virtual workspaces as normal worktrees, and all git commands works exactly as you would expect. So I think for some people, especially on the very big repositpries, it might solve a few problems they try to solve with jj.
FUSE isn't new, but GitFS, EdenFS and VFS for Git solve a different problem: lazy fetching from a server. A checkout is cheap until something reads it - e.g agent trying to run rg over the whole tree. That problem is solved in gitfold.
Also gitfold does not need or try to change any existing git behavior, and is fully compatible with existing git binaries without any modifications.
So while used technology is the same, approach is from completely different angle.
Ha, fair: ClearCase dynamic views were a filesystem too. The difference is that nothing is remote and git stays the source of truth. And it's a single binary that runs without root, tiny next to a behemoth like ClearCase.
I've been using JJ almost exclusively for over 2 years now. It's great, it works fantastically with our rather large monorepo at work.
However I mostly use it backing on to a custom VCS, not git. I can't wait to see some JJ-native forges that don't try to keep it compatible with git, I think there's a lot more benefits and more UX to be explored there!
I doubt so, because not being compatible with the git repo format (and therefore requiring distinct hosting, therefore socially excluding from GitHub) is what slowly drove mercurial into obscurity, even though its UX was (and still is) superior to that of git (and JJ, which drew from it), not to mention the other aspects which made hg a much sounder choice on technical merits (e.g. very large monorepos), the users and decision makers both couldn't stand breaking away from the git repo format.
I agree that this was a factor in Mercurial dying, but I'm not sure this holds today. Mercurial performed significantly worse than git, that was a factor at the time, but in 2026 the perception is that git doesn't perform well enough (see GitHub outages, GitLab writing on this topic, Anthropic developing their own VCS, etc). Even small teams I know (circa 10 committers) are finding Git to not scale to the speed they're working at now.
JJ has the potential to be a substantial step forward in performance. This will depend on the backend to fully realise it, but a backend that prioritises scalability could vastly outperform git and GitHub's storage.
I think in the post-Microsoft acquisition, post-Dear GitHub letter era, GitHub's shine has worn off. I see a lot more use of GitLab for open source, a lot more use of various other forges. I don't think it's a requirement for a thriving open source project in the way it was for ~2010-2020.
This is somewhat on purpose. For most people GitHub is most of their git experience. But even if it's not, GitHub represents the most mature attempt to scale git storage, and at this point it seems to be clear that it's not doing well at that, at this point it's likely that's not a git problem, but a GitHub problem. The fact that other large companies have migrated off git due to scalability issues is further evidence for that. Git's data model is just not designed for the scale of software engineering happening now.
I originally thought to write "Git winning might be as simple as linux and github using it.", before I decided to shorten it:) Yes, I think that was a significant factor.
not to mention that many at mozilla cried over the loss of mercurial, with some mozillians part-time mercurial contributors rolling-up their sleeves and putting their weight behind jj as a "lesser evil" kind of compromise.
Sure, but that was before the GitHub monopoly, the social/gamification of it, before the monoculture that ensued, and at a time when it was normal to cruise through the day using 2/3 distinct VCSes (being a FOSS contributor before 2010, you probably would use svn/git/hg/bzr on a daily basis and not need to RTFM for most routine commands like branching, checking in, merging and sharing a diff/series in one form or another).
Totally different situation IMO. Git and GitHub were not incumbents at the time. Mercurial mainly lost because it was overall worse than Git, ignoring network effects.
You cannot decouple "VCS" (the component at the core of the project collaboration fabric) and "network effects". Too bad we don't have time machines: how many chose git over alternatives because "they've seen others doing it", without putting time and effort to weigh the pros and the cons? My observation is: a substantial amount.
I'm not too bothered about the backing store but I really want to see some forges gain support for code review based on jj changes rather than git branches and commits. The Github model absolutely sucks if you're someone who likes to keep a coherent history because if you squash the resolution of PR comments into the parent commits nobody can see what changed between when the comments were made and now.
Basing code review on changes and changesets would mean that the evolution of each change could be seen in isolation, which would also mean that you immediately do away with awkward workarounds like PR stacks.
I'm fully onboard with the idea that git is horrible to learn and unfriendly for beginners, and also that jj is more convenient and a better UX. I do however struggle to find the point of it for me personally when I've suffered with git for long enough that it has become deeply familiar and very intuitive, and these days I mostly interact with it at a distance through a robot. I've yet to see anything which is for me personally compelling enough to make the effort to switch.
You are welcome to do whatever you like! But I do think that you're being unreasonable when you are deliberately using a less convenient tool, seemingly just for the sake of it.
jj just makes everything so much easier. But more than that, it has capabilities that are not available in git - eg how it deals with conflicts. There's tons of guides and essays out there about all of this so I won't try to enumerate all the differences
There would surely be some uncomfortable learning period, but it is worthwhile. jjui makes it that much easier too.
Codex seems to do pretty well with jj in my experience. I often use it to do things like resolving the conflicts in a rebased stack. The two main issues I found were having to remind it to use jj instead of git in a colocated repository, and it getting stuck when some commands open the interactive hunk selector or an editor.
I wrote a jj skill (https://github.com/mhw/jj-skill) that tries to address both of those issues, and explaining some higher-level workflows like the conflict resolution example I described above. It happily goes through the conflicts creating new commits off them, resolving the conflict, and then squashing the results.
I think all the models do pretty well with jj now. I just added instructions and a skill to make sure they always use jj rather than git commands.
Only gap that I care about is jj workspaces<->git worktrees is not fully implemented. You can now auto create a worktree when you create a workspace, but not the reverse. There's prs for this though. I hope they get merged soon.
The LLMs I use seem to handle it (I'm not sure about the token efficiency though). It could actually be more token efficient because I'm not rebasing as often.
Long-term I'm sure LLMs will have JJ in their training data.
GLM-5.3 does seem to speak jj quite fluently and without consulting docs. Including complex codebase restructure and recovery of corrupted object storage.
What I miss is a guide on how a good commit history should look like, ideally focused on real-world examples.
There's lot's of jujutsu tutorials that teach you how to undo operations and write commit messages before the commit, but almost none cover what to do with all this power.
It's easy to name some general principles like “it should be easy to read” but I don't think it helps, especially if you're a novice like me.
I think you're probably overthinking things. Split your changeset into a series of commits each of which encapsulates one step along the way to achieving the overall goal of your changeset.
As an example, you might end up with "Refactor to facilitate adding feature X", "Data models for X", "API endpoints for X", "UI for X". Each of those would contain all the code/tests/documentation for each of those steps.
The nice thing about jj is that it makes it really easy to have a bunch of messy commits locally as your bouncing around the place, followed by squashing/splitting things as appropriate. In practice that first refactor commit might only come into existence very late after you've built a bunch of endpoints and done some refactoring along the way.
The guide I usually point people at is https://mainmatter.com/blog/2021/05/26/keeping-a-clean-git-h... . It talks about git and the Fork GUI, which I find to be great for visualising what is going on in the repository, particularly for beginners who don't have a strong mental model of the commit graph.
Jujutsu tries to be nonprescriptibe about the end result, but my understanding of the megamerge strategy is that you want the powerful rebasing to help you manipulate many branches in parallel (fixes, features, etc), test them together, and end up with a linear history once accepted each is accepted.
This isn't a real world example though.
In practice I end up producing a branch where the commits are the kind of "ideal"; units of work that build on each other, but not interspersed with "fix something we didn't in notice in the commit a week ago".
The single most compelling reason is probably `jj undo` and `jj redo`, with having a generally more consistent user interface and design being not far behind.
The rest is probably a bit more of a tradeoff for many people in that jj like git also has a non-traditional mental model that you have to learn, with the difference that there is actually rhyme and reason behind jj's. But whether learning that (which can be a non-trivial effort) is worth it to you if you're already accustomed to git idiosyncrasies is a personal decision.
> Perhaps the value becomes clear on larger teams, big monorepos?
I find it incredibly useful as an individual contributor opening many PRs on a single upstream project. I can rebase all my PRs onto new upstream changes in one go, I can easily keep the commit graph neat, I can easily squash changes down into specific PRs while keeping my working tree positioned after they all merge together. Really speeds up my workflow, it's awesome. And it's really cool that merge conflicts don't block operations. It's really limiting that git has only one active branch at a time.
how does using something like this compare to just using a simple git-wrapper that does all the hard stuff for you (ala lazygit)?
Is jujutsu worth learning a whole new workflow for?
In my experience, git has a few workflows that work well, and you can wrap them to improve the UX. JJ on the other hand is just designed better – there are many more workflows that will work well in it, and you can mix and match them more effectively, and because it's better designed there's less need for wrappers to simplify the UX because the fundamentals are simpler.
That said, I think JJ will get better when it's backing on to something that's designed from scratch rather than backing on to git and forges like Git(Hub|Lab) which really restrict it.
I used jujutsu regularly for a while (several months) about a year ago. My conclusion, in short, was that the improvement over my lazygit based setup was small enough that it wasn't worth the friction and small annoyances of jj. I'd still recommend trying it if you have the bandwidth for it, it just isn't a strong recommend of "this is undoubtedly better".
Longer version: if jj was what git had been originally, it would have saved millions of people a lot of pain and annoyance. It's definitely a better tool than git originally was. By now, though, git has gotten reasonably better, and the ecosystem around it has become polished enough, that the nicer, well-thought out UI of jj isn't as much of a slam dunk win anymore. It's still pretty good to work with, but there were enough papercuts for it to be not worth it for me: missing docs and features due to immaturity (presumably/hopefully to a lesser degree by now than back then), the friction of bookmarks interacting with branches in remote git forges, the fact that every throwaway file is committed right away (theoretically optional, practically assumed by every jj workflow out there) so you need to both ignore it and prune it out of history every time, there being `jj <command>`s and `jj git <command>`s that you need to remember which is which - all of these have understandable reasons and are small things, but overall added up to the fact that I felt myself dreading the jj-specific issues more than I enjoyed the upsides of it.
Recently JJ supports colocated workspace/worktrees so you get a .git directory in the workspace so git is happy. Also workmux has initial support for JJ colocated workspaces and sesh (tmux session handler) also has experimental support. Whilst there are still some sharp edges, none of them are around data integrity, and I'm using it every day. YMMV.
Use hooks. Prompts are for guiding an agent towards a goal. If you want it to never, ever, do a thing then write some hooks that detect an attempt to use git and refuse the tool use. "Is the `git` executable in this command line" is entirely deterministic and doesn't require throwing an LLM running on 15 GPUs at the problem.
> I found it hard to get Claude and other agents to use it consistently and more effectively than git.
Write yourself a very good JJ skill or reference file from your AGENTS.md.
My LLMs struggled with it a lot too, but I slowly covered everything they were messing up and they haven't made a mistake in months now. Even when there are "divergent" issues, it knows how to recover now.
> I found it hard to get Claude and other agents to use it consistently and more effectively than git.
That was the biggest hurdle for me too. I was a 2+ year jj user, then I had to switch back to git because of all the agentic tools relying on it.
I recently went back to jj, after finding a decent skill [1] and discovering Emacs' majutsu plugin. Claude still tries to do a git command every once in a while, but it's a lot more bearable.
I use jj with open weight models and Claude Opus without much trouble, even without any explicit skill loaded for them - maybe they've made it into the training data? They seem to understand how the two differ conceptually and when told that the repo it is working in uses jj they stop using stash (or at least claim to).
I can say this hasn't always been the case, and until about 2 (maybe 3?) months ago I would handle all the VCS related parts of the work. I would let the agents write code, which I've found less and less necessary to tweak as time has gone on, and write the commit messages and create the PRs by hand.
My colleagues (who use git) let Claude write commit messages, but I find those awfully long-winded and my eyes just glaze over when I open their PRs - but to each their own I guess.
At least the Claude commit messages are an improvement over the commit messages before - I gave up trying to get them to apply the recommendations of how to write good commit messages given in https://cbea.ms/git-commit/
Yeah it took me a while to get agents comfortable with it. Mostly I had access to Gemini, and 2.x and early 3.x models struggled. By 3.7 it was much better, and with all the 4 models it's a complete non-issue. Separately I (and others) worked on improving our JJ skills and they're in a much better place now with some scripts that wrap up more complex operations (e.g. maintaining file copy/move markers).
This hasn't been an issue for me for a while now, and I've actually had Opus 5.5 and Gemini Hydrogen build and submit a 28 commit deep stack, with all the reviewing/rebasing/shifting around that entails.
During late 3.x timeframe Google has been explicitly adding Jujutsu support across the agent stack in Antigravity, but it's not fully exposed unlike Git yet
That's also true, the Antigravity harness may have been a contributing factor here. I use the internal Antigravity fork which uses JJ heavily because JJ is a core supported VCS interface for us.
That tracks. I've not used JJ in public Antigravity, only in the internal fork, and that's not JJ for git, but JJ for Piper, so I don't know how much commonality there is.
I used to think this even just 6 months ago, but I no longer do. With the right prompting it's possible to get near-human results on commit chains. That said, I'm not suggesting you shouldn't review code, you absolutely should, it's just that I am fine letting agents manage the commits now.
jj is great, we use it a lot and we've hijacked it to make a decision-management/context-management system [0]. it's also generally very useful for keeping commit history clean and the squash workflow is good for progressively iterating with ai-written code, since you can squash to preserve the good parts and get agents to build on that.
JJ, using the squash workflow, is brilliant for working with Claude
The workflow is straightforward: I create a named revision for the work I want to do, then an unnamed revision on top. I prompt Claude, changes land in the unnamed revision, I review those, squash the parts that I'm ready to accept, prompt some more to iterate on the parts that aren't up to par yet. Rinse and repeat until the topmost (unnamed) revision is empty.
I instructed Claude that I use jj with the squash workflow, so it should never touch revisions with a non-empty description (I also needed to tell it to shut up about that check), and the whole thing flows pretty damn smoothly.
I just tell Claude to fold changes in their respective commits when working on a feature branch. No need to do rebase edits or anything else really. I don't really have to think of what gymnastics it has to do to get there.
It seems like a good usability upgrade to git but a few years too late. I don't even remember how to use git anymore since the only thing I do manually is pushing to and pulling from the remote repo.
I wrote a piece on what specific advantages jj brings over git, and what kind of development workflows deserve it. Give it a read if you are debating internally whether jj deserves a place in your toolbox: https://sarthakag.bearblog.dev/from-git-to-jj-jujutsu/
I'm skeptical about the no staging area, but it seems just like a HEAD commit replaces that, which could be nice.
I really don't like the automatic bookmark naming thing.
I'm also skeptical about automatic rebasing, but having conflicts not block the process could be nice, I'll have to try it out on more complex trees.
Also, I didn't see a section on workspaces, but I assume they basically do the right thing.
Have to say staging area is one feature that makes people better programmers. Especially using GUI tooling to pick hunks or discard parts you don’t want to go to a commit was always super useful for me. (CLI of staging hunks is not convenient at all for me)
I keep running into people who “just commit stuff” and they don’t know what they are doing.
Downside is we are heading into direction where people don’t even read code anymore so I might be just old man screaming at the clouds or agents.
To each their own, but I always saw the staging area as an anti-pattern that also needlessly complicated git's mental model.
With the staging area, you don't even know if the commit builds if you commit selectively, and manual adding is error-prone.
The traditional "clean" way has been to stash unwanted changes temporarily, then commit the rest.
I think jj is pretty good at this. You can use `jj squash -i` to move hunks to parent commit or `jj split to partition hunks into separate commits.
Think of it this way: you still have a staging area in jj, but now it's a commit instead of something unique and separate. There's zero obstacle to picking and discarding hunks with jj.
I do that for stash, I do not use stash for me it is commit or discard.
Here's my current workflow:
1. I write some code.
2. I realise it makes sense to commit as two commits.
3. I stage changes for the first commit & commit it.
4. I stage the remaining changes and commit those.
How would that work in JJ? I guess you do things in a different order somehow?
You would just use jj split to break the working commit into two, choosing which parts to put in which commit
Someone already said this, but you just use jj split. Either split the whole file or use interactive mode to split the exact lines. You could also use squash if you want to move it to an existing revision/commit.
Jj makes it vastly more efficient and ergonomic to perform surgery across commits - no staging area to think about, remember, stumble over, etc. Conflicts don't stop the world.
It's all dead simple if you use jjui - don't even need to learn any jj syntax
The stuff you wrote is always captured in a commit and never in some weird lingering (uncommitted) state.
Treat the HEAD commit like your staging area. Split it as you will, pick stuff you like, remove stuff you don't want and push it to a different commit, etc. Feel free to rewrite history as you will (that you haven't exposed publicly, for others to depend on).
I effectively skip staging by just doing e.g.
To commit my changes to foo and bar/* but not baz. Also pairs well with -p.if anything i think jj encourages you to commit selectively by doing jj squash <options> / jj split and by enabling you to edit commits with no worry
In jj you create a new commit for the staged parts, you can name it "wip: foobariating", and then the gui tooling allows you to move files between both commits, for me it's the equivalent of a staging area/stash that you can name
I've used jujutsu for maybe half a year by now.
At first the auto-staging (or whatever it's called) is annoying. It sure is if one is used to dump random files in the repository, that haven't been ignored.
After some time, I realised it gives a lot of freedom. Working on something but not in a workspace, and need to do something else for the day? Just jump somewhere else. Everything will still be there when you get back. In other words, it's hard to lose things by mistake. In those situations it's also cool to describe (name) the work being done, prior to making a normal commit. A bit odd but one can also push `@` to a remote (e.g. iterating on something and piggy backing on a CI-system), avoiding having to squash and then push.
Having a stack of PR's, then rebasing it all to see a conflict, and only having to deal with it one is also magical.
Moving bookmarks around can be annoying.
Workspaces work fine, and there's two options:
- the normal ones, where a full .git isn't created. That works fine, unless having tooling that expects the workspace to also work as a git repository, in which case ..
- you can make the workspace collocated, less lightweight, but git tooling works
As others have said, the head commit is effectively a staging area, it just contains everything that you've done which you can then split/squash/rebase as you see fit. `jj split -i` felt like magic the first time I used it.
Automatic bookmark naming is 100% cursed, I always name them, and also don't subscribe to this weird one commit per-bookmark/PR thing people seem to have adopted. You can use bookmarks just like git branches in practice.
Rebasing is so much nicer than doing the same thing with git because its going to do its best to finish the job, then leave you with a coherent set of conflicts you can clean up one commit at a time. Its still conflict resolution, and it still sucks, but at least you feel less like you're fighting the tooling.
Finally, workspaces exist and work reasonably well. Annoyingly Claude Code specifically has real trouble interacting with them, and last I tried in agent mode refused to accept that a jj workspace is just as valid a mechanism as a git workspace. They may have fixed that by now, its been a while since I tried.
I have a good story around these features.
At the start of the day, I resumed working on a feature; there's no staging, so modifications I make are all stored as the current change.
Later that day I realised I needed to actually save the version of the feature that existed when I started work that morning.
So into the evolog I go (`jj evolog`). It's a record of all commits that a change has been; I could scroll back through the recorded changes, find the first change made that day, and then 'jj new' to create a change that represents that work.
It felt magical, to just be able to jump back to a project state that I didn't explicitly record, then save it.
I don’t get the excitement, it looks a lot like branching off a commit
The evolog doesn’t track explicit commits. It is a list of snapshots of the codebase. JJ creates a new snapshot every time you run a command (or edit a file, depending on how you configure it).
I don't mind auto commits too much, but auto adding files really doesn't work for me.
I'd be OK if I had to immediately (blocking any operations) choose whether to add or (locally) ignore the file, but auto-add isn't for me.
Agreed, seems like we want this:
Yes you can create an empty commit on the top of your branch, it works like a staging area.
Or edit the commit if you just want to make a quick fix you know you'll want to squash immediately.
Shameless plug, but a bit related to jj:)
I recently created a project which utilizes FUSE to serve git files directly from object store without a checkout. Main motivation was to sepeedup a worktrees creation (I work on a huge monorepo). In my case it helps a lot - now I wait a second instead of a minute. But then I realised there are other interesting features which having vfs opened:
- tree structure of related branches (simplest case of that are stacked PRs) which rebases itself
- live preview of merge state or any node of such tree
- on demand creation of a new branch which merges any of the existing ones very cheaply (e.g for a throwaway build check)
- quick and simple comand which shows conflicting files between selected worktree and all others
- agents gets notified about such conflicts when they happen
I was able to design it in a way so git sees those virtual workspaces as normal worktrees, and all git commands works exactly as you would expect. So I think for some people, especially on the very big repositpries, it might solve a few problems they try to solve with jj.
https://github.com/pkukielka/gitfold
A few typical use cases: https://github.com/pkukielka/gitfold/blob/main/docs/guide.md
You made it much further with this effort than i did! https://github.com/rektide/jj-workfuse
I think in truth I 50% of the reason I made it was because I was mad about Anthropic inventing a whole new vcs after blaming git clone speed. I also knew artifact-fs exists, which works lazily to get data on demand, which is cool. https://github.com/cloudflare/artifact-fs https://news.ycombinator.com/item?id=47792374
There are quite a few of those projects already I'm pretty sure, e.g. GitFS.
FUSE isn't new, but GitFS, EdenFS and VFS for Git solve a different problem: lazy fetching from a server. A checkout is cheap until something reads it - e.g agent trying to run rg over the whole tree. That problem is solved in gitfold. Also gitfold does not need or try to change any existing git behavior, and is fully compatible with existing git binaries without any modifications. So while used technology is the same, approach is from completely different angle.
> I recently created a project which utilizes FUSE to serve git files directly from object store without a checkout.
this for some reason gives me clearcase vibes...shudder.
Ha, fair: ClearCase dynamic views were a filesystem too. The difference is that nothing is remote and git stays the source of truth. And it's a single binary that runs without root, tiny next to a behemoth like ClearCase.
I've been using JJ almost exclusively for over 2 years now. It's great, it works fantastically with our rather large monorepo at work.
However I mostly use it backing on to a custom VCS, not git. I can't wait to see some JJ-native forges that don't try to keep it compatible with git, I think there's a lot more benefits and more UX to be explored there!
I doubt so, because not being compatible with the git repo format (and therefore requiring distinct hosting, therefore socially excluding from GitHub) is what slowly drove mercurial into obscurity, even though its UX was (and still is) superior to that of git (and JJ, which drew from it), not to mention the other aspects which made hg a much sounder choice on technical merits (e.g. very large monorepos), the users and decision makers both couldn't stand breaking away from the git repo format.
I agree that this was a factor in Mercurial dying, but I'm not sure this holds today. Mercurial performed significantly worse than git, that was a factor at the time, but in 2026 the perception is that git doesn't perform well enough (see GitHub outages, GitLab writing on this topic, Anthropic developing their own VCS, etc). Even small teams I know (circa 10 committers) are finding Git to not scale to the speed they're working at now.
JJ has the potential to be a substantial step forward in performance. This will depend on the backend to fully realise it, but a backend that prioritises scalability could vastly outperform git and GitHub's storage.
I think in the post-Microsoft acquisition, post-Dear GitHub letter era, GitHub's shine has worn off. I see a lot more use of GitLab for open source, a lot more use of various other forges. I don't think it's a requirement for a thriving open source project in the way it was for ~2010-2020.
You conflate Git and GitHub a few times here. I'm a heavy git user, almost never anywhere near GitHub.
This is somewhat on purpose. For most people GitHub is most of their git experience. But even if it's not, GitHub represents the most mature attempt to scale git storage, and at this point it seems to be clear that it's not doing well at that, at this point it's likely that's not a git problem, but a GitHub problem. The fact that other large companies have migrated off git due to scalability issues is further evidence for that. Git's data model is just not designed for the scale of software engineering happening now.
Pushing and pulling from a git instance without a working directory on a server is seriously fast and robust.
Try `git init --bare --shared`. You'll never pay for GitHub again.
Mercurial and Git arrived exactly at the same time, in 2005. Most people were using SVN (or some of them still on CVS).
If Mercurial was better than Git it would have won the distributed versioning system war.
I remember Mozilla picking Hg instead of Git to migrate from CVS, and most people were unhappy about it because they prefered git.
I don't think that follows. Even at the same time, social and network effects have impact. Git winning might be as simple as linux using it.
Non trivial part was that GitHub had better UX than Hg-supporting forges.
People learnt git to use GitHub
I originally thought to write "Git winning might be as simple as linux and github using it.", before I decided to shorten it:) Yes, I think that was a significant factor.
not to mention that many at mozilla cried over the loss of mercurial, with some mozillians part-time mercurial contributors rolling-up their sleeves and putting their weight behind jj as a "lesser evil" kind of compromise.
We're still on SVN. We exist.
Compatibility helps with adoption, but it isn't absolutely required. Git wasn't compatible with the CVS repo format, but still became popular.
Sure, but that was before the GitHub monopoly, the social/gamification of it, before the monoculture that ensued, and at a time when it was normal to cruise through the day using 2/3 distinct VCSes (being a FOSS contributor before 2010, you probably would use svn/git/hg/bzr on a daily basis and not need to RTFM for most routine commands like branching, checking in, merging and sharing a diff/series in one form or another).
Totally different situation IMO. Git and GitHub were not incumbents at the time. Mercurial mainly lost because it was overall worse than Git, ignoring network effects.
You cannot decouple "VCS" (the component at the core of the project collaboration fabric) and "network effects". Too bad we don't have time machines: how many chose git over alternatives because "they've seen others doing it", without putting time and effort to weigh the pros and the cons? My observation is: a substantial amount.
I'm not too bothered about the backing store but I really want to see some forges gain support for code review based on jj changes rather than git branches and commits. The Github model absolutely sucks if you're someone who likes to keep a coherent history because if you squash the resolution of PR comments into the parent commits nobody can see what changed between when the comments were made and now.
Basing code review on changes and changesets would mean that the evolution of each change could be seen in isolation, which would also mean that you immediately do away with awkward workarounds like PR stacks.
I'm fully onboard with the idea that git is horrible to learn and unfriendly for beginners, and also that jj is more convenient and a better UX. I do however struggle to find the point of it for me personally when I've suffered with git for long enough that it has become deeply familiar and very intuitive, and these days I mostly interact with it at a distance through a robot. I've yet to see anything which is for me personally compelling enough to make the effort to switch.
You are welcome to do whatever you like! But I do think that you're being unreasonable when you are deliberately using a less convenient tool, seemingly just for the sake of it.
jj just makes everything so much easier. But more than that, it has capabilities that are not available in git - eg how it deals with conflicts. There's tons of guides and essays out there about all of this so I won't try to enumerate all the differences
There would surely be some uncomfortable learning period, but it is worthwhile. jjui makes it that much easier too.
[delayed]
JJ would be interesting to me pre-AI, but these days I don't run VCS commands myself so the problems JJ solves don't apply to me anymore
Does this work well with LLM workflows? Any advantages over git for say Claude or GPT or Gemini to stage changes in a better way?
Codex seems to do pretty well with jj in my experience. I often use it to do things like resolving the conflicts in a rebased stack. The two main issues I found were having to remind it to use jj instead of git in a colocated repository, and it getting stuck when some commands open the interactive hunk selector or an editor.
I wrote a jj skill (https://github.com/mhw/jj-skill) that tries to address both of those issues, and explaining some higher-level workflows like the conflict resolution example I described above. It happily goes through the conflicts creating new commits off them, resolving the conflict, and then squashing the results.
I think all the models do pretty well with jj now. I just added instructions and a skill to make sure they always use jj rather than git commands.
Only gap that I care about is jj workspaces<->git worktrees is not fully implemented. You can now auto create a worktree when you create a workspace, but not the reverse. There's prs for this though. I hope they get merged soon.
The LLMs I use seem to handle it (I'm not sure about the token efficiency though). It could actually be more token efficient because I'm not rebasing as often.
Long-term I'm sure LLMs will have JJ in their training data.
GLM-5.3 does seem to speak jj quite fluently and without consulting docs. Including complex codebase restructure and recovery of corrupted object storage.
I wish there was a jj-bench somewhere
edit: there is! https://tabbyml.github.io/jj-benchmark/
What I miss is a guide on how a good commit history should look like, ideally focused on real-world examples.
There's lot's of jujutsu tutorials that teach you how to undo operations and write commit messages before the commit, but almost none cover what to do with all this power.
It's easy to name some general principles like “it should be easy to read” but I don't think it helps, especially if you're a novice like me.
I think you're probably overthinking things. Split your changeset into a series of commits each of which encapsulates one step along the way to achieving the overall goal of your changeset.
As an example, you might end up with "Refactor to facilitate adding feature X", "Data models for X", "API endpoints for X", "UI for X". Each of those would contain all the code/tests/documentation for each of those steps.
The nice thing about jj is that it makes it really easy to have a bunch of messy commits locally as your bouncing around the place, followed by squashing/splitting things as appropriate. In practice that first refactor commit might only come into existence very late after you've built a bunch of endpoints and done some refactoring along the way.
This is my commit style guide I wrote up based on what I've seen that makes PRs easier to review: https://epage.github.io/dev/pr-style/
The guide I usually point people at is https://mainmatter.com/blog/2021/05/26/keeping-a-clean-git-h... . It talks about git and the Fork GUI, which I find to be great for visualising what is going on in the repository, particularly for beginners who don't have a strong mental model of the commit graph.
Jujutsu tries to be nonprescriptibe about the end result, but my understanding of the megamerge strategy is that you want the powerful rebasing to help you manipulate many branches in parallel (fixes, features, etc), test them together, and end up with a linear history once accepted each is accepted. This isn't a real world example though.
In practice I end up producing a branch where the commits are the kind of "ideal"; units of work that build on each other, but not interspersed with "fix something we didn't in notice in the commit a week ago".
Google offers some advice on how to write good commit messages: https://google.github.io/eng-practices/review/developer/cl-d...
If the only thing you're lacking is experience, try it out! You'll develop your own judgement along the way.
jj gives you excellent tools to change your mind mid-way.
Follow the guide Git provides for contributing to itself! It's there in the source distribution, though I don't think the man pages.
None of the pages explain to me what jujutsu is or why I should choose it over git.
The single most compelling reason is probably `jj undo` and `jj redo`, with having a generally more consistent user interface and design being not far behind.
The rest is probably a bit more of a tradeoff for many people in that jj like git also has a non-traditional mental model that you have to learn, with the difference that there is actually rhyme and reason behind jj's. But whether learning that (which can be a non-trivial effort) is worth it to you if you're already accustomed to git idiosyncrasies is a personal decision.
Yeah, git never makes it to any list of tools I have a problem with.
Clearly other people are delighted with jj though.
Perhaps the value becomes clear on larger teams, big monorepos?
> Perhaps the value becomes clear on larger teams, big monorepos?
I find it incredibly useful as an individual contributor opening many PRs on a single upstream project. I can rebase all my PRs onto new upstream changes in one go, I can easily keep the commit graph neat, I can easily squash changes down into specific PRs while keeping my working tree positioned after they all merge together. Really speeds up my workflow, it's awesome. And it's really cool that merge conflicts don't block operations. It's really limiting that git has only one active branch at a time.
tried jj once or twice, it just didn't quite click for me. Gitbutler seemed more intuitive, although more than likely less powerful.
I also strongly recommend this guide https://v5.chriskrycho.com/essays/jj-init/
how does using something like this compare to just using a simple git-wrapper that does all the hard stuff for you (ala lazygit)? Is jujutsu worth learning a whole new workflow for?
In my experience, git has a few workflows that work well, and you can wrap them to improve the UX. JJ on the other hand is just designed better – there are many more workflows that will work well in it, and you can mix and match them more effectively, and because it's better designed there's less need for wrappers to simplify the UX because the fundamentals are simpler.
That said, I think JJ will get better when it's backing on to something that's designed from scratch rather than backing on to git and forges like Git(Hub|Lab) which really restrict it.
I used jujutsu regularly for a while (several months) about a year ago. My conclusion, in short, was that the improvement over my lazygit based setup was small enough that it wasn't worth the friction and small annoyances of jj. I'd still recommend trying it if you have the bandwidth for it, it just isn't a strong recommend of "this is undoubtedly better".
Longer version: if jj was what git had been originally, it would have saved millions of people a lot of pain and annoyance. It's definitely a better tool than git originally was. By now, though, git has gotten reasonably better, and the ecosystem around it has become polished enough, that the nicer, well-thought out UI of jj isn't as much of a slam dunk win anymore. It's still pretty good to work with, but there were enough papercuts for it to be not worth it for me: missing docs and features due to immaturity (presumably/hopefully to a lesser degree by now than back then), the friction of bookmarks interacting with branches in remote git forges, the fact that every throwaway file is committed right away (theoretically optional, practically assumed by every jj workflow out there) so you need to both ignore it and prune it out of history every time, there being `jj <command>`s and `jj git <command>`s that you need to remember which is which - all of these have understandable reasons and are small things, but overall added up to the fact that I felt myself dreading the jj-specific issues more than I enjoyed the upsides of it.
While jujitsu is superior to git in many ways, I found it hard to get Claude and other agents to use it consistently and more effectively than git.
Git and jj work trees are not interoperable, so any tool that assumes git forces you back. Looking at you, Claude app…
Recently JJ supports colocated workspace/worktrees so you get a .git directory in the workspace so git is happy. Also workmux has initial support for JJ colocated workspaces and sesh (tmux session handler) also has experimental support. Whilst there are still some sharp edges, none of them are around data integrity, and I'm using it every day. YMMV.
Oooh thanks for pointing that out! :)
Use hooks. Prompts are for guiding an agent towards a goal. If you want it to never, ever, do a thing then write some hooks that detect an attempt to use git and refuse the tool use. "Is the `git` executable in this command line" is entirely deterministic and doesn't require throwing an LLM running on 15 GPUs at the problem.
> I found it hard to get Claude and other agents to use it consistently and more effectively than git.
Write yourself a very good JJ skill or reference file from your AGENTS.md.
My LLMs struggled with it a lot too, but I slowly covered everything they were messing up and they haven't made a mistake in months now. Even when there are "divergent" issues, it knows how to recover now.
> I found it hard to get Claude and other agents to use it consistently and more effectively than git.
That was the biggest hurdle for me too. I was a 2+ year jj user, then I had to switch back to git because of all the agentic tools relying on it.
I recently went back to jj, after finding a decent skill [1] and discovering Emacs' majutsu plugin. Claude still tries to do a git command every once in a while, but it's a lot more bearable.
[1] https://github.com/netresearch/jujutsu-workflow-skill/
I use jj with open weight models and Claude Opus without much trouble, even without any explicit skill loaded for them - maybe they've made it into the training data? They seem to understand how the two differ conceptually and when told that the repo it is working in uses jj they stop using stash (or at least claim to).
I can say this hasn't always been the case, and until about 2 (maybe 3?) months ago I would handle all the VCS related parts of the work. I would let the agents write code, which I've found less and less necessary to tweak as time has gone on, and write the commit messages and create the PRs by hand.
My colleagues (who use git) let Claude write commit messages, but I find those awfully long-winded and my eyes just glaze over when I open their PRs - but to each their own I guess.
At least the Claude commit messages are an improvement over the commit messages before - I gave up trying to get them to apply the recommendations of how to write good commit messages given in https://cbea.ms/git-commit/
Yeah it took me a while to get agents comfortable with it. Mostly I had access to Gemini, and 2.x and early 3.x models struggled. By 3.7 it was much better, and with all the 4 models it's a complete non-issue. Separately I (and others) worked on improving our JJ skills and they're in a much better place now with some scripts that wrap up more complex operations (e.g. maintaining file copy/move markers).
This hasn't been an issue for me for a while now, and I've actually had Opus 5.5 and Gemini Hydrogen build and submit a 28 commit deep stack, with all the reviewing/rebasing/shifting around that entails.
During late 3.x timeframe Google has been explicitly adding Jujutsu support across the agent stack in Antigravity, but it's not fully exposed unlike Git yet
That's also true, the Antigravity harness may have been a contributing factor here. I use the internal Antigravity fork which uses JJ heavily because JJ is a core supported VCS interface for us.
Lots of JJ in public antigravity changelogs, it just seems not wired into UI well
That tracks. I've not used JJ in public Antigravity, only in the internal fork, and that's not JJ for git, but JJ for Piper, so I don't know how much commonality there is.
I wrote an extensive skill some time ago. Works really nice https://codeberg.org/thisalex/jj-skill
It's a tad opinionated: my agents are not allowed to push to external repos — but that's easy to change if you need
You should really be doing your own commits anyway. It's not hard, and it's important to make sure you review what is going into the repo.
I used to think this even just 6 months ago, but I no longer do. With the right prompting it's possible to get near-human results on commit chains. That said, I'm not suggesting you shouldn't review code, you absolutely should, it's just that I am fine letting agents manage the commits now.
I have hooks that prevent repository modifications with git commands. And I have a global AGENTS.md file that says to prefer jujutsu if present.
It works totally fine.
jj is great, we use it a lot and we've hijacked it to make a decision-management/context-management system [0]. it's also generally very useful for keeping commit history clean and the squash workflow is good for progressively iterating with ai-written code, since you can squash to preserve the good parts and get agents to build on that.
[0]: https://github.com/edawise/deccy-cli
I don't really see the point anymore of mastering jj or git; Claude does all the hard stuff for me.
JJ, using the squash workflow, is brilliant for working with Claude
The workflow is straightforward: I create a named revision for the work I want to do, then an unnamed revision on top. I prompt Claude, changes land in the unnamed revision, I review those, squash the parts that I'm ready to accept, prompt some more to iterate on the parts that aren't up to par yet. Rinse and repeat until the topmost (unnamed) revision is empty.
I instructed Claude that I use jj with the squash workflow, so it should never touch revisions with a non-empty description (I also needed to tell it to shut up about that check), and the whole thing flows pretty damn smoothly.
I just tell Claude to fold changes in their respective commits when working on a feature branch. No need to do rebase edits or anything else really. I don't really have to think of what gymnastics it has to do to get there.
But git cant undo claudes mistakes. jj can.
I have made my peace with git.
But I still miss the number commit references from mercurial...
Is that syntactic suger?
Is Domain Expansion planned?
Nice to see a minimal alternative to git.
Also I’m sure there’s a joke in here about rollbacks.
Have anyone tried jj together with gh stack?
It seems like a good usability upgrade to git but a few years too late. I don't even remember how to use git anymore since the only thing I do manually is pushing to and pulling from the remote repo.