I think that for many developers, it’s all too common for them to have heard or even to have said something along the lines: “That’s nice, but I could build that, too” or perhaps go even further and then say “that’s nice, but I could build it better.”

In fact, years ago, the classical example of this was:

I could’ve written Twitter in a weekend.


Surely some of you guys remember that.

Anyway, there’s another thing that’s interesting in the development community and that’s that we’re all taking advantage of the work of others who have come before us.

To use a cliche, we’re standing on the shoulders of giants.

And what I’m getting at has nothing to do with whether or not you could’ve written Twitter in a weekend, but that there are certain signals of developer maturity, and one of the first is recognizing that regardless of whether or not you know when to write it from the ground up, and when you know when to use the work of others.

The Signal and Noise of Software Development

It should never be said that developers aren’t opinionated people.

Granted, we’re all opinionated at different levels – some sit around with their fellow local developers talking about things, some share their thoughts on, ahem, a blog – but the truth is that we have our thoughts and many of us are interested in conversing with others about them.

Of course, some people are more interested in convincing others that their perspective is more right than others (read: strong opinions, strongly held), and others who are more interested in having a conversation about what is more correct than a given alternative (read: strong opinions, weakly held).

But what does this have to do with developer maturity?

“I’ve Got a Secret”

Early in my career, I remember meeting many other developers who were around my age – not all, but many – who felt as as if software development was a secret that only a few people were privileged to hear despite the fact the industry had been around for decades.



And I remember being extremely turned off by this. Of course, this naturally raised the question: Why do people even feel this way?

Five Signals of Developer Maturity

Straight up, I don’t have an answer to this particular question (or phenomenon or whatever it is you want to call it), but over the past few years of working at a larger company, leading a team, then working for myself, and within the context of a startup, there are a number of things that I’ve observed that differentiate those who have matured beyond this stage.

In short, it kind of turns up the level of signal-to-noise ratio as it relates to professional developers.

1. Solutions, Not Ego

Generally speaking, I think that mature developers care more about providing solutions for others regardless of the career in which they are operating – a corporation, a contract, a startup, or their own company – than they care about proving themselves.

It’s not about finding satisfaction in or showing off “look what I can do,” it’s about finding satisfaction in helping solve a problem for others.

2. Value, Not Acclaim

Similarly, more mature developers find that doing good work and providing value and solutions for others than in finding acclaim for their work.

Sure, we all enjoy the pat on the back for some of our work, but if the ultimate goal that you have for what you’re doing is to achieve a level of acclaim, then I’d claim you’re in programming for the wrong reason.

3. Give Credit Where It’s Due

As I mentioned, we’re all building on the work of those that come before us. There is very little technology that the average developer uses that hasn’t been created or helped to be built than by a prior developer of team of developers.

To that end, they do not mind attributing certain aspects of their inspiration, their work, or another aspect of a project to whatever person or team helped them.

This could be through helping to generate an idea, this could be through a third-party library contributing to the overall application, or this could be to another mentor that helped to build their business.

4. “I Don’t Know”

Perhaps the most significant sign of maturity as it relates to a developer’s career is when they are okay to admit “I don’t know” when faced with a problem.

And here’s why: No one knows the solution to every problem. If they did, then there’d be no work for us to do, right? And the the thing, developers aren’t always paid simply to implement a solution – they are paid to find a solution.

It’s okay to say “I don’t know” right now because you’ll be able to say “Now I know” later.

5. No Fear For Mistakes

No software ships without bugs, and it’s impossible to recognize every single possible use case for a piece of software regardless of how much work you put into the planning the thing.

In fact, I’d venture to say that for every widget that you introduce into your user interface, the potential for something to go wrong increases exponentially (rather than linearly).

And, as software matures, this only increases.

At some point, you have to come to terms with the fact that you’re going to make mistakes and that you’re likely going to be called out for it.

Best case scenario: someone contacts you quietly, you release a fix, problem solved. Worst case: they call you out publicly on a site, you release a fix, and the Internet moves on to the next big thing the next week.

I Doubt That’s It

The truth is, it’d be mistake and it’d be presumptuous if I didn’t admit that I believe that these observations will change or won’t further develop over time.

Granted, I’ve been learning to write software since I was young – and I’m still learning to write software today. I’m further that I was then, and I hope that I’ll be further tomorrow than I am today.

But, at this point in time, these are five observations I’ve seen in the last few years as it relates to developer maturity.