The AI-first PDLC (AI SDLC) is a six-stage cycle: Specify, Classify, Build, Test, Verify and Release. It is a vision of how software should be built once AI takes over generation, and it rests on one shift: generation is no longer the bottleneck, specification and verification are. The lifecycle, and the people in it, reorganize around that trade: spec first, AI executes, humans govern.
How does the AI SDLC differ from the traditional SDLC?

The traditional SDLC runs through six stages, from Analysis to Retire. Analysis sits with the PM and an Enterprise Architect, Design with the PO and a Solution or System Architect, and Build is shared by the Developer, QA and the PO. Deploy, release and monitor are split across the Developer, the PO or PM, and Support. The AI SDLC keeps the same start and end points but reorganizes the middle, running as Specify, Classify, Build, Test, Verify and Release, followed by Maintain and Retire. Two gates, a Requirements Gate and a Design Gate, sit across the first two stages, and the diagram highlights Specify, Classify and Verify as the stages where the change is greatest.
What are the six stages of the AI-first PDLC?
1. Specify
Acceptance criteria are written to be machine-checkable before a sprint starts, not discovered mid-build. This work is human-authored and approved in the Requirements Gate. The Product Owner and the Business or Industry SME own it.
2. Classify
Two axes decide what AI may touch and how closely it is watched: how well-specified the work is, and the cost of being wrong. The decision is made at the Design Gate, and the Architect or Tech Lead owns it.
3. Build
AI drafts code, unit tests and documentation straight from the spec, and the output is released for review after an AI plan review. The Developer owns this stage, which the diagram marks as an agent build.
4. Test
AI drafts test plans, which are reviewed after the Test Plan review. AI then verifies application metrics, covering functional, integration, security and compliance checks, and runs the tests. People verify a second set of metrics manually: response quality, hallucination rates, prompt effectiveness, token and cost behavior, safety violations, and the actions agents generate. A human in the loop then runs user acceptance testing (UAT) to certify the definition of Done. Ownership is shared between the Tester and Tech Lead, along with the Product Owner and Business or Industry SME.
5. Verify
Review is tiered by blast radius, meaning how much damage a mistake could do, and it is sized into sprint capacity as a planned cost. This stage is human-gated, and the Product Owner owns it.
6. Release
The release boundary doubles as a checkpoint. Metrics are baselined and re-measured every cycle. The Developer owns the release stage.
The cycle is continuous. Release feeds the next specification, and the loop starts again.
Who owns what, and how do roles shift?
AI takes on the work that starts from a clear spec: first drafts of code, tests and documentation, a first pass at edge-case and non-functional requirement questions during backlog refinement, legacy code comprehension and mapping, release notes, and integration boilerplate for third-party APIs and internal services.
People keep the work that depends on judgment and accountability. They write the spec and define "right" before AI writes anything, apply domain judgment and design novel or high-complexity logic, and sign off on compliance and security where applicable. They also decide data isolation and security boundaries, and they verify and own what ships, because accountability does not delegate.
How does responsibility shift for each role?
Three roles take on more. The Product Owner and Business or Industry SME see the biggest increase: they turn product intent into specs, and because spec quality now directly gates what AI can safely touch, they become the critical bottleneck. The Tech Architect or Lead owns the Classify gate and AI governance. The Developer spends less time typing code AI can draft and more time specifying intent, reviewing AI output and owning architecture, so verification replaces volume as the core skill.
Four roles take on less. For the Scrum Master, AI absorbs status tracking, backlog housekeeping and capacity reporting, leaving planning review capacity as a real constraint each sprint. For the manual Tester, standalone test-writing folds into spec-writing and review, leaving exploratory testing that AI cannot anticipate. For the UX Engineer, AI generates first-pass UI variants and boilerplate components, freeing time for user research and interaction judgment that AI cannot originate. QA Automation shifts to test strategy and verifying that AI-generated coverage is trustworthy, since AI drafts test scripts as part of the Definition of Done.
Some work is fading as a standalone function: junior implementation coding, since the routine build tasks juniors learn on are what AI absorbs first; boilerplate integration development, which becomes AI-drafted and human-verified; and pure documentation writing, where first drafts become AI output and the role shifts to accuracy review.
New roles are emerging in their place: an AI Verification or Review Lead who owns tiered review and blast-radius classification, a Legacy Comprehension Lead who directs AI-assisted mapping of the oldest, highest-risk modules, and an AI Governance and Provenance Owner who covers licensing and hallucinated-package risk, tied to existing security and compliance controls.
Where does the time go in an AI-first lifecycle?
Here is how the split of effort changes:
| Phase | Traditional | AI-First (2026) |
Requirements | ~10% | ~25% |
Design | ~15% | ~30% |
Implementation | ~40% | ~10% |
Test | ~20% | ~15% |
Deploy | ~5% | ~5% |
Ops | ~10% | ~15% |
AI compresses implementation and runs tests concurrently, so effort moves into requirements and design on one side, and into ops and observability on the other.
Why do specifications become the control plane?
In an AI-first lifecycle, specs are versioned, executable artifacts. AI agents read them, validate against them and extend them, rather than just referencing them. Product briefs become AI-drafted technical specs, story maps, data models and API schemas within hours.
The direction of control also reverses. Acceptance criteria and contracts drive test generation and code changes, not the other way around. Tests are generated from specs and run continuously as agents iterate, which makes specification governance central: a wrong spec produces confidently wrong tests and code.
How do quality and risk change when agents write the code?
Quality moves from human discipline to governed automation. Far more pull requests land, so work-in-progress limits must apply to agents, not just humans. Craft practices are augmented or replaced by mechanical gates, with test-driven development as the anchor because agents excel at test-driven loops. System quality expands to cover agent runtime, sandboxing and OWASP ASI-style controls for AI-specific risks.
Security gets the same treatment. AI-generated code ships faster but can be systematically less secure without strict gates, so SAST and SCA, including transitive dependencies, run continuously in PR workflows.
Architecture reviews tighten too. More architectural decisions need explicit review before agents execute multi-file changes, and tools that map context across services win over line-level completions. That strengthens System Architects and Architecture Runway planning, with firmer limits on what agents may change autonomously. Teams reorganize around AI agent squads with humans as reviewers and governors, and junior hiring profiles shift accordingly.
What guardrails does the new risk surface need?
Direct LLM integration into portfolio tools without bounded limits creates lateral vulnerabilities. The guardrails are sandboxed agent execution, strict tool permissions, audit logs of agent actions, and stronger rollback and feature-flag controls.
What does the AI-first PDLC mean for SAFe teams?
For teams running SAFe, the shift shows up in four practical ways. First, treat specs, meaning Epics, Features, Stories, acceptance criteria and contracts, as first-class, versioned artifacts that drive AI, and make Epics, Features and Stories crisper and more structured so agents can reason over them reliably. Second, redefine the Definition of Done to include AI-specific checks: spec alignment, test coverage from specs, security scans and agent action auditability. Third, invest in platform capabilities such as repo-wide context, agent sandboxes, CI/CD with continuous SAST/SCA, and observability for agent behavior. Fourth, upskill roles, so that Product Owners and System Architects become "spec engineers" and developers become AI orchestrators and quality governors.
The shift also affects ART cadence, capacity allocation and possibly funding models as throughput rises and cycle times shrink.
Conclusion
Writing code is no longer the hard part of building software. Specifying it well and verifying it properly are, and accountability for both stays with people, because release feeds the next specification and the cycle starts again.

