Agentic SDLC

A guide on adopting agentic AI in the software development lifecycle (SDLC).

Things are rapidly evolving; this is current as of October 2026.

Contents

How AI Is Changing Software Development

With the advent of AI, typing code is no longer the bottleneck. It started with code completion, then to an AI assistant bundled within a classic IDE. It then shifted towards coding agents and agent-first interfaces. As this progression was happening, LLMs have gotten so much better at following larger instructions, gotten really good at writing code and tool calling, harnesses have gotten better as well.

This is a huge shift since the advent of higher-level programming languages, now the intent can be represented in human language, and agents compiles it to a high level language, but with a nuance, it is non-deterministic in nature. Software engineers can now focus solely on durable decisions, like architecture, API design, and the domain model, etc the things that are strategic in nature.

While chat-based agentic interfaces are great for certain aspects of software development, for example asking questions about the codebase or brainstorming ideas to decide what you want to build, once you have decided and created a good specification of what needs to be built, you no longer have to stay within the loop. Google’s white paper calls this orchestrator vs. conductor.

Loops

Lot of places where human attention was needed in traditional CI/CD, it can now be delegated to coding agents running in a remote machine. This approach is called as loops. A loop is nothing but an automation to accomplish a particular goal, triggered by an event or schedule, that runs a multi-agent workflows with humans on the loop to make any durable decisions as needed for that workflow. With loops, software development is more observable and automatable than ever before, because it happens in a remote environment visible to the entire team. There is input and output, it can be eval’ed, it enables to find better cheaper model for a particular type of tasks etc. Since these loops are setup at a team level, the workflow is visible for the entire team and any optimization that can be done at the loop level, benefits the whole team.

You can create loops for many things, for example:

  • Loops to create a spec from an idea
  • Loops to implement from the spec
  • Loops to do PR review and fix
  • Loops that automatically triage issues

Since you can create loops for many things, it is important to have a system in place to manage them at scale. This is where software factories come in, to harness loops at scale.

Software Factories

A software factory is harnessing loops at scale. In essence, it is a system in itself that is built to create loops, provides observability, and allows humans to make decisions at the necessary places. The ecosystem of loops forms a software factory. Even though the term has existed since 1969, this definition fits well for the current agentic era. What CI/CD is for DevOps transformation, a software factory is for agentic transformation.

Spec-Driven Development

Currently, the default mode in most places is to stay in the loop and prompt agents every step of the way. A person with a great software engineering fundamentals can be highly productive with this approach. There are alternatives to consider to structure and scale this process, in most cases this is not a single person activity in a larger enterprise. This is where Spec-driven Development as a methodology can be considered, and an essential way to get better benefits from software factory.

At a minimum, a specification should contain:

  • Intent
  • Requirements
  • Acceptance criteria in Given/When/Then format
  • Any other additional context

For a good model of what a spec should be, see MinimumCD: Agent Delivery Contract.

Verification and Proofing

Whether the implementation is happening on a developer machine or in a cloud agent as a part of a loop, it is important for the agent to verify its work as fast as possible—not just unit tests. It should be higher-level tests, UI tests, and also linting and style checks that are hooked as a part of the build / pre-commit hooks.

Of late, there has been a lot of interest in using Lean and TLA+ to formally verify application logic.

The coding agent should also attach proofs of its verification on a pull request for human review. It is important for humans to review durable decisions and proofs more than code diffs.

Humans reviewing code diffs can soon become a bottleneck and need intelligent ways to be selective. Until there are good ways to do this, human reviews on a PR should focus on reviewing proofs and durable decisions, and the code diff for any mission-critical PRs / codebases.

Software Delivery Performance

While there will be gains by adopting AI in software development, it is still important to look at the core DORA model and DevOps culture as a whole to reap big benefits. See DORA Research.

Glossary

Durable Decisions

Architecture, API design, and the domain model: the things that are strategic.

Reference: Kiro: Frontier Engineering

Loops

A loop is nothing but an automation, triggered by an event, that runs a sequence of agents to accomplish a goal. Humans are still in the loop for any durable decisions.

Software Factory

The ecosystem of loops forms a software factory. In essence, a software factory is a system in itself that allows the creation of loops, provides observability, and allows humans to make decisions at the necessary places. Even though the term has existed since 1969, this definition fits well for the current agentic era. What CI/CD is for DevOps transformation, a software factory is for agentic transformation.

While there is no common definition for this modern software factory, this definition sums it up well: a software factory is harnessing loops at scale.

Reference: Addy Osmani: Software Factories

References