This is kind of a poor take. By all means use what you prefer! But understanding git and knowing the "right" way to use it doesn't make jj obsolete.

I am (or was) a git expert. I’ve used it since pre-GitHub. I’ve written a git implementation. I know (or knew) the interface inside and out. I haven’t deleted and re-cloned a repo in as long as I can remember.

jj is still leagues better. Things I want to do and know how to do in git are dramatically faster and easier. They require less mental overhead. They’re less error prone. And I get superpowers with workflows that are super useful but wildly impractical in git.

This isn’t even really opinion at this point. Any task you can give me in git, I can with almost near certainty give you a shorter and more elegant alternative with jj that is an intuitive and obvious interaction with its core primitives.

A month ago our company split off a division. They needed to take a specific repo and sanitize out all of the parts that aren’t relevant to the new company, going back to the beginning of its commit history. You can do this with git. It wouldn’t be fun. I’d have to spend a lot of time reading the filter-branch manpage, and people have written countless wrappers of varying quality that try and make it a bit more ergonomic.

It took me like ten minutes to come up with:

    declare -rA paths=(
        …
    )

    # for every commit that touched a file
    # we want to excise
    for id in "$(
        jj log \
            --revisions '..' \
            --no-graph \
            --template 'change_id ++ "\n"' \
            "${paths[@]}"
    )"; do
        # restore those paths’ contents from the
        # the empty root commit; this happens 
        # entirely in-memory without having to check
        # out each revision into the working copy to
        # do file operations so it is FAST
        jj restore \
            --ignore-immutable \
            --from 'root()' \
            --to $id \
            "${paths[@]}"
    done

    # remove any commits that are now empty 
    jj abandon \
        --ignore-immutable \
        --revisions 'empty() ~ root()'

Not only was this more or less obvious to do, but it was exceedingly fast to perform on a pretty highly-trafficked repo due to not having to thrash around in the working directory with checkouts.

> Magit is a much better git frontend than Jujutsu. It guides you down the right path but doesn't take away any of the power of git at all.

jj is more powerful than git. It’s not simply a dumbed-down alternative. By having a more carefully chosen set of primitives that compose better, you gain a lot of abilities that are technically possible with git but never used in practice due to the complexity.

And you can still do all the normal git things too.