When you’re new to engineering, there’s a strong (and healthy) desire to learn as many new techniques and technologies as possible. This is is great! It’s good to have lots of tools in the toolbox and to know what’s out there, and we should always be exploring.
But there’s a counter pressure here too - it’s often more efficient to work with code or tools that we know and understand well. And this also makes a ton of sense - why learn everything from scratch each time? But this risks becoming stagnant or isolated over time, as the rest of the industry moves on.
So, how do you balance these? One part of the answer is that you have to consciously do a little of both, all the time. Have tools and code you invest in and are comfortable with, but don’t let them be the only things you use. Working with something new is almost always less efficient, so you have to make space in your life for that inefficiency. You can call it “play” or “research” or “investment” if you want. But some regular percentage of your time should be dedicated to trying out new tools and sometimes incorporating them.
Another part of the answer is to look for tools that compound over time - they compose with each other, the capabilities are reusable and can be applied elsewhere, etc. Being very familiar with a scripting language or development environment might be a good example of this. Sometimes engineers build their own toolkits of scripts and other things that are useful - this is a good way to get compounding, if the tools are general purpose enough to be reused.
All the tools in your mental toolbox should be there for a reason. They should be as useful as possible - you should have a great understanding of them, use them regularly, get compounded value from them, but you shouldn’t be trapped by them. And you should discard them when something better comes along.
It’s essential to be comfortable with our tools, but not too comfortable.