Unless you’ve been living under a rock over the past few months, you know that OpenAI has seriously shaken the world of technology. ChatGPT’s impressive algorithm, now in beta for all to use, can generate insanely impressive textual results given simple prompts. And the results are imaginative and comprehensive, with the ability to write “original” articles, screenplays, poems, song lyrics, and more.
But perhaps its most disruptive facet is the potential to generate surprisingly complex and accurate code.
Having seen ChatGPT in action, nearly all experts in software development agree that generative AI is the future of programming. However, we’re still unsure what the relationship between the programmer and AI assistant will look like.
ChatGPT is powerful, like auto-complete on steroids, but it can’t solve every IT problem. Most likely, it won’t replace the need for talented software developers anytime soon. However, AI assistants will undoubtedly accelerate the pace of modern software development and experimentation. This will permanently impact future coding workflows, influencing a new class of talent and best practices that will likely emerge and involve working alongside an algorithm.
So, how exactly will code generation AI alter software development, and what are the repercussions? This is a question I posed recently on Twitter and LinkedIn that got some interesting responses. Below, we’ll summarize what code generation AI will enable for individual programmers and businesses at large. We’ll see what it solves and what it doesn’t solve. We’ll also consider what new skills will be required to work most effectively in this new AI-supported age of coding.
AI Code Generation: What Does It Solve?
Instant generation of functions and scripts. At the micro-level, code generation is very good at writing functions faster. “AI is a better autocompletion,” wrote Jens Neuse, founder at WunderGraph. “I’ve quickly learned how to write comments and code to help AI suggest what I need.”
As such, code generation will accelerate the pace of coding significantly. For example, I asked ChatGPT to write a JavaScript function that takes a user’s birthday and calculates their age, and here is the result.
function calculateAge(birthday) {
const currentDate = new Date();
const currentYear = currentDate.getFullYear();
const birthYear = new Date(birthday).getFullYear();
const age = currentYear - birthYear;
return age;
}
Create glue code between components. Integrating with standard SaaS can be a pain point for some developers since it involves perusing API documentation and testing calls. But, advanced auto-completion could reduce the time it takes to generate code that calls external sources, such as APIs and common libraries, in various languages. This could significantly reduce the time and effort of writing boilerplate glue code that integrates data from third-party applications.
For example, here is a curl snippet generated from the OpenAI playground that calls the Salesforce API and requests a list of current clients:
curl --request GET \
--url https://yourInstance.salesforce.com/services/data/v20.0/query \
--header 'Authorization: Bearer yourAccessToken' \
--header 'Content-Type: application/json' \
--data '{
"query": "SELECT Name, Email, Phone FROM Account"
}'
Enable quicker experimentation. Engineers often want to test a new feature to see if it works, but manually programming a new application for every half-fledged idea can eat into resources. However, programmers could quickly generate mockups with a code generation toolset like ChatGPT or Copilot. This makes it much easier to swiftly test theoretical ideas.
Overall increased agility. Given the increased speed, code generation can increase overall business agility. Since so much of modern business is tied to software design, accelerated code creation results in faster pivots, enabling the company to respond to new features and requests.
Reduce technical debt. It’s no surprise that many enterprises face expanding technical debt. This could leave a business struggling to embrace new technologies to keep pace with change. AI-driven code generation could assist in code conversion, helping remove dependencies on legacy programming languages.
For example, OpenAI easily converted the first age computation function into the Go programming language:
package main
import (
"fmt"
"time"
)
func calculateAge(birthday time.Time) int {
currentDate := time.Now()
currentYear := currentDate.Year()
birthYear := birthday.Year()
age := currentYear - birthYear
return age
}
func main() {
birthday := time.Date(1998, 11, 25, 0, 0, 0, 0, time.UTC)
age := calculateAge(birthday)
fmt.Println(age)
}
What Does It Not Solve (Yet)?
Deployment pipeline friction. Just because you can generate code snippets doesn’t mean you have a fully working application deployed for public use. There are still countless steps between the code and the user’s fingertips. And although continuous integration and delivery (CI/CD) is becoming more automated, it still involves much manual intervention.
Which companies are the most important vendors in AI and Hyperautomation? Click here to see the Acceleration Economy Top 10 AI/Hyperautomation Short List, as selected by our expert team of practitioner-analysts
Piecing together the larger architecture. At the time of writing, code generation utilities don’t see the bigger picture well. At the macro level, there are plenty of architectural decisions to consider, such as code structures, development frameworks, and overall design patterns. Engineers must choose which cloud environment to utilize and how to integrate the right tools to help their applications scale correctly.
Keeping pace with integration changes. Furthermore, AI-driven code generation is not necessarily up-to-date with SaaS. Maintaining API integrations is tricky due to the implicit interface created between the consumer and provider. Simple changes on the provider’s end, such as endpoint names, authentication, or response times, can cause breakages if the client consumer isn’t consistently updated with each minor version change.
Software supply chain vulnerabilities. Just because an AI bot creates your code doesn’t mean that code is secure. Organizations will still require additional cybersecurity analysis and a view of the entire software platform to audit for potential vulnerabilities. Efficient security auditing will require a different type of automation that specializes in scanning software against a continually updated database of exploits.
What New Skills Will It Require?
Knowing what questions to ask. Working with an AI assistant is similar to working with a search engine — you need to know what questions to ask. And just as it took a while for the general public to learn how to perform keyword queries on Google, programmers will find what prompts deliver the best results and fine-tune their queries over time. Thus, knowing how to construct elaborate, natural language prompts for complex functions will become a skill in its own right.
Proper organization skills. Once you realize the right prompt, you’ll probably want to reuse it and share it with others in your team. Thus, keeping a library of helpful prompts to feed the algorithm will be important to both avoiding duplication and enabling consistent coding practices across an organization.
Debugging AI errors. Naturally, some human intervention will be required in the future of programming. But instead of focusing on writing base-level functions, engineers will likely spend more time on error diagnosis and configuration. In this new paradigm, errors could result from AI interpreting the prompt slightly differently than intended. Or, bugs may arise if mistakes are present within the source code that the ML model is based upon.
Ingenuity to realize truly unique end-business outcomes. In a capitalistic society, if all boats rise, all expectations rise as well. Now that the power of advanced software creation is more democratized, it will increase competition. Standing out in this new economy will thus require genuinely innovative ideas that provide tangible outcomes to the business. It also emphasizes other needs, like making great user experiences, using creative marketing tactics, and retaining key professional relationships.
Tomorrow’s AI-Based Abstractions
Undoubtedly, today’s code generation AI is becoming increasingly influential. However, it’s not my belief that this will replace jobs anytime soon. Instead, code generation AI is more likely to augment the day-to-day developer workflow. You still need knowledge of basic programming skills to diagnose errors. You also require architectural insights to piece components together, not to mention deploy applications in a cost-effective and sustainable manner. Lastly, a security mindset is still integral to spot open-source vulnerabilities and ensure data regulation compliance.
Instead, AI opens new opportunities for engineers to catch up on their backlogs and deliver more features rapidly. It could also open new opportunities for AI specialists to develop experience working alongside and training code generation algorithms and understanding the nuances between them.
All this being said, the above limitations are not set in stone (hence the “yet”!). We are still in the very early stages of generative AI. And the roadblocks mentioned above could very well become new frontiers for tomorrow’s AI-based abstractions.
Looking for real-world insights into artificial intelligence and hyperautomation? Subscribe to the AI and Hyperautomation channel:
