Jujutsu on MoskitoHero

How I Use JuJutsu Revisions to Plan My Work Ahead

Tue, 30 Jun 2026 09:29:19 +0200

JuJutsu is a distributed version control system that allows you to manage your codebase and collaborate with others. One of its features is the ability to create revisions, which are snapshots of your code at a specific point in time. In this post, I will share how I use JuJutsu revisions to plan my work ahead.

When I start working on a new ticket, I usually create a new revision for it, with the ticket number and description, along with a bookmark, like I described in my previous post.

The next step is to start planning my work ahead. And JuJutsu makes it easier by allowing me to split my ticket into multiple sub-tasks, each matched to its own revision. That way, I can start working on one sub-task, then the next one, and so on.

This is what it can look like in practice:

Keeping that habit is very useful because it forces me to think things through before I start coding. When working with an agent, it also gives it the context of the piece of work I am doing, and allows it to focus on the right sub-task, instead of trying to solve the whole ticket at once.

What often happens it that when editing a revision, I realize that I have to change something I had not anticipated in the previous one. In that case, I just go back to it and edit it. If that change is important and requires a lot of work, I usually create a new revision on top of the previous one, and squash it once I am happy with the result.

The icing on the JJ cake is that if those changes lead up to conflicts, they do not block me. I can follow my train of thought, and resolve the conflicts later, when I have more time / energy to devote to it.

Once everything is done, I can squash all the revisions into one, or keep a few of them as logical milestones in my work if I want to keep track of the progress I made.

Nujutsu Custom Jujutsu Commands in Nushell (With a Neovim Twist)

Tue, 23 Jun 2026 06:40:13 +0200

I use Nushell as my main shell. I love it for the UX, the UI, and the syntax. I do sometimes hate it for not being POSIX, but since that’s the whole point of the thing, I cannot really complain.

I also use JuJutsu as my main VCS. I love it for the UX, the UI, and the commands.

Say what you want, I’m a tech romantic.

So let me share a little bit of NuJutsu love with those two small Nu functions I use daily at work:

jj-desc

This one interactively asks me for the JIRA ticket number, and the title of issue. It builds a formatted description out of it.

 def jj-desc [] {
    let ticket = input "Ticket number: "
    let title = input "Title: "
    jj desc -m $"[($ticket)] ($title)"
  }

jj-bookmark-from-desc

This one creates a bookmark from the current JJ description — provided it uses the correct format specified above, so [PROJ-12345] Add feature A to project C will yield a bookmark like feature/proj-12345-add-feature-a-to-project-c.

def jj-bookmark-from-desc [] {
      let desc = (jj log -r @ --no-graph -T 'description.first_line()')
      let bookmark = ($desc
        | str downcase
        | str replace --all --regex '[^a-z0-9\s-]' ''
        | str replace --all --regex '\s+' '-'
        | str replace --all --regex '-+' '-'
        | str trim --right --char '-')
      jj bookmark create $"feature/($bookmark)"
    }

The icing on the cake: Neovim counterparts

I use [jj.nvim] to manage my JJ log in Neovim.

Here is part of my LazyVim plugin definition:

return {
  "nicolasgb/jj.nvim",
  branch = "main",
  lazy = false,
  config = function()
    require("jj").setup({})
    local cmd = require("jj.cmd")
    vim.keymap.set("n", "ji", function()
      if not utils.is_jj_repo() then
        vim.notify("Not in a jj repository", vim.log.levels.WARN)
        return
      end
      vim.ui.input({ prompt = "Jira ticket: " }, function(ticket)
        if not ticket then return end
        vim.ui.input({ prompt = "Title: " }, function(title)
          if not title then return end
          cmd.describe(string.format("[%s] %s", ticket, title))
        end)
      end)
    end, { desc = "JJ describe interactive" })
    vim.keymap.set("n", "jc", function()
      if not utils.is_jj_repo() then
        vim.notify("Not in a jj repository", vim.log.levels.WARN)
        return
      end
      vim.cmd("!nu -lc jj-bookmark-from-desc")
    end, { desc = "JJ bookmark from desc" })
  end,
}

