The Agentic Software Development Lifecycle: What Really Changes in Software Development

Within three years, AI systems in software development have evolved from autocompletion through copilots to agents that plan and complete multi-step tasks on their own. What changes is not a single development step but the operating model of software development as a whole. With this article we open a series on the agentic Software Development Lifecycle and describe what really changes, what stays, and how to tell the difference between a tool and a new division of labor.

Division of labor instead of tool usage

In the agentic Software Development Lifecycle, coordinated AI agents carry out the executing work across all phases: from requirements analysis through architecture, code, testing, and deployment to operations. People define the goal, make decisions, review results, and take responsibility for every release. That is the core of the change, and it fits into one sentence:

People own the why, agents take over the how.

The difference from a copilot is structural, not gradual. A copilot assists one person with one work step; every suggestion is reviewed individually and accepted or discarded. An agent takes on entire assignments against defined quality criteria: it plans sub-steps, generates code and tests, checks itself against the specification, and hands a verified result to a human gate. Only this level changes the cost structure and lead time of a delivery organization, and only this level requires a new operating model.

That this level has been reached is shown by the measurement series of Kwa et al. (2025, arXiv:2503.14499): the length of tasks that AI agents complete autonomously with a 50 percent success rate is currently doubling roughly every seven months. In rough terms, 2023 meant single functions, 2024 well-defined tickets and tests, 2025 real issues end to end from analysis to pull request. Whoever starts this year builds a maturity that cannot be bought: tools are available at any time, while verified specifications, a robust knowledge graph, and a practiced organization only emerge in operation.

Six maturity levels and a tipping point

To make the path measurable, we work with a maturity model in six levels, modeled on the Capability Maturity Model (Paulk et al. 1993) and the delivery research of DORA (DevOps Research and Assessment; Forsgren, Humble, Kim 2018):

• L0 Manual: individual heroics, undocumented processes, no reliable measurement.
• L1 Digital: version control and tickets, deployed manually; the lead metric is velocity per team.
• L2 Automated: DevOps baseline with CI/CD and test automation; people build and operate the pipeline.
• L3 LLM-assisted: copilots assist in everyday development; people review every single output, and the acceptance rate of suggestions is measured.
• L4 Agent-supported: agents execute multi-step assignments end to end; people hold the critical gates and are responsible for releases; the lead metric is cycle time per assignment.
• L5 Agentic: an orchestrated agent ecosystem across the entire lifecycle; people steer intent, architecture, and responsibility; throughput per full-time equivalent at stable quality is measured.

Most large organizations today stand on the DevOps baseline (L2), with LLM islands in individual teams (L3): copilot licenses have been distributed, but processes, quality assurance, and governance are unchanged. The result is a familiar pattern: local time savings for individual developers, but no measurable change in lead time, quality, or cost at the portfolio level.

The tipping point lies between L3 and L4. Up to L3, licenses and training are enough; from L4 onward, organization, quality assurance, and governance carry the change. This is exactly why copilot programs without work on the operating model get stuck in pilot islands, and exactly there it is decided who realizes the productivity leaps. I consider this tipping point the most important insight of the past three years: the question is not which model an organization licenses, but whether it is prepared to reorganize processes, verification, and responsibility.

Four shifts that change the operating model

Code becomes renewable, the specification becomes the asset. When agents generate code in hours, code is no longer an asset but a reproducible artifact. The lasting asset is the machine-readable specification: rules, data, interfaces, and acceptance criteria in verifiable quality according to ISO/IEC/IEEE 29148. Whoever owns it can have code regenerated, in a different technology, with a different model, by a different provider. Own the Spec, not the Code. For existing systems this means reconstructing the as-is specification first, for example with App2Spec from observed usage and with SLIP from the source code.

Context becomes a factor of production. Agents are only as good as their context. Without structured knowledge about systems, domain terms, and rules, models guess: they hallucinate requirements, overlook dependencies, and create rework that eats up the efficiency gain. A knowledge graph that connects systems, requirements, test cases, releases, and regulations through typed and evidenced relationships solves this structurally. It belongs to the organization, not to the model provider, and it remains when the model is replaced.

Verification becomes the bottleneck. When generation becomes cheap, review is the scarce factor. Two principles carry the answer: no agent checks its own work; independent verification agents test against the specification, scan security and dependencies, and measure coverage. And test cases are derived from the specification before code is generated. Test-first moves from good practice to the norm.

