Not necessarily. In software, experience cuts both ways, and can be a hinderence as much as a boon.
One of the key reasons that modern day computer programmes are getting so monstrously large is precisely because of bad experience.
A lot of the time, maybe even most of the time, coders stitch together and/or repurpose existing codes rather than start with a clean slate.
That can save time when writing the code, but it also often needlessly bloats the code and slows the programme, where needless calculations are made, because the original piece of code repurposed needed to calculated two things, but you only need it to one one of those calculations in your programme, but cannot be bothered to fully disintengle the two functions of the old code.
So experienced coders could probably get something ready a lot faster than a more talented coder without their experience, but the more talented novice could approach the problem with fresh, new eyes, and potentially come up with a far cleaner, more eligant, and efficient way to tackle the problem at hand.
That is just the efficiency side of things, there is also the security implications.
On some levels, more established codes could be more secure, as they have been debugged for longer. But the flip side is that if you rely on experience and use the same code elements in a lot of places, if someone found a way to exploit a well established code element, that could open up a hell of a lot of software to the same expilot if they all used that code element.
My point is that it cuts both ways, and it will depend entirely on the circumstances, so it would be rather foolish to make any categorical pronouncements on what is best.
