What are the 15 traits you need to be the best programmer?

Matthias Endler, a former backend engineer and programmer at travel booking site Trivago, has compiled 15 traits that make a great programmer in his blog.

The Best Programmers I Know | Matthias Endler
https://endler.dev/2025/best-programmers/

◆01: Read the references
The key is to always go to the primary source. Instead of jumping on Stack Overflow, asking an LLM, or guessing, it's important to read official references directly, such as the Apache Web Server documentation, the Python standard library, or the TOML specification. 'Surprisingly, official references are often easy to access and well-written,' Endler says. 'Always going to the primary resource is one of the most important habits to develop as a young programmer.'

◆02: Deeply understand the tools
'A good developer understands the technology they use at a fundamental level. Simply using a tool is one thing, and truly understanding it is another,' Endler points out. An expert can write a configuration after reading the reference, understand every line of it, and explain it to a colleague. Endler said that to truly know a tool, you need to understand 'the history of who created it, why, and what problem it solves,' 'the situation of who maintains it and where they work,' 'the limitations of when the tool becomes inappropriate,' and 'the ecosystem of what libraries, plugins, and users there are.'

◆03: Read error messages carefully
Really reading error messages and trying to understand what they say is a surprisingly powerful skill. 'The best programmers can infer a lot of information from very little context,' says Endler, who argues that you can solve most problems yourself just by reading the error messages. Whenever Endler helps someone who can't read error messages, he feels like he has 'some kind of supernatural ability, like a fortune teller who can tell the future by looking at the tea leaves left in the cup.'

04: Break down the problem
Difficulties are not always solved smoothly, and everyone gets stuck sometimes. When the best programmers get stuck on a problem, they break it down and simplify it until it is digestible. This problem decomposition is a difficult skill to learn and requires a lot of experience. According to Endler, most of the work you get paid to do as a professional developer is this problem decomposition, and if done properly, you can complete the job by simply solving simple problems one after another.

◆05: Don't be afraid to get your hands dirty
'The best programmers read a lot of code and aren't afraid to touch it,' Endler said. The best programmers don't say, 'That's not my area' or 'I can't help you with that,' but instead start learning. 'Code is just code,' Endler said, arguing that the best programmers can acquire the necessary skills with time and effort.

◆06: Always help others
According to Endler, good programmers are in high demand and always busy, but they also have the characteristic of always wanting to help, and one of the factors that makes them good programmers is that they are 'naturally curious and supportive.' Endler concludes, 'Having good programmers on your team is a pure joy, because they are problem solvers.'

07: Get into the habit of writing
Great programmers tend to be good talkers and enjoy sharing their knowledge, and often have a place to publish their thoughts, such as blogs, lectures, and open source. 'There is a strong correlation between writing ability and programming. Mastering how to write is mastering how to think, and vice versa. The style of writing says a lot about how one thinks. If it's chaotic and lacking structure, so will the coding style,' Endler pointed out, arguing that 'great programmers find pleasure in playing with words.'

◆08: Keep learning
'Some of the best programmers I know are over 60 years old. They're much better than me,' Endler said. A good programmer will learn new tools and languages that they haven't tried yet, and stay up to date. Endler pointed out that many people stop learning soon after graduating from college or starting their first job, and emphasized that 'good programmers don't blindly jump on trends, but always carefully evaluate the merits of new technology.'

◆09: Status doesn't matter
'The best programmers treat lead programmers and new developers alike; there is no hierarchy,' Endler said. He said good developers 'are willing to learn from both younger and older people.' Endler noted that 'newcomers are often not caught up in office politics and still have fresh thinking. They don't know why things are hard, so they propose creative solutions.' He concludes that 'Old obstacles may no longer exist, and these people can be a great source of inspiration.'

10. Establish a reputation
'You can be a solid programmer by doing good work, but you can only be one of the best if you become known for your good work, at least within a large organization,' Endler points out. There are several ways to establish a reputation, such as building and providing important services, writing well-known tools, contributing to popular open source, and writing books that are often mentioned. In response to the question, 'Why is reputation important?', Endler explains, 'These are all ways to expand your reach in the community. Famous developers influence many more people than less well-known developers.'

11. Be patient
'You need patience with computers and with people, especially with yourself,' Endler preaches. Not everything works right the first time, and people take time to learn. It's not that the people around you are stupid, they just have incomplete information. 'Without patience, you'll feel like the world is against you and that everyone around you is incompetent. That's a miserable state of affairs. To be the best programmer, you need incredible patience, focus, and dedication. If you want to solve difficult problems, you can't allow yourself to be distracted,' Endler said.

◆12: Don't blame the computer
Endler points out that 'Most developers blame bugs that seem quirky and 'random' on the software, other people, their dog, or the weather. The best programmers don't do that.' No matter how strange a computer's behavior may seem, there is often a mechanism behind it that just hasn't been discovered. Endler argues that 'the best programmers keep digging until they find the reason. They may not find it right away, but they never blame external circumstances. This attitude allows them to make incredible progress and learn things that others miss.'

◆13: Don't be afraid to say 'I don't know'
'In interviews, I try to get candidates to say 'I don't know' at least once, not because I wanted to gain an advantage, but because I wanted to reach the boundaries of their knowledge. I wanted to stand with them on the edge of what they thought they knew,' Endler explains. According to Endler, a good programmer will say, 'Hmm, I don't know, but that's an interesting question! If I had to guess, I'd say it's ____,' and then ask for an answer. It's important to acknowledge that you can't know everything, because being afraid to say 'I don't know' is a sign of arrogance and defensiveness.

◆14: Don't guess
When faced with ambiguity, it's important to resist the temptation to guess. The temptation to guess is very strong, but when you do, you make incorrect assumptions that can lead to bugs. In the worst case scenario, you may believe that your guess is correct and not question yourself, instead running ahead based on incorrect assumptions. Endler urges you to ask questions, read references, and use a debugger.

15. Keep it simple
'Smart programmers write smart code. Exceptional programmers write simple code,' Endler said in contrast. In most cases, simple code is sufficient, and simple code has the advantage of being easier to maintain than complex code. Endler pointed out that 'sometimes doing things right is important, but knowing the difference is what separates the best developers from the rest,' and argued that 'you can achieve a lot by keeping things simple. Focus on the right things.'

'These items are not a checklist or a competition. Good programming is not a race,' Endler emphasized. 'But don't fool yourself into thinking there's a shortcut to avoid the effort. There aren't any. Good luck on your journey,' he said, reiterating that becoming the best programmer requires continuous effort and a sincere attitude.