Turns out, git sorta trains you to be very, very afraid of breaking something.
jj answers this in a few ways:
1. everything is easily reversible, across multiple axes.
2. yes, everything is basically a stash, and it's a live stash — as in, I don't have to think about it because if it's in my editor, it's already safely stored as the current change. I can switch to a different one, create a new one, have an agent work on another one, etc, all without really caring about "what if I forgot to commit or stash something". Sounds like insanity from a git POV but it really is freeing.
3. Because of 2, you can just leave conflicts alone and go work on something else (because they are, like you said, essentially stashed). It's fine and actually very convenient.
The thing the article doesn't mention, that makes this all safe, is that trunk / "main" is strictly immutable. All this flexibility is *just* for unmerged WIP. (There are escape hatches though, naturally!)
It's still not great, but it's better than anything else.
Best results when:
1. run /init and let it maintain a CLAUDE.md
2. Ask it to run checks + tests before / after every task, and add those commands to the "no permission needed list" – this improves quality by a lot
3. Ask it to do TDD, but manually check the actual test is correct
4. Every time it finishes something solid: git commit manually, /compact context (saves hella $$$ + seems to improve focus)
Honestly I treat it like a junior programmer I'm pairing with. If you pay attention, you can catch it being stupid early and get it back on track. Best when you know exactly what you want, it's just boring work. It's really good with clear instructions, eg "Refactor X -> Y, using {design pattern}."
(Default is 10 iirc, so if you want 15 more... 25)
If you want everything, ever: `jj log -r ::`
Or every ancestor of your current change: `jj log -r ..@`
reply