On average, developers spend a mean of 13.5 hours per week dealing with technical debt and code smell. That’s almost a third of your developers’ salary paying for the sins of past decisions. For a 15 person team at $100k per person, that’s $500k of poor productivity. If you have a team of a 1,000 people – well, you get the idea.
If we look at it from a different perspective, that’s the equivalent of a 33% interest rate on your software development cost through tech debt. Expand this into multiple projects, features, and teams, and the costs can easily hit the million-dollar mark.
But what exactly is tech debt?
Tech debt is a term used to describe the extra development work that is needed to complete a project because of poor code quality. Code smells are potential problems in code that can indicate underlying issues with the design or implementation of the code. Code smells are often symptoms of tech debt.
According to a report by Stripe, the global estimate of developer inefficiency caused by technical debt and low-quality code is approximately $300 billion. There’s a high chance that you are also contributing to this figure.
While it’s no argument that tech debt and code smells are bad – how exactly do we get and prevent it in the first place?
The problem with technical debt for high-performance teams
A Swedish study found that long-term exposure to unresolved technical debt causes anxiety, sadness, frustration, and helplessness in software engineering teams. This impacts the long-term quality of new code, resulting in a cascading effect for the rest of the business.
Here is how tech debt can impact your team’s productivity and software ROIs over time.
More debt, more drag
You can’t have a high-performance team if there is excessive tech debt.
McKinsey reports that CIOs estimate the spending on paying tech debt has increased significantly but only allocate less than 20% of their budgets to pay it down. Some companies have the equivalent of up to 40% tech debt on their accounts but only pay 10% interest on projects.
Like all debts, technical debt compounds. Issues that come with tech debt include:
- Reduced forward motion. The estimated cost of tech debt drags that resulted in failed software projects in 2020 sat at $260 billion in the US. Technical debt is the amount of time and effort that will need to be put into a project to fix errors, poor design, or other technical problems. This can reduce the forward motion of code because it takes time and effort away from adding new features or improving the codebase.
- Volatile performance. Poor quality software and legacy systems are costing businesses in the US a cumulative $520 billion. Volatile performance of code often comes in through excessive usage of dependencies and tight coupling. This can make code difficult to change and maintain and can lead to unexpected behavior when code is modified.
- Testing strains. Operational software failure costs is a $1.56 trillion pipeline in 2020. Technical debt increases the complexity of the codebase. This makes it more difficult to write tests that cover all of the code, and difficult to maintain existing tests.
Nothing is perfect, code is always a work in progress
Tech debt is a manifestation of yesterday’s decisions. It is the nature of the work.
However, not all decisions are equal in cost. Using theoretical tools like the defects metric can help reduce existing technical debt over time.
What is the defects metric?
It is a measure of how many errors or defects there are in a software system per unit of output (this could be lines of code, or story points). This metric can help reduce technical debt by bubbling up issues to the surface before they become major problems. By monitoring the defects metric, teams can identify areas of the codebase that are more prone to errors and take steps to improve the quality of the code.
Agile needs communication
Agile development is an established standard for shipping software and emphasizes the delivery of working software early and often.
This approach can lead to technical debt. In agile, teams ship on a short schedule, often in 2-week sprint schedules. Technical debt can arise from taking shortcuts during development, such as not writing enough tests or not refactoring code due to time pressures and constraints. Over time, these shortcuts can lead to the tight coupling of technical debt that is difficult and expensive to fix.
Lack of timely code moderation, miscommunication, and lack of context for issues raised often occurs in agile due to poor communication, especially for distributed and remote teams. According to Project Management Institute (PMI), one-third of projects fail due to this reason.
In-code communication tools like Bito can easily solve this by reducing communication friction.
Bake in the features of quality code
How do you increase the ROI and engineering velocity of your teams and software development? How do you reduce technical debt? Here are three ways to achieve it.
1. Communication is king and code is queen
With the rise of distributed teams, it’s become more important than ever for team members to be able to communicate effectively with one another.
Technical debt is a real problem for many organizations, and it can be exacerbated by poor communication. When team members are not able to communicate effectively, it can lead to a build-up of technical debt. This can be costly and time-consuming to fix down the line, so it’s important to avoid it if possible.
While Slack is great, it often lacks a direct contextual link to the code itself. Bito [link to the landing page here] can help organize your discussions and queries, and get feedback from the right team member with minimal effort.
2. Reduce the complexity
Complexity creep is the gradual increase in the complexity of a system over time. This can happen for a number of reasons, such as adding new features or functionality, making changes to existing features, or simply not removing old code that is no longer used. Complexity creep can lead to technical debt.There are a few ways to avoid or mitigate complexity creep:
- Keep things simple from the start. When adding new features or making changes, consider how this will affect the system’s overall complexity.
- Remove old code that is no longer used. This will help to keep the codebase clean and manageable.
- Use automated tools to help manage complexity. There are a number of tools available that can help to identify areas of complexity in codebases, and some of these can even help to automatically refactor code to reduce complexity. For example, Visual Studio has the ability to generate code metrics values that calculate the maintainability of your repo, depth of inheritance, detect class coupling, and structural complexity.
- Encourage code reviews and technical debt discussions. By making complexity and technical debt visible, it becomes easier to address these issues.
3. DevTools can help with standardization
There are many benefits to using automated standardizations through IDE plugins and dev tools, the most notable being time savings. By using a plugin, add-on or dev tool, developers can automate the often tedious and time-consuming task of code formatting and linting. This not only saves the developer time but also ensures that the code meets certain standards, thus improving the quality of the code.
Here is a quick list of plugins that can help improve the quality of your teams’ code:
- Prettier: formats your code for you. It can format your code automatically or you can format your code manually with a keyboard shortcut.
- ESLint: allows you to lint your code for potential errors. It can be configured to lint for specific rulesets and can be used to automatically fix some errors.
- TSLint: a TypeScript linter that helps you find and fix problems in your TypeScript code.
- GitHub Copilot: an AI-driven code suggestion tool that helps you code faster and more accurately based on the project’s repositories.
- Tabnine: a code prediction tool that suggests your next line of code based on context and syntax.
It is important to note that AI-driven plugins like GitHub Copilot, Microsoft’s IntelliCode, and Tabnine are not perfect. While these plugins are great, they’re not intelligent enough to moderate complexity and understand the architectural context that requires refactoring. In order to maintain a high standard of code quality, human moderation is still required.
Nip technical debt in the bud with Bito
Technical debt and technical smells are inevitable. It is part and parcel of writing code itself. However, it can be reduced and paid off before it becomes problematic.
Bito can help your teams nip technical debt in the bud. With the help of Codenotes, you can directly make comments and start discussions with team members about specific lines of code with minimal effort. Even if a tool like Bito isn’t a fit, find a way to note technical debt, and communicate about it. Find a way to ask questions within the code to help make things clear, and help explain it for later developers coming by.
So get started today with Bito and check out how we can help you help your teams reduce technical debt.