For decades, the software development lifecycle has followed a familiar rhythm. Requirements are gathered. Designs are produced. Developers implement features. Test teams validate them. CI/CD pipelines package and deploy them. The process works — but it often involves significant hand-offs, coordination overhead, and cycles of clarification between teams.
Mycom has started adopting a different approach over the past eighteen months. What began as simply adding AI coding assistants to existing, unchanged working practices quickly evolved into something much larger: a shift from the traditional Software Development Lifecycle (SDLC) to what the industry calls the AI-Driven Development Lifecycle (AI-DLC).
This transition did not just introduce a set of new tools. It reshaped how our SaaS teams structure work, collaborate, move from idea to production, and delight customers.
The shift: From writing code to designing systems
Early AI coding assistants helped developers in generating snippets of code faster. Useful, but incremental. What Mycom developers observed with newer agentic development environments was something fundamentally different. These systems are capable of planning work, coordinating tools, generating code and tests, and iterating toward working outcomes. Instead of accelerating just the coding step, they begin to reshape the entire lifecycle.
In practice, this means the centre of gravity shifts away from writing code manually and towards defining intent, architecture, and verification. Mycom’s platform developers still write code — but increasingly they design systems that intelligent agents can help implement.
Introducing AI-DLC to the platform teams
Mycom’s SaaS platform teams adopted this model gradually. Rather than replacing existing processes, agentic tooling was introduced into specific parts of the lifecycle and observed for workflow evolution. Over time, the most effective pattern that emerged was specification-driven development supported by AI agents.
Today, most new work begins with a structured planning phase where the developers define the intent of a change before implementation starts. This includes:
- Describing requirements in structured form
- Defining the technical design and architecture
- Decomposing work into implementation tasks
- Capturing verification criteria and correctness properties
Once this foundation is in place, AI agents can assist with implementation, test generation, and pipeline integration. This approach dramatically reduces the ambiguity that traditionally exists between planning and execution phases.
Designing projects for agents
One of the most important lessons from this transition is that AI tools become dramatically more effective when the surrounding project structure is designed for them. Making a codebase ‘agent-friendly’ is just as important as choosing the right models or tools. This includes practices, such as:
- Maintaining clear architectural context for the project
- Capturing system knowledge in steering files and documentation
- Defining reusable workflows and domain capabilities for agents
- Structuring repositories in ways that agents can navigate reliably
These elements act as the operational context that helps agents understand how the system works and how new features should be implemented.
Agents as contributors across the lifecycle
Once this structure is in place, AI agents can contribute across multiple phases of development. In Mycom’s current workflows, they assist with:
- Translating specifications into implementation plans
- Generating code and tests aligned with architectural constraints
- Validating behaviour through automated testing
- Interacting with CI/CD pipelines to build and deploy artefacts
- Iterating on fixes when automated verification fails
This enables a form of long-running, iterative execution, where agents can work through a set of tasks while continuously validating the results. Developers remain responsible for the key decisions: defining the system, reviewing changes, and ensuring the architecture evolves safely. But the mechanical steps between planning and delivery become significantly faster.
What changes for the Mycom platform development teams
Perhaps the most interesting impact of adopting AI-DLC is how it changes everyone’s day-to-day role across the life cycle. Mycom engineers spend less time producing individual artefacts and more time working on:
- Crystallising requirements
- Defining behavioural specifications
- System architecture and choices
- Shaping development workflows
- Guiding and reviewing agent-generated work
- Running and operating production systems
In other words, the role shifts toward system design and orchestration. Agents help execute the plan, while the AI-DLC pod focus on intent, correctness, and long-term evolution and running of the platform.
The role of tools such as Kiro
Agentic development platforms, such as Kiro, have been instrumental in enabling this shift within our SaaS teams. In Mycom’s experience, Kiro’s emphasis on specification-driven planning aligns particularly well with the AI-DLC model. It provides a structured environment where requirements, design artefacts, implementation tasks, and verification steps remain connected throughout the lifecycle. However, the broader transformation observed is not tied to a single tool. The underlying pattern — designing development workflows in which AI agents participate throughout the lifecycle — is likely to become increasingly common across the software industry.
The emergence of a new model
Looking back at our journey, the most important insight is that the AI-DLC is not simply about using AI to write code faster. It represents a shift in how software systems are conceived, built, and run.
Mycom’s projects increasingly start with structured intent and ‘working backwards from customers’, both internal and external. Specifications drive design. The design drives implementation. Automated verification enables agents to iterate until systems perform as expected. For Mycom’s SaaS platform teams, this model is already enabling smaller, integrated, high-agency teams to move quicker while maintaining strong engineering and operational discipline. A true implementation of the ‘you build it – you run it’ paradigm.
Through this transition, one thing is becoming clear: the future of software development will not be defined solely by the code we write — but by how effectively we design systems where humans and intelligent agents collaborate to build and ship software together.
