Way back when I started out on my career, the term "senior developer" was a title I associated with genius level hackers in movies who could make code do just about anything. A developer who reached this level obviously would know everything there was to know about their particular stack and would produce elegant sophisticated polished code that would never fail for some mundane reason like a missing conditional check. HA
Senior does not mean competent
These days I put zero weight in the term and in fact look on anyone claiming to be a senior developer with some amount of suspicion. To put it simply over the years I have encountered so many applications written by so called "senior" developers that should be consigned to the great recycle bin in the sky that I sometimes wonder how humanity is still alive.
One shining example I encountered was an application that dealt with large arrays of financial data, written without using a single array. The reason...the original developer did not know how to declare, let alone manipulate arrays. I kid you not! And this is but one of many many examples I could give.
Time vs Experience
Individuals tend to acquire the title "senior" through a simple process of hanging around long enough. This is particularly common in big corporations where someone slowly rises through the ranks as higher up people are promoted or retire. This doesn't even take a lot of skill. All that is required is patience, a basic understanding of the product domain, the ability to use corporate jargon and a good read on office politics. The bigger the corporation the less technical skill is required.
To explain this simply I've come up with a saying, which anyone who knows me will be very familiar with:
There are two types of "senior" developer. Senior Developers with 15 years of experience and "senior" developers with 1 year of experience repeated 15 times.
What we need is better terminology. After looking back over the years I have realized that I have (broadly speaking) encountered three classes of "Senior Developer".
These are developers who by virtue of being alive long enough are the sole repositories on knowledge on how a system or technology works and as such are "almost" irreplaceable.
This actually happens fairly often, either someone builds a complex system and doesnt document its quirks so that everyone else is afraid to touch it, or a system uses a technology that nobody knows or wants to learn about anymore. There are very few people who would want to learn a language like cobol these days, yet there are probably still fortune 500 companies who depend on some system written is one of these so called "dead languages".
Old developers are a step up from legacy developers in that they have managed to keep their stack knowledge somewhat up to date or got lucky in choosing a language/technology in its very early days and as such their skill set is still relatively current. They do not possess anything close to an advanced level of skill in their technology, they just know enough to get by in a technology that is still considered current and have been around long enough to be considered senior (which is commonly mistaken for experienced/competent).
I actually find these types developers to be the most problematic. Unlike the legacy developers who just tend and tweak their aging system while never really doing too much, old developers continue to build new applications using the same basic level of skill they had when they first started in their positions. However due to their "senior" status now have the authority to override/ignore anyone with less seniority when making important design decisions.
These are the rare few developers who have both the talent and interest to continually grow both their skills and understanding of a given problem domain. I consider these to be the craftsmen/craftswomen of our industry and we do them a disservice when we lump them in with the other two groups when we use the term "Senior Developer".
Indeed, many "Master" developers as I would call them are often overlooked or underappreciated as they have not been around long enough in terms of age to be given the title of senior and their talent is thus wasted.
How do we fix this
I'm not sure that this is a fixable problem. I have seen far too many blog posts and presentations around software quality to believe that this industry wants to change. A lot of what we build is invisible to the end user so it is actually pretty profitable to just do the bare minimum, and as long as that is the case these senior developers can skate by.
If you personally want to try to make things better I would suggest this. If you are a manager or asked by a manager to write a job description for a senior developer, tell them this. Tell them you will not write a job description for a senior developer but you will write one for a Master Developer.
Lets remove time and age as valid indicators of a persons skill levels in our industry.