Steve Snodgrass — All-Day Suckers (CC BY 2.0)

“Junior dev for life” is a tagline that was recently popularized by Dan Abramov. Dan is the author of Redux. He’s very smart, very respected, and worthy of emulating in a lot of ways. If all developers tried to be a little more like Dan Abramov, our culture would be much improved.

But on this one point, I disagree with Dan. “Junior dev for life” sounds nice. Sounds like you’re humble and committed to staying in learning mode forever, right?

Right. But it breaks down easily. Let’s be honest with ourselves for a minute:

Do you want junior PAY for life?

for life? Do you want junior SKILLS for life?

for life? Do you want junior RESPECT for life?

for life? Do you want junior RESPONSIBILITY for life?

for life? Do you want junior CONTRIBUTION for life?

Senior developers:

Get paid more.

Develop great coding skills.

Earn more respect.

Earn more responsibility.

Become team-wide productivity multipliers.

Contribute a lot more value.

That’s not what people mean when they say “junior dev for life”. What they really mean is that they want to stay humble, and they always want to stay open to learning new things. That sentiment is great. I completely agree with that bit.

Making the commitment to become a developer is making a commitment to lifelong learning.

But calling yourself a “junior dev for life” is really about humility. So let’s talk about humility.

What is Humility, Really?

Some developers have a warped understanding of humility, what it means, why it’s valuable, and how to approach it. Let’s set the record straight. Here’s how Merriam-Webster defines humility:

Humility: freedom from pride or arrogance: the quality or state of being humble.

Humility doesn’t require you to hide your skill. What we’re really talking about is avoiding arrogance. What is arrogance?

Arrogance: an attitude of superiority manifested in an overbearing manner or in presumptuous claims or assumptions.

An arrogant person feels the need to puff themselves up, or put other people down in order to feel good about themselves.

Arrogant people often:

Assume that they’re the smartest person in the room.

Refuse to explain something because the other person “wouldn’t understand”.

Talk down to others / condescend.

Pretend to be smarter than they really are.

Assume they can’t learn new things from other people.

True Humility

Let’s start with what humility isn’t:

Humility isn’t humble-shaming people who self-identify as rock stars, masters of their craft, or experts. Don’t worry about what other people call themselves. How can you presume to know what’s better for other people? That’s the opposite of humility: It’s arrogance.

You worry about you.

Humility isn’t about selling yourself short, hiding your expertise, or downplaying your skills.

True humility is:

Willingness to learn new things.

Willingness to share your expertise with others and lift the rest of the team up.

Being honest about your skills.

Asking for help when you need it.

Treating the rest of the team with respect.

Always assuming that no matter how much you have learned, there’s always room to take your skills to the next level.

Work hard to develop undeniable skill. Take pride in your craft. Pour yourself into it and get passionate about it. Do that, and you won’t have to call yourself an expert: everybody else will.

You can be a humble rock star. In fact, I’d say that goal is 100x better than “junior developer for life”.

Become a humble rock star; not a junior developer for life.

What’s Wrong With Being a Junior Dev?

Absolutely nothing. It’s a stage of development that all of us go through. It’s how new developers get their foot in the door. It’s just a recognition that you’re new at the game, and that because you lack the experience that other developers can bring to the table, you’re probably going to need a lot more time to ramp up, and a lot more hand-holding.

You won’t always see the pending disasters lurking around the corner. You won’t always see the obvious patterns that a senior developer who’s solved the same problem 100 times can spot.

Junior developers bring a lot of value to teams — but that value is more about normalizing a culture of helpfulness and mentorship than about being an individually super-productive member of the team. You’re expected to contribute, but nobody expects you to be a rock star at this stage.

And that’s fine. At your next job, you’ll need less hand-holding and you’ll ramp up faster. You’ll be more productive. It’s a natural progression, and nobody is holding it against you.

But you want to step up from that. You’re expected to progress. You’re expected to get better with practice.

You’re expected to evolve.

People who say “junior dev for life”, are trying to send the message, “I’m really chill and humble, this isn’t about my ego, and I’m all about learning new things”, but employers might hear:

“I don’t care about evolving and pushing myself to the next level. I’m not even trying to be a 10x developer.”

You don’t want to send that message. You really don’t want to send the message that you’ll settle for junior-level pay and treatment even though you’ve been in the game 6 years and you’ve done outstanding work.

Employers want to hire developers who are pushing themselves to improve. Employers look for really self-motivated people who want to be 10x devs.

Every developer should be asking themselves, “what can I do today to get closer to 10x?”

What Does “Junior Developer” Mean to Employers?

To employers, junior developers are valuable for two very important reasons:

Hiring a junior developer is an inexpensive way to improve development bandwidth. Junior developers earn an average of $38,000/year less¹ than senior developers. Junior developers are cheap.

than senior developers. Junior developers are cheap. Having junior developers on staff is a great way to encourage a culture of mentorship and healthy collaboration because junior developers naturally need a lot of training and hand-holding, even to accomplish seemingly simple tasks.

A well balanced team will have at least one senior developer for each junior developer on staff. Senior developers multiply the productivity of the rest of the team through code reviews, pair programming sessions, and mentorship. On well balanced teams, junior developers can ramp up and start contributing at decent levels within 2–3 months.

A culture of mentorship where thoughtful code reviews, Q&A, and pair programming sessions are the norm can help junior developers start contributing at or near the level of a typical senior developer within a year. A great learner will start to kick it into high gear around the 6–9 month mark.

In other words, balancing a good team with junior developers can be a very cost-effective way to add throughput to the team.

You can’t shortcut it though. A team of all-junior developers is a train wreck waiting to happen. Likewise, if you hire a junior developer and fail to provide the mentorship and support they require, that developer is going to end up slowing down the rest of the team by contributing low quality code that nobody wants to maintain.

Conclusion

“Junior developer for life” is a nice sentiment that superficially sounds like humility, but if you really want a mantra that will guide you better towards success, try “always learning”, instead.

You’ll never master everything about software development, but you can and will become a master of many software development skills. Make mastery your north star — your target to aim at.

With the goal of mastery, and an “always learning” mantra, you’ll rock at your job and develop a genuine passion for your craft.

Evolve past junior level contributions as quickly as you can. Become an expert. Master your craft. Become a productivity multiplier. Set your sights on 10x.

Don’t settle for less than your absolute best. Whatever you do, don’t be a junior developer for life.

#alwayslearning

Next Steps

How can you go from junior to senior fast, earn an average of $38,000 more, and get more enjoyment out of your craft?

Learn JavaScript with Eric Elliott. Members get lifetime access to videos that guide you through concepts like TDD, React, Redux, functional programming, prototypal inheritance, and a whole lot more.