There are two ways to use git:

- learn a basic workflow and ask/google for help for problems. A gui makes this slightly easier

- learn the underlying model for git. Then you probably still have to google for invocations occasionally but you would have to do the same with a sugary gui. And for complex actions in a gui the answer usually is 'use the cli'

Plus occasionally a gui does something incredibly weird like giving direct access to `git clean --force` like vs code did a while back.

https://xkcd.com/1597/ is a sadly accurate description of how most of us use git.

People used to say that about svn to which I akways found so odd. Perhaps I was fortunate to start out on a team that actually understood branching, merging, and most importantly, how to resolve merge conflicts?

I like git cli and find it to be amazingly well-designed and intuitive.

Ah, irony. Or maybe you could explain what's intuitive about the number of completely different things that for instance 'git checkout' is used for?

I like git, but the cli is only usable after a dash and a spoonful of aliases.

If you could expand it into a longer answer, I would appreciate that - perhaps there are some pieces of good design (git add -p?) in Git, but overall it's too messy for many.

git add, push, pull, fetch, bisect and rebase, along with git grep and log commands, are very easy to use and exceedingly rarely is anything else needed. Just use a rebase-only workflow and the cli essentially is self explanatory in terms of how your mutations affect the revisions.

Other commands like stash, checkout and branch are equally simple. It’s just a very simple user experience.

I think where people express confusion over git is that they don’t expect to be interact with revision history, rather just inflicting changes onto a head-only svn style repo.

People are mistakenly encouraged to bring that mentality to the table when it’s not useful. You need bring a mentality that you’re mutating and sculpting branches.

It’s like a beginner saying “snowboards are complicated” because they come in expecting it to be like a sled. You hear the same complaints about other systems like darcs and mercurial too, for the same reasons, even though each of those offers respectively super easy to use cli experiences as does git.

As much as I find Git's all magic incantations difficult to master, I have to agree with your comment 100%.

Once you grok rebasing branches, git add, push, pull, bisect, rebase, log, commit --amend are all I have needed to work with Git and the experience has been far better than working with any other version control like SVN or Mercurial.

> Other commands like stash, checkout and branch are equally simple

Ok, so they are the simple because you say so? Stash in all but the simplest cases is a sure-fire way to shoot yourself in the foot. Checkout is a weird guy, he does too many different things, and what's up with the double dashes? Super-weird! Also beware that any of your branch names happen to match any of the file names in the repo :O.

> I think where people express confusion over git is that they don’t expect to be interact with revision history

This is one of the things that confuses beginners about git, but it's not a confusion about git cli. You are conflating the criticism of git cli with criticism of git. Git is good, git cli is (notoriously) bad. However, eventually you'll (hopefully) learn the proper incantations and then using git cli will seem simple to you.

I never claimed any of this was anything more than my own technical appraisal / opinion. But to be clear, you’re not offering any counter argument, just unsupported assertions of your different opinion, including things like “what's up with the double dashes?“ which makes it hard for me to believe I could personally find value in your view on it.

> “You are conflating the criticism of git cli with criticism of git.”

Not at all. I’m saying most of the time when people say they are confused by git cli, that it behaves counter to their expectations, they are not actually expressing any design limitation of the cli commands themselves, but instead blaming cli commands for the conceptual confusion they have about git’s model in general.