Software development is a unique profession. Unlike many industries, productivity doesn’t automatically increase with more capital, new processes, or more employees. Productivity depends on each developer’s personal habits and is heavily influenced by the way the company is managed.
Let’s take a look at what makes developers productive, how to cultivate good habits, and how to avoid wasting time to increase your team’s productivity.
Software development is a unique profession—you can’t improve productivity by throwing money or people at the problem. Click To TweetWhat Makes Developers Productive?
We have all heard about the “10X developer” that’s ten times as productive as the average developer. With an industry dominated by young developers with less than five years of experience, most people that have been around long enough will concede that 10X developers are a very real phenomenon.
That said, 10X developers aren’t what you might think. They aren’t geniuses that can type 10,000 words per minute of error-free code. Rather, they have a deep understanding of computer science fundamentals, can quickly reason about problems, and are extremely productive with their time.
But, how do you measure developer productivity?
We define production as delivered value in the form of working software that does something useful for users or owners. And we measure productivity as the value delivered over time—or the pace of value delivery. The 10X developer is a developer that delivers value ten times faster than an average developer.
It’s important to note that delivering ten times the value doesn’t mean typing ten times as much code or working ten times as many hours. In fact, 10X developers are often those that enter the office at 8:00am and leave the office by 4:00pm.
Productivity is influenced by many factors, such as:
- General intelligence
- Personal habits
- Team dynamics
- Software tooling
- Social environment
- Work environment
- Work schedules
Highly productive 10X developers are also very efficient.
Everyone has a certain amount of cognitive currency that they can spend each day, and productive developers are the most frugal spenders. Instead of implementing a poorly defined feature at record speed, they will push back to ensure that it’s actually delivering value before spending any time.
Productive developers also minimize office distractions and avoid taking poorly structured breaks to check Facebook, Reddit, or Hacker News. They realize that there’s only a certain number of productive hours in a day, they only intend to stay at work for eight hours, and they maximize what they can get done.
Cultivating the Right Habits
Most developer productivity comes from good personal habits. Some of these habits can be influenced by managers, such as maintaining a schedule, while others rely on the person, such as getting a good amount of sleep and eating healthy.
Let’s take a look at some habits that you can cultivate to improve productivity.
Maintain a Schedule
Professional software development as a team sport that involves pair partners, product managers, designers, clients, and countless others that must collaborate. Developers that follow a consistent schedule are far more productive in this environment.
Encourage developers to arrive on-time each day. If they’re late to work, they could not only reduce their own productivity, but the productivity of those relying on them. Tardiness also reduces their collaboration window with clients and managers.
It’s equally important to let developers leave on time each day. Without a hard deadline, it’s easy to allow distractions to creep in early that require developers to stay late. And constantly staying late can lead to arriving late in the morning.
Defend Their Best Hours
Many people are familiar with the concept of flow from experience where they feel the highest level of alertness. It’s important to ensure that your developers are working on their most difficult problems during these times.
It’s equally important to understand the preconditions for reaching a state of flow to help your developers achieve the mental state on a regular basis.
The basic requirements for flow include:
- Know what to do
- Know how to do it
- Know how well you’re doing
- Know where to go
- High perceived challenges
- High perceived skills
- Freedom from distraction
Managers should always ensure that these requirements are met for their team in order to maximize the time spent in flow.
Take Disciplined Breaks
Breaks are extremely important for maintaining a high throughput. By intelligently structuring breaks, you can boost your development team’s productivity and avoid burnout.
There are a couple different techniques that we encourage for structured breaks:
- Pomodoro – The Pomodoro technique involves timing breaks according to specific patterns or rhythms. The default Pomodoro settings are a 25 minute work period with three to five minute breaks in between. Then, there’s a 15 to 30 minute break every four work periods.
- Water – The eight glasses of water method involves standing up to get a drink of water once per hour. This also solves the problem of being chronically under hydrated, which can impact productivity on a more general level.
Managers should encourage developers to take regular breaks and/or consider coordinating breaks between pair partners.
Avoiding Wasted Efforts
The 80/20 rule states that 20 percent of the effort creates 80 percent of the value. Often times, the 20 percent comes when a developer is working in a state of flow. It’s incredibly important to ensure that developers aren’t wasting their time or skillsets during these periods to gain the most value.
Question Everything
Managers should always ensure that developers aren’t wasting effort on tasks that don’t matter or have a lower value than other tasks. Experienced developers will quickly become frustrated if they are doing great work at high speed, but the work is ultimately deemed unnecessary or of no value.
It’s important to question everything:
- Why do we need this feature?
- Do we really need all of this?
- Is this really the most important thing?
- Is this really necessary for launch?
- What if we did a simpler version?
Many 10X developers already ask these questions before working on anything, but junior developers may rely on their manager to filter their tasks.
Speed Up Troubleshooting
Developers tend to fall into a couple different camps when troubleshooting problems.
Some developers will default to Google or Stackoverflow and simply copy-and-paste the answer without really understanding how it works. Others will avoid looking up the answer and spend several hours of trial-and-error to arrive at a solution.
Many 10X developers are proficient at researching answers with Google, but they don’t simply copy-and-paste code. Instead, they are proficient at reading source code to understand how a problem can be solved, and then they write their own solution.
Pair programming between junior and senior developers can also help speed up troubleshooting and help new developers learn best practices when it comes to troubleshooting on their own.
Training Your Developers
We have discussed several ways to improve the productivity of your development team, but many of these improvements require personal change on the part of your developers. For example, you can’t control how a developer spends their off-hours or look over their shoulder every minute of the day.
The 10X Dev Academy is designed to teach developers these non-technical skills to improve their productivity. In many ways, knowing how to code well and learn quickly doesn’t translate to becoming a 10X developer—this course teaches the other skill sets needed to increase your team’s productivity.
Sign up today to provide the course for your team of three to five developers and help them 10X their skillsets.