As a person responsible for an engineering team, when I need to hire an engineer into my team, how can I approach this problem? The way it works right now is that a recruiter, knowing the outline of skills that my team is currently in need of and personality traits that would ensure good culture fit,1 looks for cold candidates and works through applications. If we're lucky and well-established as a brand, we have more applications. This part of the funnel—the very top of it—is already limiting us. The very best hire that we can potentially achieve is capped at the top candidate coming into the recruiting funnel. And if we follow the satisficing strategy, there's never a 100% chance to push the best candidate of all every time down the funnel.2

I like the way the open-source community runs and evolves. My favorite example is ClojureScript: it's small enough to roughly know who are the most active members, and it's supportive and friendly. Because Clojure/Script isn't a mainstream language, and runs on JVM—the platform that requires substantial experience to hack on and ship even simple things,—its adoption is far from reaching the heights achieved by, say, Node (yet).3 The Clojure language design is, in fact, kept in control by a small group of people. But the conversation is totally open. Anyone4 can open a pull-request or an issue. React community works in a similar fashion: it has a core group of owners, but any person in the world can ask questions, open issues or contribute to the code. The overall effect is that each individual member of the community improves. People get to know better what other people expect from them. They elevate each other's social skills and emotional intelligence.

A side-effect of open-source is that people get to know each other and work with each other, naturally overcoming the boundaries that are set by their employers in many other situations. In his book “Reinventing Organizations”, Frederic Laloux mentioned the final stage of the evolution of organizations yet known to the humankind, the Teal stage, where companies understand that they don't “own” individuals and that they exist in a world that is, yes, adversarial, but also increasingly cooperative. Open-source very much looks like the Teal stage to me, because the work people do is not absolutely bound to the intellectual property they generate. If I use React on my day job, I get a kick-start from all the people who contributed to the library; if I give back, not only I do that but also provide better foundation for those who's about to begin their career. This community is a system of people and organizations that build something together, even when their incentives don't match.

Raise the bar of the average over time, faster

When a candidate comes to their potential employer, they don't know much about the company. Most do research and google stuff about it. If the company is on CrunchBase or Glassdoor, even better, but not necessarily representative of what the daily work and the possibilities to grow would look like. Some candidates—usually those who are targeting very specifically—go even deeper: find the employees of that company online, follow them on Twitter (or maybe they have been following them already), look at what they create on Github or Dribbble, and such. But recruiting is still a very adversarial process where two parties don't reveal their hands until the contract is signed.

I remember when Buffer made some noise a couple years ago when they made a bold statement with disclosing the salaries of all employees. Anyone, anywhere could open a table on Google Spreadsheets and see any Buffer employee's compensation info. Recently, indie makers started the “/open” movement, where members reveal their businesses' information such as P&L and growth. That's awesome, and the intentions obviously go beyond just getting into the spotlight for a month or two. This could also have improved their chances in recruiting—although I'm sure that wasn't anywhere remotely the point. Still, it might have worked in that it might have raised the cap on the best candidate possible. The very best are looking for companies that are, well, the best. And companies that are so confident that they make such bold statements seem to be the best. So the trick might have worked, but the overall effect is, I think, that the community got divided even more instead of getting more open.

So how could we make the community of candidates and recruiters make more open and inclusive and yet not sacrifice some limitations that companies have? More specifically, how could we make sure that, on average, a candidate that we hire is the best possible, comparing against the global pool? We could try the good part of open-source: elevating everyone so that the “average” bar goes up, thus making it easier for us to make better hires5—compared to the market in its state one month or one year ago. There are so many people, it's absolutely impossible that we “lose” to our competitors in hiring the crème de la crème, because the definition of this is different for every company.

Sure, but how?

How do we accelerate the evolution of the market? This is already happening. One simple example is StackOverflow. Quite honestly, I hardly imagine life without it anymore. Before StackOverflow, we had MSDN, a source of technical information for programmers that was tightly controlled by a single corporation and, let's put it honestly, got us all lagging because of that. We had to navigate it, inserting CDs one after another, trying different search terms to find a piece that would unblocks us. With StackOverflow letting everyone in, it made out life way easier on average. It also established the new paradigm of “lookup skills”: it's not as important to know anymore, as it is to know how to find out the solution.

Another example is, of course, Github, where people share their solutions to the problems they hit most often, increasing the likelihood of getting someone else's problem solved by pure law of large numbers. This is why companies open-source their code (or at least should be), not because it's hip or makes cool technology marketing materials and employer branding. Sharing provides tools to the global community, but also provides insights into what is important, giving necessary feedback to people who are eager to grow.

The more we collectively share, the better candidates will be getting into out funnels. So deliberate and purposeful giving might be working toward the goal that the tech ecosystem pursues.

  1. Point of view: “culture add” > “culture fit”.

  2. If not 100%, then how much? What would be the error? Author remembers his friend citing a book where the answer to this question was given in the most radical way possible: the error is roughly ⅔, meaning that only one-third of all hires would be the best potentially achievable. This does not, of course, imply that the others would be bad. Author recommends applying this heuristic cautiously.

  3. A part of Javascript's success as one of the most used languages is attributed to its short path from zero to “Hello, World”. Javascript is easy to hack around with, and the programmer does not need to have Computer Science background to make changes and see the results, making progress faster and accumulating learnings faster as a result.

  4. Letting anyone into a community backfires. Rich Hickey, the author of Clojure programming language, posted a rather dissatisfied note where he describes vividly what bothers him about the open-source and, more specifically, openness that allows anyone to say anything.

  5. “A better hire” for one company is different from what it means to another. If companies come together to develop the pool of candidates in a way that makes an average candidate more technically and socially skilled than a year before, the other variables staying the same, every player wins by the same margin, versus just a couple most funded or most publicly attractive players winning and leaving all the others in dirt.