This is the third and final blog post in our series on integrating AI into the Software Development Lifecycle (SDLC). In this post, we will review the high-level technical elements of the three-phase approach discussed in the previous blogs.
Phase One: Leveraging existing low-hanging fruits and building the foundation
The first step in technical implementation is mapping the workflow of the lifecycle (see exhibit 1), identifying the tools currently in use, and determining if they have AI-enabled assistance capabilities. Whether it’s project management tools such as Atlassian’s Jira, requirement gathering tools such as Atlassian’s Confluence, design tools such as Lucidspark, or DevOps tools such as Azure DevOps, many already offer some AI assistance capabilities.
Exhibit 1
After a map of the end-to-end SDLC has been completed, the first phase consists of three steps:
- Implement the use of existing AI functionalities of tools already used in this workflow.
- Enable integration and services layers to support AI components.
- Build the foundational layer to be used throughout the three implementation phases.
This foundational layer consists of four main pillars, as depicted exhibit 1:
- Telemetry collection and time-series storage of key usage data points
- Metrics layer to enable usage and ROI analytics
- Implementation of quality guardrails and artifact validation
- And identity and security management
On identity and security management element, for instance, if MCP (model context protocol) is implemented is likely to be used in phase two, the right security foundation is put in place. Read more about best practices on MCP security in this blog post.
Phase Two: Building the prompt and agent catalog
Building on phase one, in phase two, the focus is on building a prompt and agent catalog to help with specific tasks. These small, purpose-driven task-specific agents will supplement the AI capabilities of the existing tools. They will be trained on the enterprise’s existing documents and will take over manual, generic, and/or easy-to-templatize sections of workflows. They will then be cataloged for use in the lifecycle, thereby delegating specific tasks from humans to AI agents.
For instance, if we consider a standard software engineering development lifecycle (see exhibit 2), each step will have multiple sub-steps, many of which could leverage dedicated purpose-driven & guided AI agents.
Exhibit 2
For example, the “design and architecture” step could leverage agents to analyze the story plan and propose design approaches that would then be reviewed and approved by experienced architects. Or initial UX design would be AI-proposed based on an enterprise’s internal guidelines (branding, best practices, etc.) before being validated by UX designers.
Phase Three: Graduating to autonomous AI agents-based SDLC
In phase three, we add an enterprise knowledge layer to make the agentic systems context-aware. This will further enable the development of complex autonomous agents that will orchestrate existing simple AI agents and capabilities, as well as combined more advanced capabilities. In this phase, the transition will be to a more autonomous SDLC where human supervision and control will be leveraged where it adds the most value and where AI agents will do most of the heavy lifting across the development & engineering lifecycle.
Conclusion
Integrating AI into the SDLC through this three-phase approach allows for more effective & pragmatic integration of AI into the existing SDLC. By leveraging existing AI capabilities, building a prompt and agent catalog, and adding an enterprise knowledge graph layer, organizations can enhance their development lifecycle incrementally and achieve better outcomes while ensuring measured adoption by their engineering teams.
We believe the true north star of a context-aware, human-AI symbiotic engineering ecosystem is not too far. However, the true success of AI-driven SDLC will be specific to each enterprise’s knowledge & ontology that would be the context to its own autonomous agents & systems building and engineering software.
This blog post is the final installment in a three-part series on integrating AI into the Software Development Life Cycle (SDLC). You can read the previous two posts here:
- Generative AI’s role in revolutionizing the software development life cycle
- AI-assisted engineering phase 1: Laying the groundwork for autonomous engineering
