4 Key Developer Traits to Look For When Recruiting on GitHub

It’s no secret that recruiting on GitHub is one of the best ways to find high-quality developers.

But, knowing what developer traits to look for (and where to find them on GitHub) is a totally different story.

Sure, you might be an experienced tech recruiter. And you may know exactly what your hiring manager looks for in a developer candidate.

But translating that knowledge to recruiting on GitHub isn’t always so obvious.

That’s why the SeekOut team put together this post:

To help recruiters know exactly which developer traits to look for when sourcing candidates from GitHub.

Before we dive into those traits, let’s go over why you should be recruiting on GitHub:

Here’s Why GitHub Should Be Your Go-To Source for Recruiting Developers

If you read our recent post on our newly-released GitHub Search, then you already know why more tech recruiters are turning to GitHub over LinkedIn and other sourcing sites for finding developer talent.

In short:

GitHub offers access to high-quality developers with real-life examples of their skills and expertise.

It’s about more than just finding a developer with five years of experience working for a big name company like Google or Facebook.

Instead, recruiting on GitHub means digging deep into a developer’s background to find out how their experience aligns with your company’s needs.

For you, the recruiter, that means a few important things:

1. Recruiting on GitHub reduces your time-to-hire.

If you’re relying on sites like LinkedIn to source developer talent, your time-to-hire will suffer.

And there are a couple key reasons why.

First, it’s because there are simply more active developers using GitHub versus LinkedIn.

If you run a search on LinkedIn for people in the United States with the word “developer” currently in their job title, you’ll find around 458,000 results as of publication.

(image source)

At first, that number doesn’t seem so bad. But in comparison to the 5.9 million active users GitHub has across North America, that 458,000 feels pretty small.

And the second big problem with sourcing developer talent on LinkedIn versus recruiting on GitHub comes from actually qualifying a candidate’s skills and experiences.

That’s because candidate profiles on LinkedIn often look like this:

Sure, he lists his jobs. But there’s no way to really evaluate the candidate’s expertise.

And that’s where GitHub really becomes a recruiter’s best resource.

By analyzing the repositories where your developer candidates contribute code, you’re able to ensure you only reach out to the most highly-qualified candidates.

That saves you time in the sourcing and screening process. And it saves your hiring manager time in the interview process.

The combination of those two factors means a shorter time-to-hire.

And it also means an overall higher-quality of talent in your pipeline:

2. It also improves the quality of your talent pool.

When you’re contacting candidates that you know have the requisite skills and experience for your open job, writing a cold email to them that feels personal becomes a whole lot easier.

Now combine that with writing to them at their actual email address rather than through a platform messaging system like LinkedIn InMail.

As I’m sure you could guess, your response rate is going to go up.

Way up.

And that means the overall pool of talent you have to choose from improves, too.

As you surely know, better quality hires attract more top-tier candidates…

And those top-tier candidates also contribute to your increasingly valuable pool of talent.

That sort of impact has a personal benefit for you, the recruiter, as well:

3. You’ll elevate yourself into the role of a talent advisor.

If you read our blog post on the big differences between a recruiter vs a talent advisor, then you know it really comes down to your level of contribution.

There are plenty of great recruiters who source quality talent, keep interviews organized for hiring managers, and diplomatically deliver feedback to candidates.

While good at their jobs, those recruiters are not talent advisors.

A talent advisor earns a seat at the recruitment strategy table alongside their hiring manager. They are an invaluable resource in not only finding the best candidates, but also determining how to attract them to your company.

Recruiting on GitHub means you have a better understanding of what the best developer candidates want to see from a potential opportunity.

And that puts you in a position to elevate yourself out of the traditional sourcing/screening grind into a role where you’re actually influencing the way your company attracts top-tier candidates.

But to do that, you first need to know exactly what developer traits define a “top-tier candidate” and how to identify them on GitHub.

The 4 Developer Traits to Look For When Recruiting on GitHub

#1. Professionalism

Admittedly, this one seems pretty obvious.

But, it might surprise you to find out how many developers treat their GitHub profiles like social channels that their current or future employers won’t ever see.

And it might be even more surprising to see how many recruiters ignore the “warning signs” of an unprofessional developer.