Handoffs become responsibility. The smallest unit of value creation is no longer the specialist team of eight roles but the cell: five people and a growing number of agents, responsible end to end for one business slice. The cell lead owns the outcome, the domain expert holds the business truth, two full-stack engineers steer architecture, review, and the agents themselves, and the operations expert secures the last mile into production. Cycle times fall from weeks to days, in mature cells to hours, with unchanged quality gates.

What stays: people decide at every gate

What does not change is responsibility. Every release at a gate remains a human decision; every agent step behind it is logged. The division of labor along the four phases looks like this:

This structure is at the same time the answer to regulation. The EU AI Act, Regulation (EU) 2024/1689, requires risk management, human oversight, and traceability; the Digital Operational Resilience Act (DORA), Regulation (EU) 2022/2554, demands robust ICT risk management in the financial sector. Three principles provide the building blocks: a person is responsible for every change made by an agent, policies are enforced as compliance as code in pipelines rather than remembered in documents, and a complete audit trail makes every agent action, every context used, and every release reconstructable. Built correctly, the agentic Software Development Lifecycle is therefore not the compliance risk it is often taken for, but the first form of delivery in which evidence emerges as a by-product of the work.

Roles do not disappear either; they shift from execution to judgment: developers become architects of agentic systems, domain experts become the precise source of the specification, and leaders steer through target pictures and metrics rather than effort planning. Culturally, the DevOps moment repeats itself: AI becomes a team member, not a tool.

What the evidence says and what we measure ourselves

The scientific evidence for the productivity effect of AI in knowledge work is now robust. In the controlled experiment by Peng et al. (2023, arXiv:2302.06590), the time to complete programming tasks with AI assistance fell by 56 percent. Noy and Zhang (2023, Science 381) measured 40 percent less time on professional writing tasks at 18 percent higher quality. Brynjolfsson, Li, and Raymond (2025, Quarterly Journal of Economics 140) found 14 percent higher productivity among customer support staff, and 34 percent among newcomers to the job. These figures describe the copilot level, that is, L3. The agentic lifecycle starts above it.

We deliberately label our own figures as experience values from ReqPOOL projects since 2023, verifiable per project and not scientific evidence. In the agentically orchestrated implementation model, that is, for the pure coding share, we see up to five times faster delivery and up to 80 percent lower coding costs. Across entire projects including strategy, specification, and steering, the efficiency gain is 20 to 45 percent. Quality rises by around 30 percent through systematic rather than sample-based verification. The distinction between the coding share and the whole project is essential, and we communicate it transparently. Efficiency counts only within constant guardrails: change failure rate, production incidents, defect rate, and test coverage must not deteriorate.

How we do it ourselves: reqCoder

We do not just describe this lifecycle, we work this way. reqCoder is ReqPOOL's complete, fully automated agentic Software Development Lifecycle and already in use internally at ReqPOOL: from the specification as a machine-readable build order through implementation, testing, and acceptance to deployment. Coordinated agents carry out the executing work, our experts validate in the loop, and every release at a gate remains a human decision.

Implementation runs in four individually commissioned stages: Prototype (two to four weeks) as a clickable proof of scope generated from the specification, Beta (four to eight weeks) with design, build, and test along the agentic pipeline, Deployment (two to six weeks) with acceptance against the specification and automated pipelines, and Production as monitored operation with complete IP transfer. Between the stages lie evidence gates: proof of scope, estimate, quality check of the requirements with reqChecker, security scan, Signoff acceptance, and audit trail. Generators and verifiers are separated, the AI runs in EU data centers, and there is no training on client data. For banks, public administrations, and other regulated organizations, this chain is what decides whether an experiment becomes a system fit for acceptance.

The next step

The agentic Software Development Lifecycle is not a tool purchase but a plannable maturity path. The first step is small and concrete: determine your position, set up two to three lighthouse cells, and measure against the baseline after 90 days. How we anchor the agentic Software Development Lifecycle in your organization is described on the Agentic Software Development Lifecycle page; how reqCoder generates software from the specification, on the reqCoder page. In the coming articles of this series we will take a closer look at individual building blocks of this operating model. Or talk to us directly: in an expert conversation we clarify where your organization stands on the maturity path.