By Scott Ambler
Hardly a day goes by without news about a new advance in artificial intelligence (AI). AI is being applied to augment white collar workers, including software professionals. This includes software architects. Common augmentation strategies such as using AI to help you write something or to summarize a long article are certainly applicable, but more interesting are the use specific to software architecture. In this article I explore five use cases that I have seen in practice.
I need to make two things clear. First, this article focuses on software architecture AI-augmentation use cases. I won’t go into typical white-collar worker use cases nor will I even go into software development use cases that aren’t specific to architecture. Second, the way that I have worded the use case is important. I use terms like potential and suggest. This is because you need to “keep humans in the loop”, working in such a way that a person validates the output of an AI, updates it as appropriate, then commits it to your overall asset base. An implication of this is that the human in the loop, in this case a software architect, must be sufficiently competent to judge the AI’s output. Even with AI, we still need skilled software architects regardless of what the tech bros may claim.
For each use case I will present an overview of it, suggest exemplar tools, and describe the advantages and disadvantages of applying it. Regarding the tools, my goal is simply to provide examples it is not in any way to recommend them. As always, you need to identify the appropriate tools for your context. The AI-augmentation use cases for software architects that we will explore are:
- Analyze existing code
- Generate potential tests
- Identify technical debt
- Suggest potential architectural strategies
- Visualize an existing implementation and potential workflows
AI Use Case #1: Analyze Existing Code
As software architects we often need to work with existing legacy code that we are unfamiliar with. Yes, sometimes it’s code that we have forgotten about even though we wrote it. Tooling such as SonarQube and CAST SBOM Manager help us to navigate the complexities of existing implementations and to better understand any technical debt that we face.
Why do we want to apply AI-based tooling to help us with this? First, it enables us to navigate complexities of legacy code and to pinpoint any potential problems in it. Second, thoroughness. The AI is likely to perform a more thorough job than people would. Third, trustworthiness. The AI is less likely to be biased in its analysis than humans would be.
Unfortunately, there are potential downsides to using AI to analyze existing code. The first issue is accuracy risk. Although AIs can often be built to produce more accurate results than people, they still aren’t perfect and any results shouldn’t be taken verbatim. The second challenge is intellectual property (IP) risk. Does the AI retain your IP after it processes it? Are you sure that it doesn’t (has the licensing agreement that you likely didn’t read changed since you first started using the tool)? The point is that you need to be careful. Third is privacy risk. Are you taking safeguards to not provide personal identifying information (PII) to the AI?
AI Use Case #2: Generate Potential Tests
It is possible, and mostly desirable, to generate tests (or more accurately automate checks) from various artifacts. For example, you can generate acceptance tests and quality of service (QoS) tests from requirement descriptions. These tests are a critical part of validating your architecture. Tooling such as TestRigor enables you to create acceptance and UI-level integration tests from English prose.
There are several advantages to using AI tools to generate architecture-oriented tests. First, you can generate tests to use as executable specifications and include them in your automated testing strategy. Second, the AI is likely trained on a greater range of examples and contexts than that experienced by the people on your team, potentially giving a more robust result. Third, as mentioned earlier, the AI is likely to do a more thorough and trustworthy job than people would.
There are of course drawbacks to this use case. There is intellectual property (IP) risk. Does the AI retain any of your IP after you use it? Are you completely sure of that? And of course, there is the accuracy and privacy risks mentioned earlier.
AI Use Case #3: Identify Technical Debt
Technical debt refers to quality issues within your system infrastructure, potentially pertaining to architecture, design, or implementation. Technical debt is mistakenly thought of as just a source code problem, but the concept is also applicable to source data (this is referred to as data debt) as well as your validation assets. AI has been used for years to analyze existing systems to identify potential opportunities to improve the quality (to pay down technical debt). SonarQube, CAST SQG and BlackDuck’s Coverity Static Analysis statically analyze existing code. Applitools Visual AI dynamically finds user interface (UI) bugs and Veracode’s DAST to find runtime vulnerabilities in web apps.
The advantages of this use case are that it pinpoints aspects of your implementation that potentially should be improved. As described earlier, AI tooling offers to the potential for greater range, thoroughness, and trustworthiness of the work products as compared with that of people. Drawbacks to using AI-tooling to identify technical debt include the accuracy, IP, and privacy risks described above.
AI Use Case #4: Suggest Potential Architectural Strategies
This is likely the most obvious use case of the batch – Software professionals can work with LLMs to suggest potential architecture, technical design, and UI design strategies for what they’re building. As you’d expect, modeling tool vendors are building copilot/advisor functionality into their offerings as well. The advantages are that the AI will suggest a greater range of options that are potentially more trustworthy than what people would produce. Disadvantages are the accuracy, IP, and privacy risks discussed earlier.
AI Use Case #5: Visualize Existing Implementations and Potential Workflows
As software architects we regularly work with legacy implementations that they need to leverage and often evolve. This software is often complex, using a myriad of technologies for reasons that have been forgotten over time. Tools such as CAST Imaging visualizes existing code and ChartDB visualizes legacy data schemas to provide a “birds-eye view” of the actual situation that you face. Similarly, when we extend existing systems we need to ensure that what we are doing fits into the existing workflow appropriately. Visualization tools such as Decisions Process Mining analyze existing systems and visualize the supported workflow. As with earlier use cases, the advantages are greater thoroughness and trustworthiness of the work products and the disadvantages once again are the accuracy, IP, and privacy risks.
Be Realistic About AI Augmentation
The fundamental challenge is that you need to be realistic about how AI can augment software development. You still need humans in the loop that understand the part of the software development process to validate the AI’s output. Furthermore, they need to be able to integrate that output successfully into the overall whole. The smart strategy is to work incrementally in small steps, ideally with active stakeholder participation on a regular basis.
Scott Ambler helps teams and organizations improve their ways of working (WoW) and ways of thinking (WoT) about software and data.