Is it better to learn from a tutorial or just by building?

If you want to build it - just do it!

Personally I tend to do just enough reading of a book/documentation/tutorial to get started then jump into a project - I may have a slight bias here :)

Then when stuck, or just not making enough progress read a bit more to get unblocked.

Everyone's mind works differently. If you already have experience coding in other languages and are skilled in reading documentation, starting with building could be the way to go. Personally, I usually skim the basics of a language (e.g. syntax), check how it compiles/builds/runs, then get started coding in it.

Where tutorials really thrive is taking people who have no/limited coding experience and getting them building something. It's also helpful for having a structured way for learning specific things. For example, there could be a tutorial that uses C++ concurrency, and it could help getting you thinking correctly about concurrency. You could pick up concepts you would not have otherwise and gain abilities to build projects similar to the tutorial. If you are not looking for that or prefer to jump straight in, do! You'll quickly find out what you don't know and be ability to iterate quickly by looking up the concepts relevant to you building your CLI tool.

The learning from organic building is always higher-quality than what you would get from a tutorial. If you're getting bored from the tutorial, you should definitely just jump in and start piecing things together on the fly.

However, this doesn't mean that tutorials don't have their place:

1. They're a good starting off point, especially if you're picking up a very unfamiliar tech stack (e.g. Android -> ML Infra).
2. As David mentioned, their structure is very helpful for very junior engineers who are still learning how to code. For folks who are less than 6 months in after writing their first line of code, they will probably need tutorials for a few months before they can go build stuff on their own.

That being said, you should never spend >2+ months on the tutorial phase. The problem with tutorials is that you aren't really learning how to build software if you're closely following them - You're merely sharpening your ability to follow directions (which we all learn in grade school). If you are going to do tutorials, you should level up the learning with the following:

1. Go off-script - At each step, try to tweak the logic a little bit and see what happens. Let's say the tutorial has you create a red button. You can try changing it to purple and figure out which line of code is necessary for the color styling.
2. Pick a tutorial with purpose - Let's say you want to learn iOS. The wrong way to learn iOS is to just blindly do some tutorials for Swift and "building your first iOS app". What you should do instead is have a vision of what you want your first iOS app to be and work backwards from that. Pick a tutorial that helps you achieve that vision of your first app. This is what I did when I was following iOS tutorials to build what Taro is today. As a content app, Taro needs to be able to render a list of items. So the only tutorial I did for learning SwiftUI was this one which had me build a simple app that showed a list of landmarks.

Another way of putting #2 is to decompose your goal into the collection of "legos" behind it and follow tutorials (or just stitch together StackOverflow answers) to acquire each lego. You can learn about The Lego Model here: How The Best Software Engineers Learn A Tech Stack - The Lego Model

To sum it all up, my process for learning a new tech stack completely on my own is:

1. Have a clear initial build objective of what I want to do with this new tech stack
2. Find 1 fairly holistic tutorial that covers a lot of the "legos" I'll need for #1
3. Complete that tutorial within a few days and start organically building for the rest

I wrote an entire article about tutorial hell and other traps junior engineers fall into as well: 5 Junior Software Engineer Learning Traps

A good rule of thumb to balance the two is to only consume when there is a clear intent on what you're looking for. Otherwise, build to find out where you may be stuck (and keep going until you are).

You'll feel a noticeable difference when you're in "hunting mode" when consuming vs. passively taking in information. One very clear pattern is you'll skip many parts of the content when "hunting" vs. consuming linearly from beginning to end when passive.