joshuadavidthomas/agent-skills

jj

Jujutsu (jj) — the Git-compatible version control system.

View source

How to use

  1. Copy the installation command and review the source package before installing it in your own agent environment.
  2. Check the source document for required tools, credentials and supported hosts.
  3. Describe your input and desired deliverable; review the output against the source material.
npx skills add https://github.com/joshuadavidthomas/agent-skills --skill jj

Before you start

  • Installation does not include a model subscription, API allowance or permission to access your files.
  • Repository stars and installation counts describe activity, not an independent quality or security test.
Original skill document

Rendered from the source repository. Headings, examples, code, tables, links, and referenced images are preserved.

Jujutsu (jj) Version Control

Jujutsu is a Git-compatible VCS with mutable commits, automatic change tracking, and an operation log that makes every action undoable.

Target version: jj 0.36+

Topics

I need to...Deep dive
Understand how jj relates to Git, or use raw git in a jj repogit-compatibility.md
Write revset, fileset, or template expressionsrevsets.md
Push, pull, manage bookmarks, or work with GitHubbookmarks.md
Split, rebase, squash, or resolve conflictsconflicts.md
Run parallel agents with isolated working copiesparallel-agents.md
Configure jj, set up aliases, or customize diffsconfig-reference.md

Mental Model

The working copy is a commit. No staging area. Every file change is auto-snapshotted into @ when you run any jj command. Instead of "stage → commit," just code and describe.

Change IDs are stable. Commit IDs are not. Every commit has two identifiers:

  • Change ID — Stable across rewrites. Letters k–z (e.g., tqpwlqmp). Prefer these.
  • Commit ID — Content hash, changes on any rewrite. Hex digits. This is the Git commit ID in colocated repos.

History is mutable. Commits can be freely rewritten. Descendants auto-rebase. Old versions stay in the operation log.

Bookmarks are not branches. Bookmarks don't advance when new commits are created. They follow rewrites but must be explicitly set before pushing. → Deep dive: bookmarks.md

Conflicts don't block. jj allows committing conflicted files. Resolve at your convenience by editing conflict markers directly, then verify with jj st. → Deep dive: conflicts.md

Agent Rules

Non-negotiable when operating as an automated agent:

  1. Always use `-m` for messages. Never invoke a command that opens an editor. Commands that need -m: jj new, jj describe, jj commit, jj squash.
  2. Never use interactive commands. jj split (without file paths), jj squash -i, jj resolve — all hang. Use file-path args or jj restore workflows.
  3. Verify after mutations. Run jj st after squash, abandon, rebase, restore, or any destructive op.
  4. Use change IDs, not commit IDs. Change IDs survive rewrites.
  5. Quote revsets. Always single-quote: jj log -r 'mine() & ::@'.

Agent-Specific Configuration

toml
# agent-jj-config.toml
[user]
name = "Agent"
email = "agent@example.com"

[ui]
editor = "TRIED_TO_RUN_AN_INTERACTIVE_EDITOR"
diff-formatter = ":git"
paginate = "never"

Launch with: JJ_CONFIG=/path/to/agent-jj-config.toml <agent-harness> → Deep dive: config-reference.md

Core Workflow

The daily loop: describe → code → new → repeat.

bash
jj describe -m "feat: add user validation"
# make changes — auto-tracked, no `add` needed
jj st && jj diff
jj new -m "feat: add error handling"

Curating History

bash
jj squash -m "feat: final clean message"   # fold working copy into parent
jj absorb                                   # auto-distribute hunks to right ancestor
jj abandon @                               # drop a failed experiment

→ Deep dive: command-gotchas.md

Non-Linear Work

When new work doesn't depend on the current chain, branch off trunk:

bash
# Create sibling from trunk (doesn't move @)
jj new trunk() --no-edit -m "fix: correct timezone handling"
jj edit <bugfix-change-id>
# ... fix the bug ...

# Return to original work
jj log -r 'heads(trunk()..)'
jj edit <feature-change-id>

Agent rule: Before creating a new commit, decide if it depends on the current chain. If not, branch off trunk and flag the divergence to the user.

Pushing Changes

bash
jj bookmark set feat -r @
jj git push -b feat

Bookmarks must be set before pushing — they don't auto-advance. → Deep dive: bookmarks.md

Essential Commands

TaskCommand
Check statusjj st
View diff / logjj diff / jj log
Describe current commitjj describe -m "message"
Start new workjj new -m "task description"
Edit an older commitjj edit <change-id>
Squash into parentjj squash
Auto-distribute changesjj absorb
Abandon a commitjj abandon <change-id>
Undo last operationjj undo
View operation historyjj op log
Restore to earlier statejj op restore <op-id>
Create/move bookmarkjj bookmark create <n> -r @ / jj bookmark set <n> -r @
Push / fetchjj git push -b <bookmark> / jj git fetch

For Git translations: references/git-to-jj.md

Recovery

bash
jj undo                      # undo last op; repeatable
jj op log                    # full operation history
jj op restore <op-id>        # jump to any past state
jj evolog -r <change-id>     # see how a change evolved

Detecting a jj Repo

.jj/ directory = jj repo. Both .jj/ and .git/ = colocated repo. Always use jj commands. Git's "detached HEAD" is normal in colocated repos — use jj log for real state.

Common Mistakes

MistakeFix
Omitting -m on commandsAlways pass -m — editor hangs agents
Using jj split without file pathsProvide paths or use the jj restore workflow
Forgetting to set bookmark before pushjj bookmark set <name> -r @ first
Using commit IDs instead of change IDsChange IDs (letters k–z) survive rewrites
Unquoted revset expressionsAlways single-quote: 'mine() & ::@'
Confusing :: vs .. operators:: = ancestry path, .. = range (see revsets.md)
Creating workspaces as subdirectoriesMust be sibling dirs, not children

Reference Index

Git Interop:

Commands:

Revsets & Templates:

Sharing:

History:

Config:

Workspaces:

Related by task

from this repository

More skills

All skills
joshuadavidthomas
Community

english-please

Dude, come on. You write at the density of your own thinking and leave the reader to unpack it. Apply whenever explaining anything to a human — not just end-of-run summaries, every message.

installs
1
GitHub stars
56
Updated
Jul 20
joshuadavidthomas
Community

frontend-design-principles

Use when building or reviewing frontend UI — dashboards, admin panels, landing pages, marketing sites, web apps. Drives domain-specific design decisions (typography, color world, layout, CSS token naming, depth and spacing systems) instead of generic AI defaults; routes to app.md (product/data UIs) or marketing.md (public/creative pages) by context.

installs
1
GitHub stars
56
Updated
Jul 20
joshuadavidthomas
Community

grug-brained-dev

Use when reviewing PRs, simplifying over-engineered code, judging architecture, or renaming unclear concepts — inline fake helpers, delete meatless ceremony, rename lying names, merge over-split files, reject premature abstraction, say no to speculative config/modes/layers, then end with the smallest safe next change. Triggers when code is too fancy, too abstract, too clever, too many files/helpers/layers, or too well-factored but painful to change. Embody Grug brain: complexity very bad, small

installs
1
GitHub stars
56
Updated
Jul 20
joshuadavidthomas
Community

improve

Survey a codebase as a senior advisor and turn the highest-value findings into implementation plans for other agents to execute — strictly read-only on source code, never implements anything itself. Use when asked to audit a codebase, find improvement opportunities (bugs, security, performance, test coverage, tech debt, architecture, migrations, DX), suggest features or roadmap direction, or generate handoff plans for another agent to implement.

installs
1
GitHub stars
56
Updated
Jul 20