Solving Nested jj Commands with Alias Configuration

The version control system “jj” (Jujutsu) has gained attention as an alternative to Git in recent years. Its intuitive handling of change history has earned praise, prompting its adoption among developers. However, its command structure has a small pitfall: the short command name “jj” may lead users to unintentionally type it consecutively. This article introduces a solution to this issue using jj’s own configuration features.

Problem Overview

When jj users attempt to type jj show in the command line, they may inadvertently enter jj jj show. This is similar to common input errors like typing git git status with Git. In the case of jj, the extra jj is interpreted as a subcommand, resulting in an error such as “unrecognized subcommand ‘jj’”. When entering jj jj show -T 'change_id.short()' to obtain a change ID, the output looks like this:

$ jj jj show -T 'change_id.short()'
error: unrecognized subcommand 'jj'
Usage: jj [OPTIONS] <COMMAND>
For more information, try '--help'.

One way to avoid this error is by setting up a shell alias. However, it’s worth noting that jj, like Git, supports alias definitions in its configuration file. By combining this capability with the jj util exec subcommand, the extra jj can be intercepted and redirected.

Defining Aliases in the Configuration File

The jj configuration file can be edited directly using jj config edit, or modified via the shell with jj config set. To resolve the nested command issue, an alias can be added to the configuration. The basic idea is to define the extra jj as an alias that executes the intended command through jj util exec.

As a first step, you can add the following configuration:

[aliases]
jj = ["util", "exec", "jj"]

This alias instructs jj to run util exec jj whenever jj is invoked as an alias. When the shell interprets the first jj, the second jj is processed as an alias, and the remaining arguments (e.g., ["show", "-T", "change_id.short()"]) are passed along. However, this setup introduces a new issue:

$ jj jj show -T 'change_id.short()'
error: unexpected argument '-T' found
tip: to pass '-T' as a value, use '-- -T'
Usage: jj util exec [OPTIONS] <COMMAND> [ARGS]...
For more information, try '--help'.

Here, the -T argument is mistakenly interpreted as an option for jj util exec itself, resulting in an error. While jj util exec accepts a command and its arguments, it doesn’t automatically pass subsequent arguments to the command unless separated with --.

Workaround for Argument Issues

To address this problem, you can use the standard Unix convention of employing -- to indicate that all following arguments should be passed directly to the command without being interpreted as options. Modify the alias definition as follows:

[aliases]
jj = ["util", "exec", "--", "jj"]

This adjustment ensures that jj util exec -- jj is executed, and all arguments following -- (e.g., show, -T, change_id.short()) are passed directly to the jj command without misinterpretation.

Verification and Practicality

After modifying the alias configuration, perform tests to ensure its functionality. Regardless of how many jj commands are stacked, the solution should work correctly:

$ jj show -T 'change_id.short()'
upvqxuzzvxtx
$ jj jj show -T 'change_id.short()'
upvqxuzzvxtx
$ jj jj jj jj jj show -T 'change_id.short()'
upvqxuzzvxtx
$ jj jj jj jj jj jj jj jj jj jj jj jj jj jj jj jj jj show -T 'change_id.short()'
upvqxuzzvxtx

All these commands return the same change ID. No matter how many jj commands are stacked, the intended command executes without errors. This setup is particularly useful for developers who are new to jj or prone to typing errors.

Scope of Configuration

This alias can be added to jj’s global configuration to apply system-wide or to a project-specific configuration for use only within a particular repository. You can also set it directly via the shell using a command like jj config set --user aliases.jj '["util", "exec", "--", "jj"]'.

One important note: this alias effectively redefines the jj string itself, which means it will behave differently from its original function as a subcommand. For instance, if you type jj jj, the alias expands to jj util exec -- jj util exec -- jj, which could theoretically result in an infinite loop. However, actual testing has shown that this does not occur, as jj util exec -- jj executes the command through the shell without recursive expansion. Still, this behavior might change in future versions of jj, so users should remain vigilant.

Comparison to Similar Cases

This solution bears similarities to the resolution of the “Git git git git git” issue. With Git, a similar approach involving alias configuration and the use of -- can be employed. Compared to Git, jj’s alias definitions in the configuration file are more intuitive. Additionally, the availability of the jj util exec command makes addressing this problem easier.

In contrast, using shell aliases like alias jj='jj' would not resolve the nested command issue. It’s essential to avoid recursive alias expansion, and jj’s configuration alias feature allows for seamless handling without such risks.

Conclusion

Adding an alias to jj’s configuration file and using -- to properly pass arguments can effectively ignore accidentally repeated jj inputs. This simple trick can reduce stress during command-line operations and improve productivity. It’s particularly valuable for developers who are new to jj or prone to typing errors.

Implementing the fix requires only a single line of configuration, which takes immediate effect. By opening jj config edit and appending the alias, users can quickly enable this solution. If no issues arise after testing, it can be used continuously. This practical tip leverages jj’s flexible configuration capabilities to enhance the user experience.

Editorial Opinion

This alias configuration for jj is commendable from the perspective of improving command-line interface usability. In the short term, it can alleviate the frustration caused by typing mistakes, especially for beginners who may find jj’s learning curve daunting. This technique could also be applied to similar nested command issues in other CLI tools.

From a long-term perspective, the flexibility of configuration in version control tools can significantly impact user adoption and retention. Compared to Git, jj’s alias configuration is more straightforward, which could serve as a competitive advantage. As the jj ecosystem grows, it will be beneficial for such practical solutions to be shared and documented within the community.

The editorial team believes it is worth exploring the depth of jj’s alias functionality and investigating whether similar nested command issues arise with other subcommands (e.g., those related to jj git operations). Additionally, as the behavior of jj util exec may evolve with future updates, ongoing monitoring will be essential.

References

• Lobsters — Published on June 30, 2026
• Official jj Documentation: https://martinvonz.github.io/jj/latest/config/