Better, Faster, Stronger Software Developers Powered by Generative AI.

Generative AI tools like ChatGPT offer opportunities for software engineers to improve productivity. By automating repetitive coding tasks and offering suggestions, generative AI speeds implementation and reduces human error. Studies show that developers using generative AI tools can code up to 55% faster. Adopting these AI-based solutions can increase efficiency, improve code quality and speed time to market for development teams.

Well… maybe not stronger, but more efficient and productive.

Today, people are losing it all over the internet about ChatGPT and other less famous but equally impressive AI tools. Many claim that their jobs are at stake and AI will take over. Even programmers! But keep reading before you start preparing for the prophesized AI Armageddon because I am here to show you how you can come out of this even more vital.

Change is also an opportunity. Let’s examine the facts. AI-powered tools can help people do a better job, that’s for sure, and programmers are not the exception; Generative AI can make us code solutions better and faster by taking over the less significative but far more annoying work of typing code and finding errors while we focus on the problem and design a state-of-the-art solution.

After all, that’s precisely what we Software Engineers do, Design efficient and maintainable solutions based on well-known software development patterns and engineering processes. Coding is just a part of it; it is just implementing our design in whatever tech stack you or your current employer holds dear. So, leveraging our implementation skills by receiving suggestions from a highly efficient AI tool makes sense. It is a win-win situation from my perspective.

What is generative AI, and why should you care?

Generative AI is a general term used to identify any artificial Intelligence capable of generating a response to user inputs in the form of text, images, or media. Take ChatGPT as a perfect example, you input a question, and the AI generates a response. So far, so good, but how does that apply to Software Development?

If you are familiar with Software Development, you will know that the process of coding, even the most minor task, should pass through at least three stages (Hopefully):

  • Stage 1: Understanding the problem: Developers ask the questions, clarify any doubts, understand what role this solution plays in the whole picture, and somehow end up with a set of requirements in the form of User Stories, Use Cases, or simply a requirement description.
  • Stage 2: Design a solution. Even the most minor task requires a game plan.
  • Stage 3: Implement the solution in code.

“First, solve the problem. Then, write the code” – John Johnson.

And yes, there is also testing, some code integration, and publishing the solution to production. But let’s keep it simple for the sake of this example.

Of all the stages above, implementation (Stage 3) is statistically more prone to human error and frequently the slowest phase to complete. If we go back to the Generative AI definition above, it could solve our problem. Let’s apply that definition to a coding example to clarify.

Imagine that you are typing a solution based on a Kruskal algorithm. An algorithm discovers the shortest path between two points in a connected weighted graph. Very useful for navigation applications such as Waze or Maps, among many other uses. In the old days, you either:

Remember at least the basics of the algorithm and type it all over again. 

Google it to find the most usable form of it, and then tweak it to make it work with your code. 

Either way, you could use more time and resources. As a Software Developer/Engineer, the important thing here is that you can determine, after a detailed analysis, that a Kruskal-like algorithm is what you need to solve the problem. If you decide to type it from scratch every time you need it, you are wasting precious time and exposing the solution to errors you will eventually fix. If you Google it, you not only waste time and concentration (more precious resources for developing Software) but might also end up risking your code.

But what if a Generative AI running as an add-on to your IDE can automatically detect your intentions by reading the code you input and then jump in, offering you the chunk of code you need “in flight” at the right moment? No waste of time. Could it also point out and provide solutions to your code’s possible errors and security vulnerabilities?

That is pure AI-powered “pair programming” that speeds up your development time and accuracy of code. 

Quantitative research run by GitHub showed that developers that used GitHub Copilot (their Generative AI tool) coded up to 55% faster than those without it.

What does this mean for people managing development teams?

In a word, this means “efficiency.” If you give any value to that word, you most likely measure at least 4 KPIs from your development team:

  • Velocity 
  • Code Coverage
  • Sprint Burndown
  • Release Burndown

These KPIs could greatly benefit from the speed and quality of the code that a generative AI-powered team can produce. Being able to do more with fewer or equal resources (AKA: Efficiency) is undoubtedly the mother of all objectives. 

Companies from every industry are now more than ever looking to squeeze the last possible output from every dollar invested in Software development and maintenance. Imagine the positive impact you can have on your Team’s KPIs by making them able to code 55% faster with higher levels of quality. 

Boosted speed to market and productivity is always good news. Being able to produce more work with your existing budget is what success stories in the IT industry are made of.

How has your team started using generative AI for coding?

Every company is different. Factors like company culture, industry, attrition, and resistance to change may vary and could make implementing such solutions easier or harder. 

I would only dare to tell you how to do it in your organization with a proper consultancy process. But I can tell you how we do it at Sapiensdev; it might show you how to start. As a Nearshore IT Team Augmentation company, we create teams that code solutions for many clients. Our culture is much more open to change, challenges and our attrition is very low (6% by Q1 2023), so we have a clear path to start:

  • Step 1: First, we choose a provider of generative AI that can work with our most commonly used IDEs. More information on that is at the end of this blog.
  • Step 2: We constantly and consistently measure our team’s performance. This is the most crucial step because you will have to measure the results against something to prove the effectiveness of the add-on. Subjective opinions are not suitable for measuring anything, so if you are not measuring the performance of your teams already, you should start now. Otherwise, you will be relying on a subjective measurement.
  • Step 3: We found a client interested in the subject and willing to do a test drive with his team. In your case, this could be a team within your organization that is more open to change or a developer interested in the subject.
  • Step 4: We choose a senior developer within that team to champion the project. This person is responsible for learning how to install, configure and use the add-on. This developer needs to be invested in the project to the degree that it will produce documentation and will support and teach all teammates how to use the add-on. Therefore, these people should not be appointed; they should be volunteers instead.
  • Step 5: Give the champion enough time to know its way through the add-on and how it is used. Find support for this person, training, and resources. We even involved Marketing and Engagement, so they could produce videos on how to install, configure and use the add-on, plus an internal campaign to build up expectations among the team.
  • Step 6: Allow space for knowledge transfer and set a date for kickoff. Let the champion share their knowledge with the team. Have at hand every possible resource for learning how to get up to speed fast and promote the use of the add-on. It should take one or two weeks before kickoff.
  • Step 7: Kick off the project and keep measuring performance. Don’t expect immediate results. It should take at least three months for the team to get used to it and for the improvement to be evident.

What add-on to use?

It depends on your preferred stack, budget, and needs. We chose GitHub Copilot for our test drive, but your requirements could take you through a different path. I would suggest going through the following list and finding which one you feel is a better fit for your organization:

  • Codacy
  • GitHub Copilot
  • Mutable AI
  • Minify (For documentation only)
  • Metabob
  • aiXcoder
  • Warp (For Terminal window only)

Finally, feel free to ask questions and support. I will be glad to help in any way possible. Just fill up a contact form requesting the author of this blog. 

Share this story

by Marilena Heinen

September 21, 2023

Boosting Business Agility: The Transformative Power of Nearshore Software Development