The jj-desc command is rewritten in lua and gets a nice UX with two prompts popping up in your face when you launch it.

The jj-bookmark-from-desc command is just a plain keybinding.

In Emacs, I tend to open Vterm more often, so I just use my custom Nushell functions from there.

Directory-based git config rules

Mon, 01 Jun 2026 16:22:00 +0200

Like most devs, I use Git both for personal and work stuff, but I need to use distinct user details in each case to sign-off my commits. I have a global .gitconfig that define my personal email as user.email, but whenever I need to pull a new work project, I have to remember to set it to a different value locally. Which I keep forgetting to do.

So I have found a way to alter my git config based on the directory I am working from. All you need to do is add these lines to your ~/.gitconfig:

[user]
  name = My Name
  email = personal@email.com

# Use work email for repositories under ~/dev/work
[includeIf "gitdir:~/dev/work/"]
  path = ~/.gitconfig-work

And edit .gitconfig-work:

[user]
  email = work-email@mycompany.com

I think this also applies to other git config values, so feel free to experiment!

Make Your Vcs Fly With Jujutsu

Thu, 21 May 2026 08:23:11 +0200

I like to try things out. I like new, shiny, alternative stuff that is not hype yet. I created my first Twitter account when you could see the world timeline of tweets refresh in real time on the home page. I also like new ideas that build upon great systems in order to improve them or take them a few steps further. That’s why I use Zellij, not Tmux. That’s why I use Nushell, not bash, or zsh, as my main terminal shell. And that’s why I started using Jujutsu to version control my code.

Jujutsu is a version control system UX that builds upon multiple VCS backends (Git, Mercurial, Breezy…). Jujutsu (or JJ) provides a user-facing abstraction that makes your git workflow much more flexible.

For instance, there is no such things as branches. The closest equivalent is bookmarks. But bookmarks are more akin to mutable git tags. Git commits belong to a branch, and move when the branch gets merged into another. JJ puts this the other way round: bookmarks behave the way you’d expect a bookmark to behave: they can be moved around revsets (the jj equivalent of git commits). This alone opens a wide range of possibilities.

One of the key difference with Git is that you do not have a staging area. Instead, you tend to use revsets as throwaway commits to keep track of your work in progress. You can then squash them, or move them around, or abandon them. You can come back to an earlier revision and edit it! It’s as simple as calling jj edit nf (nf being the shortcode of the revision you wish to edit) and go modify your code. No commit needed. The revision is edited as is.

No stashes either. I have a list of bookmarks with a stash prefix that I use as stashes, but they are just revsets that I can move around and manipulate as I wish.

Other killer feature: conflicts are not blockers. You can have a conflict in your code, but you can still commit and move on, dealing with the conflict later on. Especially useful when you are working on a feature branch and want to keep up with the main branch. You can just merge the main branch into your feature branch, and deal with the conflicts later on, when you have more time to focus on them.

The icing on the cake is the undo/redo feature. Yes, you read that right. JJ provides an operation log (jj op log) that tracks all your operations, including commits, merges, rebases, splits, etc. Calling jj undo will undo the last operation.

JJ lives on top / besides of your git repo. All you have to do after you install JJ is cd into your repository and run jj git init. Voilà, you can now use JJ with your git backend.

It provides you with home-made, yet efficient diff and merge tool, but you can also use your own (Meld, Neovim, Ediff, you name it). It is designed to be very user-friendly from the command line — much more than git — but a few TUI clients and IDE integrations also exist. More on that in a later post.

I started using JJ a few weeks ago, and I never looked back. I really feels it makes my VCS workflow much less of a burden.

I will probably post more about the way I use it day-to-day, along with configuration tips and tools. Stay tuned!