Go beyond git with jj

jj is a newer version control system that's gaining traction. Come see how it's both simpler and more powerful than git — while being fully compatible with git and GitHub. We'll give you hands-on experience with using jj, explain how it's conceptually different from git, and how you can use it on an existing team.

Transcript

1. Go beyond git with jj ↓↓↓ get ready https://github.com/spinel-coop/jj-workshop
2. Go beyond git with jj Workshop  Euruko 2026 André Arko Kasper Timm Hansen
3. spinel.coop We make Rails teams more performant Quality, Speed, Joy
4. we're pathological about Open Source
5. rv.dev - install ruby in seconds - no more openssl build issues
6. brew install rv rv run irb
7. also rv run rails new rv run hanami new
8. - rv ci - rv tool install
9. oaken level up seeds for dev/test data fast tests like fixtures structured shared vocabulary around your data gem.coop/@kaspth/oaken
10. # db/seeds/accounts/kaspers_donuts.rb account = accounts.create :kaspers_donuts, name: "Kasper's Donuts" users.create :kasper, accounts: [account]
11. it's jj time
12. a brief overview of jj – version control system, like git – originally built at google – now a community project – new ideas that enable new workflows
13. in this workshop 1. why do we need a new vcs 2. conceptual changes 3. how to use 4. new workflows 5. extending jj hands on keyboard ↑ coffee break ↑
14. no rush ask as many questions as you want
15. why is jj
16. git
17. git is powerful, complicated & dangerous
18. git tooling tries to mitigate these shortcomings
19. git is a sharp knife
20. jj makes editing history safe
21. jj undo
22. jj is both simpler & more powerful
23. jj is fully compatible with git hosts …GitHub, GitLab, etc.
24. you can adopt jj and your team doesn't have to
25. jj provides clear, safe tools to: – rebase safely and easily, without breaking your repo – rewrite history without losing previous versions – be fully compatible with any git host – manage source history with confidence
26. source control doesn't need to be scary
27. we'll show you how to do this
28. after this workshop – clear grasp of jj's conceptual changes – be confident in managing changes – see new workflows that you can adapt
29. jj's conceptual changes compared to git
30. jj's conceptual changes branches aren't as important everything is a commit
31. git runs on branches
32. branches always point to the HEAD commit
33. git checkout <sha> detached HEAD state
34. in jj, you jump to other commits using jj edit
35. example: amending the previous commit
36. d30732b6 HEAD commit (some-branch) 7df1455f commit that needs amending
37. git <edit here> git add . git commit -m "fixup! <sha>" # a third commit, new HEAD git rebase -i HEAD~3
38. jj edit <sha> <edit here>
39. where are you ?
40. jj log
41. jj edit @jj edit ummrzxqv jj edit um
42. everything is a commit
43. jj keeps the "working copy" updated
44. run a jj command? that's a commit edit a file? that's a commit
45. …isn't that actually worse?
46. consistent change IDs light indirection layer on top of commits
47. jj manages commit IDs, you don't
48. change ID | commit ID soxnroqz 13cf8e83 soxnroqz abcfbbe9 soxnroqz e980d559
49. commits are still immutable changes update by pointing at a different commit
50. everything is a commit + consistent change IDs
51. jj undo
52. change IDs track your intention
53. no staging area
54. things change IDs make easy work with 5 open PRs at once split a commit into 5 across 5 branches
55. change IDs also fix rebasing
56. conflicts are commits, too
57. your turn
58. – jj log – jj edit – jj new – jj undo
59. how did that go
60. where were the branches?
61. in jj, branches are more lightweight
62. they're bookmarks
63. works like jj edit
64. you set where the bookmark points to
65. jj bookmark list / set / track
66. automatic branch names
67. jj git push --change @ ⇒ push-soxnroqz
68. jj git push / fetch
69. your turn jj bookmark list | set | advance edit/new/etc using bookmarks as easily as you use change IDs.
70. bookmark + git demo
71. see Understanding Jujutsu bookmarks
72. revsets
73. revsets  SQL for commits - run commands on multiple commits
74. jj log -r "mutable()"
75. rebasing multiple branches at once
76. jj git fetch jj rebase -r "mutable()" -o "trunk()"
77. operations + op log
78. jj undo / redo
79. jj op log / op show / op restore
80. more commands for revsets and changes
81. jj log
82. 1. @2. kv+ 3. ..A & ..B 4. ~description(glob:"wip:*")
83. closest pushable change heads(::@ & mutable() & ~description(exact:"") & (~empty() | merges()))
84. revset aliases jj log -r "closest_pushable(@)"
85. revsets can do a lot more see Understanding Revsets for a Better JJ Log Output post
86. your turn
87. jj commit / desc / new / edit / split
88. jj rebase
89. jj squash
90. your turn
91. jj restore / abandon
92. your turn
93. jj merge (doesn’t exist)
94. your turn
95. commands beyond git
96. further command reading
97. migrating workflows from git to jj
98. submit a pull request
99. your turn
100. work on multiple PRs at once
101. further workflow reading
102. conflicts
103. conflict markers
104. jj resolve
105. your turn
106. mergetools
107. beyond git
108. jj absorb jj parallelize jj evolog
109. megamerges
110. jj diffedit
111. jj squash -i
112. your turn
113. tracking edits during code review