Artificial Intelligence will create, test, and deliver software products. It will be accurate. It will be efficient. It will be secure.
The following showcases how AI agents, each specialized to handle distinct aspects of the software development lifecycle, will coordinate delivery. Agents will leverage different artificial intelligence capabilities at speeds that humans cannot compete with.
How will it work?
A software creator wants a product to be built. They provide a general description to the Application Generator (AG). The AG leverages large language model technology to analyze the requirements and interact with the software creator to refine them and build out an expected set of inputs and outputs for testing.
While the AG is working with the software creator, it also collaborates with a domain modeler. Domain modeling allows software to be created using the language of the domain. This means that if someone were to review the source code, they would understand the intent of the application. It is important to note that at this point, no real software has been created.
Once the AG and software creator agree that the model is accurate for the intended goal, software creation begins. Coding Agents, likely to be Reinforcement Learning AIs, build the software based on the Model Agent’s specifications.
These are divided into several specialized types:
- User Interface Agent: Focuses on building the front-end aspects of the application, ensuring that the user interface is intuitive and responsive.
- Infrastructure Agent: Works on the database, infrastructure as code, or other shared service layers.
- Service Agent: Develops the business logic and services layer, integrating various application functionalities smoothly.
This development process includes appropriate testing. This will include security, unit testing, testing against the desired model, and performance.
Once completed, the Coding Agent will deploy the runtime and notify a Testing Agent to perform more detailed testing. This comprehensive test suite will dive deeper into security, functionality, performance, usability, load testing, and more.
1. Revolutionizing Software Engineering with AI
Software engineering is a set of repeatable tasks. Like physical architecture, variations in software are more about preferences than the underlying principles of high-quality applications.
This automated workflow has the potential to impact nearly all areas of the software development lifecycle.
Design: Most software can be developed using similar models. There will be slight variations in the design based on priorities within the application. Like a building, basic principles will remain the same. This means that Coding Agents can leverage well-known practices and deliver what some would consider complex designs that offer the best outcomes.
Coding: While there are many ways to implement specific algorithms, the variants aren’t typically needed. At its core, programming languages are grammars and foundational components. Each language has its strengths, but ultimately, while there may be infinite ways to implement software, there are better ways than others, leading to a finite set of options.
Testing: AI’s synthetic data generation combined with reinforcement training changes testing. Combine that with the potential of Large Action Models (large language models for runtimes), and there is a non-zero chance of legitimately bug-free software. The key word there is bug-free. Architecture or business logic flaws will almost certainly exist.
Support LIfe Cycle: One possible outcome is the ability for AI to write user documentation as it builds. It will also manage documentation while reviewing and potentially responding to support tickets. Another interesting possibility is the ability to create dynamic bindings between versions of software should a breaking change need to be created.
2. The Evolution of Software Practices
Source Control: Software is a living thing. It evolves as needs and technology change. This will not change, and AI will still leverage it in some way. The typical options involve feature branching, version branching, or feature flagging. Feature flagging makes more sense in this style of development. It gives the agents better context of the software in terms of capabilities and what needs to be tested at any one time.
Requirements Tracking: Requirements are usually tracked to give both a historical context of the software product and its current state. This still holds value even for automated creation. It will provide the AI with the capability to hold conversations with the software creator to discuss priorities and possibly an additional interaction or push for a needed business function.
Software Security: Security testing won’t go away. Coding Agents and Testing Agents can use software security testing agents. The Application Generator and Domain Builder have the capability to better handle access controls and business logic security.
3. Behavioral Psychology: Adapting to Rapid Changes
Impact on Users: There is a significant push in software for faster releases. In a world where the entire process is automated and software could be released in minutes, there are things to be cautious of. User fatigue is one. Keeping up with software releases and new features can be tiring. It can lead to loss of productivity as users struggle to become experts due to rapid changes.
The creator’s paradox: he software creator will have the ability to change software very rapidly. They will be able to track any data at any time. They will be able to make shifts in the products with ease. The cost of execution will go down. Yet the cost of execution will also go up. There will need to be a balancing act with changes impacting users. There will be a need to manage their own decision-making process to prevent their own decision fatigue.
Software is going to be created and changed at speeds that we are not used to. Both software product owners and users are going to have to adjust. The roller coaster is about to leave the station.