There are many aspects of being a really good developer.
First, it’s fluency. A good developer is really quick in solving any problem given to him. Everything needs training and the more focus you put in a language, the more fluent you get with it. The more tricks you know on an IDE, the quicker you are. Typing quickly is a bonus, and a skill that is actually a combination of skills – 1) thinking in words what to type, 2) spelling the words, 3) remember the keyboard, 4) reflex.
Second, write code that are loosely coupled and self-describing. Code should be written by the single responsibility principle. Each function should do just what the name describes. Function should be simple, compact not complex. Each class should work separately and serves a single purpose. Names should be self-explaining and any assumptions clearly commented.
This way, fixing 1 bug should never introduce another bug.
Third, use design patterns. Design patterns makes the code readable, and makes the code maintainable. Proper designed application should allow you to easily and correctly locate the place to add new code, fix old code. A proper design should be scalable, no matter how large and how complex the application can be, it should always be divided into small, singular and simple classes, like a company clearly divided into different departments. No class should be complex. A complex class should be divided into many separate components.
Fourth, code is reusable. Code should not be written for 1 application. Code should be written to compose a library of stand-alone, reusable components so we can reuse to assemble other applications.
Fifth, clear architecture of the whole application. To have a clear, documented view of how the application is divided/structured/built is a must.
An application should be viewed as a company with clear departments. Each class is like 1 employee, who knows his/her department and role. A company should be composed of specialists, who are responsible for specific tasks. The architect/ system designer may not know the details of how a class/employee does a job, but he knows clearly what that class/employee does, the boundary of responsibility is clear and the scope is very specific.
Each department also has a clear scope of tasks, and so the classes inside can’t do a task that does not belong to it’s department (module-level violation). Each class also have specific scope so no code here should do what the class is not expected to (class-level violation). Each function should do 1 task only, specific to the function name. If it does things that not expected by it’s name (function-level violation) -> break it into 2 functions.
A good developer writes beautiful, easily readable code. A good developer is also a good architect, having been exposed to lots of good code so he knows how to design a program.
A good developer loves coding. He cares about his efficiency and beauty of the code. He reads code of other top developers. He learns from libraries other people have read, with intention to write libraries too, not just use them.
A coder has a structured knowledge like a mind-map tree. He knows what he is lacking and works on his weakness. He also has his interests/ strengths so he works on his strengths too to excel. He always knows what he needs to study at the moment, not just follow others and study whatever other people are studying.