Transformative is an overused word these days, but AI-assisted coding is genuinely a transformative trend, a step toward a future where software writes software.

Only about one-half of one percent of the world can code, and there is more code to be written than there are developers to do it. Demand is high for tools that take the struggle out of coding – or remove the need to code altogether - so that the world's limited developers can focus on creative tasks.

Now a lot more developers are going to get exposed to AI-assisted coding. In June, GitHub, Microsoft, and OpenAI announced a new AI for code tool Copilot, which they bill as a "virtual pair programmer." It provides AI-powered autocompletion in Microsoft's source-code editor, Visual Studio Code.

Copilot is only the latest of a rash of AI-enabled products that save developers time.

TabNine, Sourcery.ai, and others have produced AI-powered auto-completion tools. Diffblue Cover, created by computer scientists at Oxford University, writes software tests using reinforcement learning.

And Akkio, an end-to-end no-code AI platform, builds and trains, and deploys machine-learning models automatically. A user needs to drag a data file into the web interface and click a few options. Any business user familiar with their data can use it without help from a developer or engineer.

These tools are putting the power of artificial intelligence within reach of even small companies for whom expensive data scientists are in short supply.

LinkedIn data has revealed 2020 to be the year of highest demand for software developers.

The shortage doesn't just affect the states; it's global. In the report, 58% of hiring managers said hiring software developers was a challenge, with some cities even facing shortages of only semi-qualified applicants.

This is exacerbated by the fact that 39% of tech hiring personnel expect to have increasingly more positions to fill on every end of the complexity spectrum. The cities with the highest demand for software developers in 2020 were: 1. San Francisco, 2. Seattle, and 3. New York.

There is a silver lining. In the next five years, 149 million+ new tech-orientated jobs are coming up. While 58% of these STEM jobs are in computing, only about a third of them can't be hired by non-stem applicants if the company is willing to equip the recruits with assisting software and educate them on the job. However, this strategy takes precious time away from the few seasoned veteran developers companies so desperately need.

Qualified teachers aren't just rare in companies but the entire education sector. This may partially be due to the low salaries offered to them. Personnel skilled enough to teach these subjects consist of veterans that can easily score retainers ranging in the $200000s.

Talent drought

Given the talent drought, companies need to make the most with what they got. Desperate, some organizations have resorted to extensive talent poaching, recruiting junior developers or even unskilled labor and building them from the ground up.

Automation software can help, but developers still spend most of their time building, testing, and deploying software - most of which can't be automated or only partially. Either way, this requires skilled people or putting a lot of person-hours into facing steep learning curves.

That being said, there has been a lot of improvement in software development, and a lot of the work can increasingly more be automated or there are new least assisting tools that make them a lot easier.

Twenty years ago, a SUN developer created an automated system named Jenkins (originally named Hudson) to simplify software integration and remove many software delivery barriers.

Facebook's Getafix learns from an engineer's past code and, much like autocorrect, recommends fixes for bugs.

Writing software requires a great deal of skill and patience which often involves painstaking drudgery like reading manuals, writing documentation, and filling out forms.

Developers surveyed last year used an average of 3.7 different tools developing software and spent a third of their time testing it. By running unit tests as the code is being written, developers can fix problems on the go and ship finished software much faster.

Programmers must manually write, edit, and rerun the tests every time they make a change. This forces them to interrupt their creative work and switch gears between the "left brain" of coding and the "right-brain" of testing and debugging.

It also adds time pressure because writing tests often comes after code has been written, but before a deadline is looming. Worse yet, the bugs we find when testing a piece of code often reveal deeper bugs elsewhere in the system.

Writing and debugging unit tests is thus akin to using a microscope for hunting for microbes in a dirty petri dish: you're bound to find some, but it takes so long that you'll miss plenty of problems.

Fortunately, there are efforts underway to automate away much of this drudgery. Modern software development environments allow developers to click on what they want rather than type it and deploy software with a single command.

Source code repositories, bug trackers, continuous integration servers, testing frameworks, and deployment systems are all being automated.

Software testing is a $12 billion industry, but very little of that testing is automated and left in the hands of millions of contract and freelance developers.

Even an unintelligent algorithm that randomly generates tests can test software exponentially faster than a human can. Deployed are carefully calibrated models which excel automatically generating tests humans can easily understand.

This makes it easy to refactor code — to improve the structure of software without breaking existing features.

This also represents a remarkable opportunity to save labor and improve the quality and productivity of each remaining engineer at the same time. After all, even a little bit of help snowballs over millions of lines of code.

Autocompletion

Copilot can autocomplete any code – including unit tests. Based on OpenAI's massive language model, GPT-3 is trained on a blend of text and public repository source code from GitHub. Copilot, a model of GPT-3, does the best it can but leaves it up to the developer to pick the best autocompletion that matches their intent, fix any problems or mistakes, and complete the code.

It's designed to be interactive.

Diffblue Cover, meanwhile, works 100% autonomously and can write a complete suite of tests that always compile and run (a direct consequence of how it searches the space of possible test programs). Copilot is computationally expensive to run and so must run as a cloud service. Code must be uploaded to Copilot to run the analysis, which many organizations don't like to do. Diffblue Cover, on the other hand, is packaged as software that any developer can run on their laptop.

Adopting this assisting software allows for testing that wouldn't have happened before because it's too labor-intensive. Companies have miles of legacy code that never had the chance to be properly tested. As code evolves, backward compatibility becomes an increasingly bigger issue. Companies can't afford to re-build billion-dollar software in a different coding langue or using other modules.

It's not a simple matter of translating, and without good tests, it is easy to introduce new bugs when iterating and upgrading software. Those bugs, in turn, require massive, time-consuming effort to find and fix later on, limiting how often updated code can be released. Organizations that push code more often have a far lower failure rate and are far faster at adapting to trends or recovering from software failure.

The less time developers spend solving mind-numbing debugging problems, the more they can focus on facing problems and innovate products. It gives them the necessary room to gain perspective, brainstorm, and deal with unsuspected challenges.

Conclusion

A considerable portion of code is already developed, delivered, and maintained using a wide array of assisting software. Before long, code will almost write itself, and developers turn from players to referees. In the meantime, executives are left to compromise.