Thanks for articulating something I've always tried to tell others.<p>Yes, writing readable code is preferred, but as an individual developer, you can't just wait for others to make their code readable before you're able to understand and contribute to it, you need to work on your skill of reading code, even badly written code that is unreadable.<p>There's also another dimension I think people often overlook, don't just write readable code, write easily extendable, modifiable and testable code.<p>Having code that very clearly explains that it has a shared global that is manipulated and touched by each component doesn't really help with the task of adding or changing a feature without breaking anything else or taking forever to do so, because of having to touch too many things in the process.<p>And what's counter intuitive is that writing simple well designed code may actually make it harder to read, if you're not aware of the patterns or constructs that are leveraged to allow the code to be designed so it can be easily extended, modified or tested.<p>For example, you might find using Java streams to be harder to read than a for-loop. You might find dependency injection harder to follow than just creating new resources wherever they are needed. You might find using some DSL for templating harder to read than just doing your own string concatenation, etc. That is, until you learn about the patterns and constructs and become familiar with them, and good at reading and understanding them as well.<p>That's why I would say the most important things are in that order:<p>1. Get good at writing extendable, modifiable and testable code. That means, code that can be extended, modified and tested quickly with low risk of breaking other things and requiring minimal code changes in the smallest number of places.<p>2. Get good at reading code, both bad messy code with poor names, no consistency, and complicated designs and abstractions (this includes learning tricks to explore such code with logs, prints, debuggers, leveraging IDE features, etc); as well as good code that uses more advanced patterns and language features you don't yet understand very well.<p>3. Get good at making the code you write readable, that means clear intuitive names, useful comments, proper formatting, consistent patterns, not abstracting beyond what is relevant, stay close to the problem, etc.