Custom image, original Richard Hendricks image via

29 Behaviors That Will Make You An Unstoppable Programmer

When it comes to programming, there is the notorious myth of the 10x developer. It is said that a 10x developer accomplishes roughly 10 times as much as the other programmers on the team. It’s quite a controversial topic and there are people on both sides of the issue.

Some people propose the myth of the 10x developer is absolutely ludicrous and others say that the variation from a standard to rockstar programmer is more like 100x or 1000x more productive.

Whether you choose to believe the idea of the 10x developer or think it’s utterly ludicrous, there is a certain set of behaviors that all unstoppable programmers share.

In fact, there are 29 things that these special programmers do differently than everyone else.

If you’re trying to level up as a programmer, pay particular attention to #15 and #29

1. Use Google very aggressively.

As a developer, you need to know how to phrase search queries, review other developers’ code, and apply it to the problem that you’re trying to solve.

In 2016, it’s essential to know how to properly research tools using the technologies available on the web.

2. Maintain an obnoxious amount of stick-to-itiveness.

Veteran programmers embrace the experience of being a beginner with new technologies and teach themselves on the fly. Every expert was a beginner at some point in time. And there are so many technologies out there that even an expert in one technology is a clueless noob in another.

3. Acknowledge that micro-decisions matter.

When writing programs, it can often feel like there are a billion decisions you need to make, even when you’re just adding a small feature. For example, things like naming variables, calling functions, naming CSS properties, using a hash vs using an array, and other seemingly small things can have a big impact.

New programmers often don’t pay enough attention to these types of things. But unstoppable programmers develop patterns to help them name variables, and they reach a point where they don’t need to think about it because they always name things the same way.

4. Acknowledge that most major decisions don’t matter that much.

In the process of building out applications, you’ll make major decisions that will impact how you write most of your code. For example, you’ll generally want to use a Test-Driven-Development approach. There are a few different tools that you can use to test your code.

In ruby, for example, you might have to weigh the differences between MiniTest vs. RSpec. People have really strong opinions about these types of decisions. But unstoppable developers think differently and tend to not care too much. They value the habit of writing tests, and they understand that the specific tooling that you use to do so isn’t as important.

Unstoppable programmers do not participate in the flamewars that other developers often find themselves in. Instead, they roll with the punches. Unstoppable programmers are quite zen-like.


5. Always use the right tool for the job.

There are so many different open source libraries, tools, and frameworks out there. Experienced programmers know what to use for each problem that they encounter. They’re willing to stomach the pain of learning something new if it will ultimately allow them to be more productive.

This allows them to narrow their research to 2 or 3 options, then quickly apply the best possible tool to their product immediately to understand how it will work out in their environment.

6. Understand that code is cheap.

You need to be ok with scrapping hundreds of lines of code to do things in a different way. Often, the only way to learn that a certain approach will not pan out is to give it a solid attempt.

Many people look at scrapping code in favor of something else as a waste of time. But the experience gained from writing the code should actually be considered an “output,” just like shippable code. It’s simply part of the process that led to the result.

7. Evaluate technologies based on all their merits.

Often, average developers will evaluate technologies while omitting the giant elephant in the room. For example, I’ve been bullish on Elixir. It has wonderful syntax, an amazing community, and a bright future. But it’s so new that if you want to actually build complex features, you’ll have a harder time finding open source technology to make your life easy. You need to take all of these factors into account.

8. Say “I don’t know.”

There’s no quicker way to waste your time as a developer than to refuse to acknowledge what you don’t know. Unstoppable programmers understand that your self-worth isn’t tied to a few facts that you’ve memorized. The “stuff” doesn’t really matter.

What makes you valuable isn’t what you know, but rather your adherence to these behaviors. Unstoppable programmers know that every technology (programming language, framework, library, etc…) could no longer be a viable option tomorrow. They think about programming on a higher level.

9. Always analyze the clues found in error messages.

