What makes a great developer?
At Freshleaf, we invest a lot in choosing the right people for our team. I think it probably drives the recruiters crazy. But just because it says “developer” on a CV doesn’t mean they have what it takes. The ability to drink coffee and write code isn't enough. So, what does make a great developer?
Has a passion for what they do
The first thing I look for in a developer is passion. I’ve never met a great developer who did it just for a paycheck. Developers who are worth their salt would write code even if they never got paid for it. True developers are problem solvers, and they build things just for fun. They have Github accounts that are bristling with pet projects and things they’re experimenting with or trying out. First and foremost, I would never hire a developer who didn’t love what they did.
Is self-taught, always learning, peer reviewed
Let’s be honest, most developers are self-taught. We have a university up the road which churns out graduates with degrees in web-related technologies. And that’s all well and good, but it’s not what I’m looking for in a dev. Being self-taught comes out of my first point – passion. People who love writing code are in a continual process of learning more – not to please their bosses or further their careers, but just because they want to.
However, in addition to teaching themselves, the best developers have had plenty of opportunity to learn from others. It’s not a formal process, but it is necessary to avoid what I call the “developer bubble” where a developer in isolation learns how to write code that just about gets things done but never gets corrected on bad decisions. So they don’t improve.
Developers who have never worked closely with others can superficially appear to be fairly knowledgeable and productive. That is, until you look more closely. Their code may not be buggy per se, but it’s not scalable or extensible. It’s just good enough for the “right now” requirements. But when someone comes through later to add a feature or amend the functionality, instead of finding a nice stable foundation to build from, they find that the previous developer has painted them into a corner.
“I can’t change anything here without breaking everything!”
It’s not intentionally bad, it's bad because they don’t know any better.
Sees the bigger picture & understands the value of planning
How do you tell an experienced developer from a junior one? Give them a task and see how long before they write a line of code. A junior will be straight to their keyboard. But someone with more experience will stand back for a minute.
First, they’ll make sure they’ve properly understood the requirements. And that’s not just what they should do, but why. Not just “what am I going to build?” but “what problem is this actually supposed to solve?” Is there another way this could be done? What other features is a user going to need or expect? What are the possible hurdles and pitfalls?
Then, once they’ve got to grips with the requirement, they’ll spend a bit of time assessing some different approaches, working out the best response to the problem. An experienced developer knows that there’s more than one way to skin a cat, and that half an hour of planning can save many wasted hours later.
Spots the “Gotchas”
Development is often a game of dependencies. And a good developer is like a chess player – capable of thinking several moves ahead, and understanding the consequences of each move, without actually having to make it. That means that they’re rarely ambushed by anything, and they don't waste time writing and re-writing sections of code. It’s partly a skill borne of experience (and being ambushed a few times) and partly a mindset. And it sets the great developers apart from the good.
The other stuff
There are other skills that are great to find in developers besides the ability to simple write good code. Testing and debugging are highly prized skills. Estimating is another one. Some devs can do all that, and talk to clients, mentor other developers, and contribute to online communities. But you don’t need “Rockstar developers” to make a great team. What I look for above everything else is people who love coding, are natural problem-solvers, and are always learning.