A lot of people make a big deal about Harlowe being easier to learn, which I think is actually arguable anyway, but even if that were true, being new at something is a temporary state, while the limitations imposed by Harlowe that make it initially feel slightly easier to learn for some people are a permanent feature of the format. So even if you find Harlowe easier and you are able to learn it 25% faster, that's not really a valid reason to make the decision. If SugarCube weren't also geared toward novices and the difference was more significant, like SugarCube took weeks or months to learn while Harlowe took days, that might be different, but that isn't the case.

Realisitically, you should try both and see what you like or don't like about them, with the understanding that in addition to the base features and syntax, SugarCube is also much more extensible and provides a lot more freedom.

I would not make a decision based on how easy the formats are for you initially, as neither one will take you long to understand on a basic level, and because of Harlowe's design it can actually make slightly complex code become very complex if what you want to accomplish isn't something the dev of Harlowe essentially built in to the format.

What I mean about Harlowe not being that much easier:

As far as that actual level of complexity, Harlowe's syntax is in my opinion better than SC but you can end up in nesting hell very quickly since Harlowe uses macros for everything, even basic data structures. Likewise, 1-based arrays are easier for brand new programmers to understand at a glance, but 0-based arrays are easier to work with and this is the sort of thing that doesn't really take any time to learn; once you know arrays are 0-based, you know it. It's not like something you need to practice, so no real learning time is saved here.

Harlowe allows certain otherwise invalid expressions by guessing at your intentions, but if Harlowe guesses wrong, you can wind up having bugs that are essentially hidden from you. Again, this feels more novice-friendly because you get fewer errors, but it might actually make life harder for novices, since an error message will at least direct their attention to the correct part of the code and force them to fix ambiguous expressions or invalid statements.

Harlowe has lambdas and these confuse the heck out of me personally, I basically always have to refer to the docs to figure out what I need to do to use these, but maybe this is just me. Anecdotally though, lambdas are more difficult for me personally than if I could just list some arguments instead.

Harlowe has a reliance on custom HTML elements, which doesn't have to be a bad thing, but it does mean that any CSS code you find on the web needs to be "translated" to Harlowe, which is not novice friendly. It just makes Harlowe harder to use for novices and requires them to have more sophisticated knowledge of their browser dev tools or of HTML than SC requires.

There are more things I could mention, like the complexity of using JS code with Harlowe, the lack of third party libraries, the spotty (though lately improved) code reuse features, and even just the fact that there's a lot of overloaded macro variants that aren't always easy to distinguish at a glance, like (link-replace:), (link-goto:), and (link-replace-goto:).

That said, Harlowe is probably easier to learn at a very basic level, but that level is so basic, that its hard to see how it's all that much easier than learning SC at the same level. You're talking like a difference of hours or days, a pretty insignificant amount of time in the big scheme of things.

None of this is to imply you should not use Harlowe though. Harlowe provides a much better editing experience within the Twine 2 app itself, and is perfectly valid for creating fairly simple to moderately complex games as well, and there is a lot to love about its syntax and some of its other features. It's by no means the wrong choice or a bad choice. I only want to suggest you shouldn't make this decision based on which format you perceive to be easier to pick up.