Paying attention to the developer’s GitHub username and what they include in their bio might save you from hiring a candidate who can code like a beast…

...but doesn’t have the professionalism to match.

#2. Quality of Their Code in Existing GitHub Repositories

One of the biggest benefits of recruiting on Github is the access to real-life coding samples from the candidates you’re targeting.

But, as we detailed in our GitHub Search launch post, tech recruiters need to be careful about how they evaluate developer code contributions on GitHub.

In short: if you’re only looking at the repositories on a developer’s profiles, you’re probably missing out on their most valuable contributions.

(And thereby the best examples of their coding ability.)

Because developer profiles only contain repositories they created themselves or that they forked from other users, you’re not really digging into their actual coding skills.

To do that, you would need to comb through the 67 million repositories to find their contributions — a near-impossible task for most tech recruiters.

Luckily, SeekOut’s GitHub Search solves the problem by bringing together a developer’s GitHub page and their code contributions into a single profile.

That means instead of recruiting on GitHub in two places — their profiles and the repositories — you can run one search in SeekOut and find all the information and coding samples you need to make an informed decision about them as a candidate.

For example: let’s say you needed a developer in New York that was a C++ expert. I run my search in SeekOut and come across this profile:

Based on the requirements of my search, SeekOut’s GitHub Search surfaces relevant coding samples directly on the candidate’s profile.   

From here, you can see the variety of different repositories where your potential candidate has made contributions in the past.

And when you click on any of those relevant contributions, the link leads you directly to their commits: the additions or changes that developer specifically made to the repository.

Pretty amazing, right?

Now, of course, experienced tech recruiters know it’s not just about the code — it’s also about how effectively a developer understands that code and the problem it is working to solve.

And that’s where this next developer trait comes into play:

#3. Clear Commit Messages and README files

The ability to communicate coding decisions shows that a developer is more than just a code machine — they understand the way their contributions impact the broader goals of a project.

And while some of that “deeper” knowledge will likely come out in an interview, tech recruiters can get an early preview through commit messages and README files.

In case you’re unfamiliar, here’s a quick definition of each:

What is a "commit message"?

A commit message is the brief summary of coding changes a developer makes to a repository. Here’s an example:

(image source)

While a single line of text that seemingly just explains a developer’s action might seem unimportant, as Peter Hutterer points out on the Who-T blog, it actually can tell you a lot about your potential candidate:

“Re-establishing the context of a piece of code is wasteful. We can't avoid it completely, so our efforts should go to reducing it to as small as possible. Commit messages can do exactly that and as a result, a commit message shows whether a developer is a good collaborator.”

Considering no company wants a rogue developer who doesn’t work well with others, this little insight can be a helpful “first-look” into a developer’s ability to work with a team.

What is a "README file"?

A README file provides a full description of a repository’s purpose and goals.

Think of it as a mission statement for a developer’s repositories. These obviously won’t apply to any open source repositories where your developer contributes code (the owner of that repository is responsible for the README file).

But for any personal projects, a thorough README shows you a developer understands more than just code.

It shows they understand the context of their code in the larger vision of a project.

As Mark Feffer highlights in his conversation with Robert Fleischhauer on the Dice blog:

“[A candidate’s] README files say a lot about [them], too...They provide a glimpse of the candidate’s thought processes, grasp of business problems and level of sophistication in attacking a problem.”

And that level of sophistication can ultimately translate to a much more successful relationship with a developer if and when they become a member of your team.

#4. Their SeekOut Coder Score

I’ll confess: this one isn’t actually part of a developer’s profile on GitHub.

But, if you’re using SeekOut’s GitHub Search to scan candidate profiles, our new “coder score” can be an important measure of your candidate’s skill and ability.

Here’s how it works:

Using a proprietary algorithm, SeekOut analyzes a developer’s code contributions on GitHub to determine their level of acceptance and influence among the GitHub community. We then assign developers a “score” of one to five stars.

Generally, anyone with three stars or more is an above-average developer candidate.

Considering the five-star rating is reserved for the top 2 percent of all candidates, you may not want to focus your search exclusively on five-star candidates.

Instead, looking at three-star candidates who meet your requirements and have the other developer traits outlined in this article might yield better results.