Traditional education has taught us that failure is bad. Error messages are often associated with failure. However, good programmers know that these messages are actually clues that lead you down the path to the right solution. And they know that they consist of two key parts:

  • The actual message, which is a plain-text sentence describing the problem that exists in the code.
  • The Call Stack (the more important part), which helps you understand the exact line of code that contains the error and the reason why that line of code is being executed.

It’s also worth noting that developers are likely to encounter similar error messages time-and-time again. You should focus on learning how to fix the problems and why you need to fix them. Doing so will allow you to fix similar errors at a faster rate in the future.

For example, ruby developers have seen the error message: “No Method Error on nil:NilClass” probably more times than someone starting out has seen any error message.

10. Know the difference between a premature optimization and a show-stopping optimization that NEEDS to happen.

Code often has trade-offs. And typically, there are at least two different ways you can write your code:

  • Way #1: Write your code in the most straight-forward way possible
  • Way #2: Write your code in a more confusing way to be faster

Since people want applications to be fast, you need to consider how long it will take your code to execute. However, it’s even worse to take code that is already fast enough and turn it into something that confused other developers.

Unstoppable programmers know the right time to write code that’s a bit more confusing, but will be faster.

11. Take responsibility for your mistakes.

Mistakes will happen. Especially when working on a team. Most problems that result from working on a team are not related to code, and they involve miscommunication between members. Typically, there are multiple parties at fault in these situations.

Unstoppable developers treat their life like they’re in the driver’s seat. 100% of the problems they face are a result of their behaviors, even if the only option is to find a different job. They don’t spend time trying to pass the blame off on other developers, processes, or environment.

Rather than fidgeting around worrying about what other people think, unstoppable developers focus on what they do have control over: code.

12. Become a power-user of your development tools.

If you spend a good percentage of your time coding in a specific environment, you should know exactly how to control it.

It doesn’t matter what makes up your toolkit, and if you use Sublime, Text,, Emacs, Vim or Visual Studio.

That said, tools like Sublime and Atom are easy to pick up. Unstoppable programmers generally start out by mastering the easy tool and eventually graduating to the harder options.

13. Know how to use Vim (at least a little bit).

You need to be capable of at least muddling your way forward using this text editor. You might not be very good, and many programmers would never write code on their own machine using it, but they are at least capable.

14. Never accept freelance work in an unfamiliar technology.

A big part of freelancing is estimating how long things will take. And more than likely, there will be one or two things that will take a massive amount of time to figure out in a new programming language or framework.

Don’t put yourself in an awkward spot by projecting time for something you don’t already know. Only agree to freelance work with technologies that you know.

15. Don’t count the number of hours.

There are two types of work that you can do in a day:

  • Deep Work: Cognitively demanding tasks that require you to focus without distraction and apply skills that are hard to replicate.
  • Shallow Work: Logistical tasks that do not require intense focus or the application of hard-to-replicate skills.

Unstoppable programmers spend their time doing deep work, and they understand that the actual number of hours spent working don’t actually matter.

16. Absorb massive criticism with ease.

Developers who produce more code than others need to get used to getting their code torn apart. You need to develop the ability to react rationally and logically when that occurs.

There’s nothing wrong with updating your code based on feedback from other developers. In fact, getting frequent code reviews prior to code being accepted to a project is one of the best ways to level up as a developer, especially if the person giving the code review is a stickler.

17. Pair program with people with more experience.

There’s no faster way to learn to code.

18. Always code review your own work first.

This is a simple rule, but it falls a little outside the norm. There are so many developers who propose a change to an application but don’t take the time to look at their own code.

Before you issue a pull request on GitHub, review the code and pick it apart in the same way you would if it was someone else’s code. You can avoid a lot of negative feedback on your code by doing this one simple thing.

19. Recognize that the hard part of freelancing isn’t writing the code. It’s everything else.

The reason why many freelance developers have seemingly outrageously high billing rates isn’t because writing code is hard. It’s because everything else about managing freelance coding work is hard.

