How Gen AI Can Transform Software Engineering
Iris Software Perspective Paper
By Mohit Mehrotra and Shivdas Nair, leading AI-assisted software engineering at Iris Software
With the release of ChatGPT in 2022, Generative AI became the talk of boardrooms. Generative AI has enormous potential for business use cases, and its application to software engineering is equally promising.
Early on, ChatGPT demonstrated interesting capabilities around code generation, analysis to identify potential defects, documentation and unit test scenarios, scripts generation, etc. GitHub CoPilot trained large language models (LLMs) on source code, and brought these capabilities closer to developers through Integrated Development Environment (IDE) extensions, making the overall process simpler and realizing true productivity gains.
Over the past 12-18 months, hundreds of LLMs and dozens of AI-based coding assistants have been made available by various providers.
In our experience, development activities, including automated test and deployment scripts, account for only 30-50% of the time and effort spent across the software engineering lifecycle. Within that, only a fraction of the time and effort is spent in actual coding. Hence, to realize the true promise of Generative AI in software engineering, we need to look across the entire lifecycle.
Our early experience demonstrates that Generative AI has the potential to help deliver higher productivity and quality and reduce cycle times by cutting down churn across the entire software engineering lifecycle. However, there is a need for a structured and thought through approach to realize benefits across different projects and larger teams.
A typical software engineering lifecycle involves a number of different personas (Product Owner, BA, Architect, QA/ Tech Leads, Developer, Quality/ DevSecOps/ Platform Engineers), each using their own tools and producing a distinct set of artifacts.
They derive and develop their artifacts based on those produced earlier in the lifecycle. Group or enterprise standards and processes also impact artifact development.
Today’s enterprise software engineering lifecycle faces several challenges:
• Multiple personas may lead to high churn: Manual and bespoke flow of artifacts between the various personas involved creates significant gaps in understanding, impacting overall completeness, quality and consistency of work products.
• A fix in time saves nine: Incompleteness and ambiguities in early lifecycle artifacts, such as requirements, architecture etc., require significantly more time and effort to address, if discovered only later in the lifecycle.
• Subjective outcomes: Very often, completeness and quality of artifacts also depends on who is involved, leading to inconsistencies.
• Repetitive low-value activities consume many cycles: Team members waste valuable time on repetitive activities like writing boilerplate requirements and code, generating obvious test cases, and validating API contracts, etc., resulting in loss of productivity and morale.
• Lack of formalization of templates: best practices, steps of doneness, checklists, solution patterns, etc., increase onboarding time for new members, impacting productivity, quality and consistency.
In our early experience, we see that applying Generative AI to the overall lifecycle can lead to more complete and consistent artifacts. This results in higher quality and productivity, reducing churn and cycle time. Complementary approaches to automate repetitive activities through smart templating, leveraging Generative AI and traditional artifact generation and completion techniques can help save time, let the team focus on higher-value activities and improve overall satisfaction. However, there are key considerations in order to do this at scale across many teams and team members.
LLMs are at the core of applying Generative AI to software engineering. The typical input to an LLM is a prompt. It would be counterproductive if every team member has to be good at prompt engineering to be able to effectively utilize Generative AI in their activities. Also, there is significant variation across teams in terms of tools/processes they use. This requires careful engineering of prompts to produce the desired outcome. Hence, the following considerations will help in overall adoption and in deriving value from applying Generative AI to software engineering at scale:
• Standardizing prompts: Standardization of prompt templates to review, rate, and refine artifacts, and derive dependent artifacts will result in higher productivity and consistency.
• Automating LLM integration and more: Automation of all or some of the steps of doneness for each type of artifact, utilizing Generative AI and other traditional automation approaches will improve productivity and agility.
• Offering in capabilities context: Offering the above in the context of the tools and platforms where various personas carry out their software engineering lifecycle activities (e. g. IDE, Jira, Confluence, etc.) will lead to faster and wider adoption.
• Configurable and extensible: Every application and software engineering team has their own nuances of process, tools and technologies. Hence, all the above need to be configurable and extensible by the teams so that they are well-aligned with their engineering context.
As an art-of-the-possible exercise, we developed Extensions (for VS Code IDE and Chrome Browser at this time) incorporating the above considerations to apply Generative AI to various stages in the software engineering lifecycle.
The extensions complement the capabilities of coding assistants, such as GitHub CoPilot, Codeium, AWS Code Whisperer, focusing on parts of the software engineering lifecycle that these offerings currently do not address. The extensions are supported by services implemented in a NodeJS server to integrate with LLMs, offer further automation, are configuration driven, and extensible. This enables the capabilities to be offered in various tooling contexts.
We also applied Generative AI (LLMs + prompt templates + orchestration for semi-automation through IDE and browser extensions) to create/iterate on various artifacts across requirements, test scripts, architecture, API specifications, etc. The objective was to develop clearer and more detailed artifacts, which can be more useful in subsequent activities.
Using the above approach, we were able to move through initial iterations much faster, producing more complete artifacts, especially for more common functional and technical domains (e. g. online banking).
The capabilities we implemented in our extensions by leveraging Generative AI include:
Integrate VS Code IDE with Jira to retrieve requirements, utilizing configurable prompts and LLMs to rate, summarize and generate suggestions to add detail, remove ambiguities and strengthen requirements. These are saved back to Jira as comments and updated requirements.
Generate Gherkin Scripts from requirements for Behavior Driven Development (BDD) or Acceptance Test Driven Development (ATDD).
Generate potential manual test cases.
Generate Playwright Scripts for automated testing.
For more details, watch the Demo Video.
As organizations have adopted API-centric development, they have created API Developer Portals. However, these currently do not offer good capabilities that allow product owners, BAs and developers from consuming teams to quickly discover relevant APIs, understand how to utilize them, get sample code, etc.
We utilized Generative AI to parse API specifications and associated metadata such as operation ID, API summary etc. These were converted into vector embeddings, and natural language searches were matched against them. LLMs could then be utilized to return results, generate sample code etc., from a standalone chatbot as well as from the VS Code IDE. For more details, watch the Demo Video.
As more teams move to an API-first model, it is important to ensure conformance to open standards. Open API Specifications are the standard for defining RESTful interfaces. The OAS enables developers to design a technology-agnostic API interface that forms the basis of their API development and consumption.
IrisGenAIDE has implemented command and context menus from within the IED to help developers validate their OASpec automatically using Gen AI and LLM from within the VS Code IDE. Recommendations are displayed in a separate tab to help the developer improve conformance. For more details, watch the Demo Video.
High-performance engineering teams can achieve higher overall productivity, ensure consistency, and deliver better quality artifacts by standardizing and templatizing. While this approach can be followed for any type of artifact, it is more commonly adopted for code artifacts that follow distinct solution patterns. We call these distinct patterns solution archetypes. Currently, selecting the solution archetype for a story or use case and creating an instance from the templates is a manual process requiring developers to prepare a lot of documentation and code.
In irisGenAIDE, we have piloted formalization of the concept of solution archetypes, providing developers the ability to search for solution archetypes, quickly create an instance of the archetype with relevant code and complete the development of the instance through the following approach:
Solution archetypes are formalized by documenting them in a repository, including structured templates to use in creating instances of the archetype.
The templates support predefined, parameterized and placeholder sections.
IrisGenAIDE utilizes Jira integration to fetch the story or use-case to be implemented.
Assuming the story has additional technical detail, the extension utilizes Generative AI to match and suggest solution archetypes that could be used to implement it. As an alternative, developers can use a natural language chat interface to search for solution archetypes and select an appropriate one to create an instance from.
IrisGenAIDE walks the developer through the process of completing the parameterized sections.
Developers can use coding assistants to complete the development from the draft.
With the availability of various AI coding assistants, the process of generating, analyzing and explaining code has become easier. However, software engineering is more than just churning out code; it is a complex endeavor involving individuals working within teams in different roles, producing various artifacts to deliver complex software solutions to businesses and clients.
Our early experimentation suggests that Generative AI has the potential to enable higher productivity, quality and agility across parts of the software engineering lifecycle that AI coding assistants do not currently address.
There is significant diversity in the personas involved, artifacts developed or derived, tools, technologies, and processes used across teams and applications. Considering this, realizing full value will require a structured approach that would standardize, automate, be configurable and extensible.
This will require development/utilization of tooling extensions (e. g. IDE extension, browser extension, Jira Plug-in etc.) that offer capabilities in-context to ease adoption. Over time, we anticipate that tool providers will offer such capabilities that can be adopted. However, this will result in islands of disconnected capabilities, diminishing the overall value.
Users playing different roles (e. g. BA vs. Architect vs. Developer vs. Tester, etc.) use different tooling for their activities. Integrating these different tools through a combination of Gen AI software engineering extensions and services will help streamline the flow of artifacts through the lifecycle, formalize the hand-off reviews, enable automated derivation of initial versions of related artifacts, etc.
This will result in higher productivity, quality and faster-time-to-market across the software engineerinvg lifecycle. To enable teams to become high-performant, the Gen AI software engineering extensions and services need to provide capabilities around standardization and templatization of standard solution patterns (archetypes) and formalize the definition and automation of steps of doneness for each artifact type.
This perspective paper is written by Mohit Mehrotra and Shivdas Nair at Iris Software.
Shivdas and Mohit are experienced software architects who are closely involved in various platform engineering and technology modernization initiatives for Iris clients within banking, retail and logistics domains. They are passionate about leveraging the power of emerging technologies and Generative AI to accelerate application development cycles for Iris customers.
Iris Software has been a trusted software engineering partner to Fortune 500 companies for over three decades. We help clients realize the full potential of technology-enabled transformation by bringing together a unique blend of domain knowledge, best-of-breed technologies, and experience executing essential and critical application development engagements. With over 4,300 skilled professionals, Iris builds mission-critical technology solutions across banking, financial services, insurance, life sciences, logistics, and manufacturing. Iris offers comprehensive services across Application and Product Engineering, Cloud Migration and native Cloud Development, DevSecOps, SRE, Data Engineering, AI/Gen AI/ML/NLP, Data Science, Quality Engineering, Intelligent Automation, Low-code/No-code Development etc.
Click here to read about the milestones of our 30-year journey.
Learn more about our Generative AI capabilities at:https://www.irissoftware.com/news-events/the-2020s-the-decade-of-artificial-intelligence/
