Just as many other software developers, I like video games. I've spent countless hours grinding and leveling my characters in RPG games like Diablo. As your character grows in levels, you choose their skills and put points into attributes. Perhaps the most classical attribute set is: strength, dexterity, vitality and magic. They define whether your character is a wise mage, a strong fighter, or an agile sharpshooter.

I decided to take this approach and develop a similar role-playing character system for software developers. For me as a manager, my direct responsibility is to give feedback and provide guidance to developers. So if you don't have a good system, it can be very hard to come up with crucial points, which your developers colleagues need to work on to get to the next level.

So here are the seven attributes of a developer that I came up with:

1. Knowledge
2. Problem-solving
3. Performance
4. Initiative
5. Reliability/Autonomy
6. Teamwork
7. Leadership

1. Knowledge - It is how good a developer knows their tools, how wide and deep their skill set is. It's a general technical fitness and overall expertise. In a role-playing system, it would correspond to how many spells do they have in a spell book. It correlates well with years of experience. Knowledge, however, does not include anything else - as we will see later, one still has to properly use these skills. A person with low knowledge is someone who just started their developer's journey. Someone with a high knowledge attribute is a seasoned veteran, who has defeated swarms of bugs and knows exactly where to look to solve a problem.

2. Problem-solving - it sounds similar to the previous attribute, but is actually orthogonal to static knowledge. It is how you come to a solution. Can you separate the important from the unimportant, do you take everything into account, or do you just follow what's written in the ticket? In chess, you may know a lot of theory, remember all the moves up until some point, but after that, you have to rely on your savviness. Someone with poor problem-solving skills will stare blankly at a screen, when the problem is formulated a little vaguely. A good problem solver can find a great solution based on incomplete information and maybe even provide plans B and C.

3. Performance - this is how you use your knowledge and problem-solving skills. There are two parts in performance: quality and quantity (quality comes first). It is not enough to just be a good developer, you also need to apply it. There is no use in your deep knowledge and ingenuity if you lazily move a couple of lines of code and call it refactoring. A mass-produced garbage code is another extreme example of poor quality. A good performing person may not be the best developer in the team, but they are the backbone. It is one of the traits that "rockstar" developers have.

4. Initiative - is bringing new ideas to the table. An initiative developer wants to change the world, the current state is just not good enough. They want to use new tools, improve the architecture, and do tech talks. If we continue with "Radical Candor" analogues, this is something "superstars" have a lot of. Not every company can handle a person with high initiative, but if you strive for the better - you need people like this. Developers with low initiative will just leave things be and go with the flow.

5. Reliability/Autonomy - these are two facets of the same attribute. You can easily delegate a task to a reliable and autonomous person and not worry if the task will be finished - it will be. The less reliable or autonomous a developer is - the more help they need from the team and management. Obviously, this corresponds with more junior developers. Autonomous and reliable work is essential for becoming a middle level developer.

6. Teamwork - corresponds with charisma in a classical role-playing attributes system. It's how pleasant a person is to deal with. Someone with a very low teamwork attribute could be for example a lone wolf. It is not so bad per se, their contribution can still be very valuable. A different example would be a toxic person - these you don't want to have in your team. A great team player helps to keep the team together and always finds a compromise.

7. Leadership - it's like initiative, but on an interpersonal level. A good leader is not necessarily the most knowledgeable developer, but it's the one with the biggest heart. It's the one who cares about their colleagues. This attribute does not really go negative, a person without leadership skills can still be a great team player and a good developer. Leadership also includes organizational skills.

It is absolutely normal that some developers are particularly strong in some attributes and have weaknesses in others. But what is important, you can work on every one of these attributes. Reading books and taking courses improves knowledge. Diligence and perseverance are key for problem-solving and performance. Being kind and willing to help others are needed for teamwork and leadership. Keeping your word makes you reliable.

Different organizations need different kinds of people. Some value teamwork and initiative over knowledge, some want knowledgeable and reliable people. Your task as a manager is to understand what attributes are key for you and look for people who have it.