Most of the developers at my company came from the same university I did. Most of us came in through the same capstone program. My mentor was one of them, a few years ahead — he'd come up through a capstone himself, then ended up leading the team I was a part of as a student. He's the one who interviewed me: a college kid full of imposter syndrome, with no real idea whether any of this was going to turn into a job.
It did. I was hired right out of graduation, and he became my mentor, alongside a senior developer on the team. He taught me things that had nothing to do with code — how to communicate clearly, how to stay calm under a deadline, how to actually talk to someone instead of just exchanging tickets. He was the first coworker I felt comfortable reaching out to when I was stuck. That sounds like a small thing. For me, at the time, it wasn't.
The actual barrier was never the code
I had a habit of wanting to solve everything myself before I'd let anyone else see I was stuck. Some of it was ego — I wanted to be the one who figured it out. Some of it was something closer to fear, maybe introversion, maybe a bit of anxiety, about asking and being told the answer was obvious. Whatever the exact mix, the result was the same: I'd sit with a problem for hours instead of sending one message that could've solved it in five minutes.
Senior developers made that worse, for a while. Years of accumulated knowledge, each of them sharp in some specific way the others weren't — they felt like final bosses in a video game, the kind you don't approach until you think you're ready. I wasn't ready for a long time. What changed wasn't that I got smarter. It's that I grew into the role enough to stop treating every question like evidence I didn't belong there.
One day, one of those senior developers told me — not in these exact words, but close enough — to use my coworkers. He'd just watched me spend two hours going nowhere on something one of them could've answered in a sentence. That's the moment the lesson stopped being abstract. It had a name now, and it was aimed directly at me.
My turn
I shadowed a capstone team before I led one — alongside the other developer who'd started at the company the same week I had, who already had two capstones behind him by then. I knew leading one myself was inevitable. I also kept finding reasons to put it off. When it was finally my turn, I was nervous about being in a room full of university students I assumed had more relevant experience than I did, having to answer their technical questions and also hold the shape of the whole project at the same time.
The first few meetings were shaky. I wasn't used to hosting them, wasn't fully sure of my own answers half the time. It got easier fast — faster than I expected. 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 for one. By the end of that capstone, I had a kind of confidence in myself as a developer that I hadn't had walking in.
Closing the circle
After that capstone wrapped, I was in the company meetings where we talked about the students we'd interviewed — who was a good fit, and why. Every one of them was strong in their own way. We extended one offer, and that developer became my mentee. I went from being the student my mentor once interviewed to being the person sitting on the other side of that same conversation.
Mentoring him is part of what pushed me into being a mid-level developer myself — not just writing code, but reading someone else's, explaining why a fix works instead of just handing it over, telling him when he's heading in the right direction even when the code isn't perfect yet. I used to tutor kids in programming, years ago. A lot of the same instincts apply here, just aimed at someone close to my own age instead of a twelve-year-old. How you explain something so it actually lands hasn't changed nearly as much as I expected it to.
I don't know exactly how much of his progress traces back to anything I've said or reviewed, and I keep that uncertainty on purpose — he's a good developer on his own, and I'd rather undercount my part in that than overstate it. But I know what it felt like to have someone do this for me, and I know it mattered more than I could've explained at the time.
Two other students from that capstone reached out to me afterward for references, even though neither of them ended up on my team. I gave both gladly. One of them got a job out of college partly because of that conversation with a recruiter and the reference behind it. That's the part of mentorship that has nothing in it for the person giving it — no project benefit, no team upside, just someone willing to vouch for you because they watched you work.
One day, my mentee will probably do the same for someone else. That's the whole shape of it, as far as I can tell. Someone hands you the thing they didn't quite get enough of themselves, and you spend the next few years figuring out how to hand it forward, to whoever's willing to listen.