Note: this post is part of a series about the foundations for Code Inspector, you can find the previous article here.

This is the last post in the series about Code Inspector. The first post focused on why humans are fallible by design and sub-optimal at executing small and repetitive tasks. The second post focused on the exponential progress of automation: tasks performed by machines are getting more complex every day and soon, most of our jobs are going to be automated.

In the next paragraphs, I explain the main drivers for starting Code Inspector.

The software maintenance problem

There is a real struggle to develop software, especially because it is really hard to find and understand the design and implementation choices made by the initial authors. Software is often poorly documented, which makes it very complicated to troubleshoot an issue or maintain an old codebase.

The average tenure for software developers is between 2 to 3 years. But the software is operated and maintained for decades. As developers leave a company their knowledge of a project leaves the company. In some industries, the developers that maintains a software were not even born when the initial system was designed.. (Think twice about this!)

Some developers have no idea how the system they operate actually works. It can take days or weeks to troubleshoot an issue because the system is way too complex and the documentation, non-existent. And it is not common that issues go unnoticed for months because developers do not understand the impact of their scope.

There is an obvious need for a product that helps developers understand a code base and establish a plan to improve it. This product needs to be user-friendly, non-intimidating and to give clear actionable paths to improve their codebase.

The software modernization problem

Software is like our physical infrastructure: it’s aging and improving legacy software is a major undertaking. Reports estimates that bad code and technical debt takes up to 30% of developer time (see Stripe study, other sources estimate it’s more like 20%). The same study from Stripe reports that bad code costs companies $85B annually. Even if you cut the estimate in half, it’s still a number that makes you wonder if we should continue to write code as we do today.

There are two solutions to address the modernization problem:

  1. Hire more engineers, which increases costs exponentially and increases productivity linearly (at best).
  2. Automate software development.

Until very recently, only the first solution was possible. The recent progress on software analysis and machine learning allows to automate software development. This is a natural evolution: after all, today, Google translate writes better English than I do and a Tesla drives better than I do (on a highway for now). Why couldn’t a computer program better than I do?

At first, only a few aspects will be automated. As the technology develops, the scope of automation will grow and the human factor in software development will shrink.

The training problem

The change from manual to automated software development is not going to happen overnight. Demand for software engineers will still be strong for the next ten to twenty years and the two problems mentioned before (maintenance + modernization) will require mode engineers over time.

The department of labor already predicts that demand for software engineers will grow by 20% in the next ten years. The traditional education system cannot absorb this increase. The job market for software engineers will be heavy on the demand (a lot of job openings) and limited on the offer (not enough engineers).

This means that many engineers will be under-trained and there will be a need for additional training. A code automation platform can help engineers to become better by providing guidance. Such a platform will not only guide them in their work but also help them become better software engineers by explaining why some modifications are recommended.

The mission

The mission of Code Inspector is clear: help developers produce better software.

There are three main aspects to achieve this:

  1. Identification: detect issues in a codebase, surface them in a user-friendly interface and help developers prioritize software maintenance.
  2. Automation: automate resolution of bugs and maintenance issues. Let the machine fix issues for you: it will do it better than the majority of humans.
  3. Training: incentivize developers to maintain a codebase, fix issues and guide them through code changes (e.g. explain why they are done).

The financial impact is clear as well: with an average salary of $108,000 per year, a product that makes engineers 1% more productive would already unlock a value of $1,000 per engineer per year. And if such a product could even cut the time spent in technical debt by 50%, it will then save $10,000 per developer per year.

This is a huge, underestimated problem and this is why I left everything to focus on this project. The coming year is going to be very exciting and I can’t wait for it to start.