Sales, marketing, customer support, quality assurance, and product management will all take up a lot of time.

20. Identify and resolve bigger issues.

The best programmers think beyond the immediate issue at hand and know how to deal with problems in a way that leads to more long-term solutions. These big issues include:

  • Working on the weekends to stay on schedule
  • Constantly having bugs in your code and having to ship hotfixes
  • Production site going down multiple times
  • Initiatives starting, but before there is adequate time to finish, new higher priority initiatives emerging

If you learn how to manage these types of issues the right way, you’ll start becoming an unstoppable programmer.

21. Dive into large open source projects to bring your features to life.

Impossible is nothing if you know how to monkey patch a solution.

In order to implement this, developers need to gain a good understanding of the code of the framework related to that feature.

Most developers are afraid to even start. Unstoppable developers can’t stop themselves from diving right into the fray.

22. Skip a lot of meetings.

If you work at a big company, there’s no bigger waste of time than meetings to talk about future goals and work that’s currently being done. It’s not uncommon to spend more time talking about work that’s happening than actually doing it.

Your company pays you to write code. Not to talk about writing code. When meetings get out of hand, it’s ok to start skipping them. People will appreciate your time more if you start doing this.

23. Know when it’s time to give back.

At the start of your career, you have to focus on honing your craft. You spend a lot of time working with other developers who have more experience, and doing so helps you learn the tricks of the trade.

But there comes a time when you need to start giving back to junior developers, just like your mentors did with you.

24. Be capable of writing bad code.

Sometimes, it’s ok to become a Duct Tape Programmer. The real world is messy. As a developer who is young and idealistic, it can be tempting to live in absolutes and extremes. But given the realities of deadlines, expectations, and the benefits of certain features, you can’t always be perfect.

Over time, you need to figure out when it’s acceptable to take a shortcut and when it is absolutely needed. This is one of the most difficult skills to learn.

25. Let other people know that you’re working late without being a jerk.

If you’re the last one in the office, just send an email to someone with a quick update. People generally notice the timestamp and will know that you’re working hard.

26. Act as a leader, not a boss.

Unstoppable programmers are leaders. They are not bosses. There’s an important difference.

  • Bosses are people who have people work for them.
  • Leaders are the people who other people follow.

Unstoppable programmers are the leaders of their team. They may not have a title. But they’re the people who the entire dev team looks to for their judgment.

On development teams, there is one key difference between leaders and managers. Leaders live in the trenches and do the work (and often the most work) of the team. Managers might be able to tell you the correct answer in theory, but the leader has enough context to have an opinion that is highly respected.

27. Go play foosball.

In the long run, building relationships with other developers (and people in other roles) will be more valuable than shipping a feature in a tighter window.

28. Learn under pressure.

Most unstoppable programmers have been in a situation where a system has gone down or something broke, and they are responsible for getting it back up. Often, they won’t know exactly how to solve the problem. To be unstoppable, you should develop the ability to learn new things on the fly, like:

  • Performance tuning
  • Server configuration
  • Data migration from different systems

You need to know how to stay cool and navigate a new situation with ease. This is difficult to learn but immensely valuable.

All of these behaviors are important. But to be an unstoppable programmer you need to implement one behavior above all others.

29. “Move fast and break things.”

Don’t let perfect be the enemy of good. Mistakes are often the best learning opportunities. So don’t treat your mistakes as failures. Instead, treat them as learnable moments and know that fighting through them is critical to your growth as a programmer.

Programming, like many things in life, is often more about the work you put in that your actual know-how. So, if you’re a beginner programmer, just get coding, and try to start implementing these practices into your routine to better your craft.

Do you want to start becoming unstoppable?

It starts with overcoming the fear of making mistakes. Read this blog post about the biggest mistake that I ever made and find out how it made me a better programmer:

The Biggest Mistake I Ever Made As A Programmer

If you found this article helpful, I’d really appreciate it if you hit the recommend button below so that more people will see it on Medium.