Most developers at my company came from the same university I did, through the same capstone program. My mentor was one of them, a few years ahead; he'd come up through a capstone, then led the team I was on as a student. He interviewed me, a college kid full of imposter syndrome with no idea whether any of this would turn into a job.
It did. I was hired right out of graduation, and he mentored me alongside a senior developer on the team. He taught me things that had nothing to do with code: communicating clearly, staying calm under a deadline, talking to someone instead of exchanging tickets. He was the first coworker I felt comfortable reaching out to when I was stuck, which was not a small thing for me at the time.
Why I didn't ask for help
I wanted to solve everything myself before I'd let anyone see I was stuck. Some of it was ego. Some was closer to anxiety about asking and being told the answer was obvious. Either way I'd sit with a problem for hours instead of sending one message that could have solved it in five minutes. The senior developers made it worse for a while: each of them sharp in some way the others weren't, they felt like bosses you don't approach until you think you're ready.
One of them told me, in not quite these words, to use my coworkers. He'd just watched me spend two hours going nowhere on something one of them could have answered in a sentence. That's when the lesson stopped being abstract.
My turn
I shadowed a capstone team before leading one, alongside the developer who'd started the same week I had and already had two capstones behind him. When it was my turn, I was nervous about a room full of university students I assumed had more relevant experience than I did, having to answer their technical questions and hold the shape of the whole project at once.
The first few meetings were shaky. It got easier faster than I expected, and somewhere in there I started doing the thing I used to avoid: sending the simple message, following up, giving a status update without being asked. By the end of that capstone I had a confidence as a developer I hadn't had walking in.
Closing the circle
After it wrapped, I was in the meetings where we discussed the students we'd interviewed. We extended one offer, and that developer became my mentee. I went from the student my mentor interviewed to the person on the other side of that conversation.
Mentoring him is part of what pushed me to mid-level: code review, walking him through deployments, planning what he works on next to grow, explaining why a fix works instead of handing it over. I used to tutor kids in programming, and a lot of the same instincts apply. I keep my estimate of my part in his progress low on purpose; he's a good developer on his own. About a year in, he's now leading his own capstone team, which is the same step I was so nervous about taking.
Two other students from that capstone asked me for references afterward, even though neither ended up on my team. I gave both. One got a job out of college partly because of that reference. That's the part of mentorship with nothing in it for the person giving it: just someone willing to vouch for you because they watched you work. One day my mentee will do the same for someone else.