While other answers seem to be giving lists of skills that are needed to be considered to be at a "more experienced" level, I think the difference is far simpler.
It all boils down to how much oversight and direction you need and how does that scale.
I'll use sub-product to try and keep this from being software specific, but think of a sub-product as a module.
New grads tend to require lots of oversight/direction. They need to be taught the details of specifically how things are done at this company. They tend to be told exactly what they need to do. They tend to work on well defined pieces of a sub-product.
Slightly more experienced people but still junior might be given entire sub-products that are well defined and done under the guidance of a more senior person.
As you get a little more senior then you are given responsibility for defining the exact details of a sub-product as defined with minimal details by more senior people.
More senior and you get people assigned to help you with your larger sub-product(s).
More senior and you start to get involved in identifying all the various sub-products from some specification already defined.
More senior and you are helping create that specification from some vaguely defined customer needs.
More senior and you are actively looking for customer needs that will bring money into the company. In other words, you are defining your work assignments.
In general, it boils down to the expectation that the more senior you rise, the less guidance you need, the bigger products you are able to successfully complete and more people that you are directing.
So you may be a great "whatever your specialty" but you are still going to have a huge learning curve on how to do things the "company-way". Thus, a lot of oversight. You'll also need to prove yourself before you get out of close scrutiny. Thus, a lot of oversight. You'll learn that techniques and practices that worked great for smallish projects just don't scale well once things get bigger. Thus, a bigger learning curve than you might think. So you'll have a fair amount of do-overs, making you less efficient than someone more experienced. Even if you are a great "whatever your specialty" for a college student, if you haven't spent 8-9 hours a day practicing and applying those skills for a few years then you are not nearly as good as you think you are, no matter how smart you might be.
More specifically to software, you can't give a code-sample and show what the differences would be because it's about the entire system and not just the code snippets. It might be better to point out what is likely to occur if a new grad/junior developer is not given the proper oversight. The 2 most common problems I've seen are 1) They write absolutely terrific code but it solves the wrong problem. 2) They come up with a design and code that they feel is much better than how they were told it needs to be; the problem is that it doesn't work with the rest of the system so it can't be used.