Beyond the Software Factory: The Agentic PDLC and the Future of SaaS
Key Takeaways
The bottleneck has moved. AI agents make code abundant; the scarce resources are now clarity of intent, confidence in correctness, and proof of value.
The Agentic Product Development Lifecycle (Agentic PDLC) replaces the ticket-driven SDLC with a nine-stage learning loop in which the unit of work is a testable outcome hypothesis, not a ticket.
The Product Intent Contract succeeds the PRD: one versioned artifact, readable by executives and enforceable by CI pipelines and policy engines.
Authority is enforced by infrastructure, not prompts. Agents propose; deterministic controls (identity, policy, an action gateway and an evidence ledger) decide.
SaaS moves from software access to delegated work. Pricing follows the work, and cost per accepted task becomes the metric that matters to customers and CFOs.
Verification becomes the moat. Independent evals, agentic test-driven development and proof matched to consequence separate trustworthy products from fast ones.
Autonomy is earned task by task, can be revoked, and is backed by a 180-day adoption plan and five questions every CIO, CTO and CAIO must answer.
A CAIO's perspective on how software, SaaS and the enterprise operating model change when AI agents can write, test and ship code.
Full whitepaper (PDF, 37 pages, 15 figures): DOI 10.5281/zenodo.24422793.
The SDLC is broken. Here is what replaces it: how humans and governed AI agents will build, run, and continuously evolve the next generation of software, SaaS, and the autonomous enterprise.
Code Is Abundant. Trust Is Scarce.
For most of software's history, the binding constraint was the cost of building it. Every method we invented, from Waterfall to Agile to DevOps, was a way to turn scarce engineering capacity into working code more reliably.
That constraint is dissolving. AI agents can now read a codebase, draft a specification, write the implementation, generate the tests, and open the pull request before a human has finished their coffee. Implementation is becoming the cheapest step in the lifecycle.
And that is exactly why the SDLC is broken. Not its disciplines; requirements, architecture, testing, security, and operations matter more than ever.
What is broken is the operating model wrapped around them: a relay race of human handoffs, built to move artifacts from one desk to the next, and to declare victory when a ticket closes.
Pour machine-speed execution into that relay race and three things happen. Review queues swell. Security and release gates become the new bottleneck. And teams ship more features, faster, without knowing whether any of them mattered.
The scarce resource is no longer code. It is clarity of intent, confidence in correctness, and proof of value.
This paper describes what comes next: the Agentic Product Development Lifecycle (Agentic PDLC). It is an operating model in which humans and bounded AI agents work as one governed system, continuously turning customer needs into verified product outcomes.
In practice, that means:
- Outcomes, not output, define success. The unit of work is a testable outcome hypothesis, not a ticket.
- Agents work across the whole lifecycle, from discovery and design to verification, release, and learning.
- Humans own intent, risk, and the consequential decisions, by name.
- Authority is enforced by infrastructure, not by prompts. Agents propose; deterministic controls decide.
- Every action is traceable, from customer signal to production outcome.
- Autonomy is earned, task by task, and it can be revoked.
- Production evidence drives the next move: expand, revise, roll back, or retire.
For SaaS companies, the shift is doubly consequential. AI is changing how SaaS is built, what SaaS delivers, and how SaaS participates in an increasingly autonomous enterprise.
Tomorrow's SaaS platform will not just give customers tools to do work. It will do bounded, governed work on their behalf.
The Agentic PDLC is the discipline that governs both: the agents that build the product, and the agents that run inside it.
The goal is not to automate every step of building software. It is to shorten the distance between a real customer need and a trustworthy, measurable outcome.
How We Got Here, and Why the Old Model Breaks
Software delivery has reinvented itself every decade, and each reinvention removed a bottleneck. Waterfall brought control. Agile brought feedback. DevOps connected code to production. DevSecOps and platform engineering made speed safe at scale.
None of these became obsolete; each became a layer the next one stands on.
Figure 1. The evolution of software delivery ยท 5 eras, each with a new unit of work
The Agentic PDLC is the next layer, and it introduces something no earlier method had to manage: a non-human participant that can plan, use tools, act, and escalate.
Traditional delivery coordinates people, processes, and systems. Agentic delivery must also coordinate software actors with variable behavior and delegated authority.
The Bottleneck Moves
Time to a real outcome has always been the sum of discovery, decision, execution, verification, release, and learning. AI speeds up all of them, discovery and analysis included, but it collapses execution far more than the rest, while decisions, verification, and learning stay bound by human attention and organizational process.
The result is predictable: the queue moves downstream. Reviewers drown. Release gates jam. And the organization learns no faster than before, because nothing changed about how it decides what to build or how it knows whether it worked.
The question for leaders is no longer how fast can we write code? It is how fast can we reach a trustworthy decision about a product change?
Five Ways the Delivery-Centered Model Fails Under AI
- Intent dissolves across handoffs. A customer problem becomes a request, then a feature, then requirements, then tickets, then code. Each translation is reasonable; together they lose the point. Agents optimize the ticket, not the customer.
- Policies describe, but do not govern. "Must preserve tenant isolation" in a requirements document is a wish. Unless it shapes tests, tool permissions, and release rules, an agent will not reliably honor it.
- Local speed creates global drag. Faster coding inflates review queues, integration failures, maintenance load, and features nobody needed.
- Accountability diffuses. When a discovery agent, a coding agent, a reviewer agent, and a human approver all touched a change, "the AI did it" becomes the default excuse. That is not governance.
- Learning stops at launch. Teams move to the next roadmap item the day a release ships. In an agentic world, launch is where the experiment begins.
The old question / The new question:
- Did we build the requested feature? / Did we solve the underlying need?
- Did the tests pass? / Did we prove the behaviors and risks that matter?
- Did the release succeed? / Did users benefit without unacceptable harm?
- Did the team hit its commitment? / Was the commitment worth making?
- Did we close the ticket? / What did we learn, and what happens next?
Typing Is the Task. Building the Application Is the Purpose.
There is a quiet trap at the heart of software engineering, and AI is about to make it much louder.
Developers love to build. We refactor because the code could be cleaner, optimize because it could be faster, and add one more capability because it would be elegant. Each step feels like progress.
Somewhere along the way, the reason the work started, a customer who needed something done, fades from view. The work becomes its own purpose, and it never ends.
That is how scope drift is born: not from carelessness, but from craftsmanship detached from purpose.
Figure 2. Task-led versus purpose-led development
Now hand that same instinct to an agent that never tires, never gets bored, and can refactor a thousand files overnight. A poorly bounded agent can keep doing unnecessary work long after the purpose is met, and do it brilliantly.
Typing is the task. Building the application is the purpose. Delivering the customer outcome is the point.
The Agentic PDLC is built to keep the purpose in front of every person and every agent:
- Every piece of work traces to a customer outcome. If it cannot, it does not start.
- Every stage has a gate and a named owner. Low-risk gates run automatically under policy; consequential ones wait for a person who asks: is this still serving the purpose?
- Every outcome has a finish line. Work stops when the outcome is proven, or when the evidence says the bet was wrong.
- Every decision has an owner. When something goes wrong, the answer is never "the AI did it." It is a named human who approved the step, with the evidence they relied on.
AI does not get blamed in this model, because AI is never the one accountable. A named person owns every gate, whether it runs automatically or waits for their approval.
Meet the Agentic PDLC
The Agentic PDLC is a product operating model in which humans and bounded AI agents collaborate across discovery, design, engineering, verification, release, operations, and continuous improvement, using shared product context, enforceable policy, and measurable outcomes.
Each word in the name is doing work: Agentic means software actors that pursue a bounded goal over many steps: planning, using tools, checking results, and deciding whether to continue or escalate. It does not mean autonomous by default. Autonomy is delegated selectively and can be taken back.
Product means more than code. The product is its behavior, data, integrations, user experience, security, economics, and the value customers get from it.
Lifecycle means a loop, not a line. Work can run in parallel, repeat, or return to an earlier decision when the evidence changes.
A New Unit of Work: The Outcome Hypothesis
In the delivery-centered world, the unit of work is a ticket. In the Agentic PDLC, it is an outcome hypothesis, a falsifiable bet about customer value with its guardrails attached:
For returning customers who abandon account setup after identity verification, reusing information they have already verified will raise completion, without increasing fraud, privacy exposure, accessibility failures, or support demand.
One hypothesis can spawn dozens of agent tasks, specs, code changes, and experiments. None of them, alone, counts as success. Success is the outcome, achieved inside the guardrails.
From Pipeline to Learning Loop
Figure 3. Agentic PDLC loop ยท 9 stages, each with its required artifact
The loop is a chain of evidence. Each stage may begin only when the artifact before it exists, and every cycle ends with a decision: expand, keep observing, revise, roll back, or retire. Killing a weak idea early counts as a win.
Delivery-centered SDLC / Agentic PDLC:
- Goal: Ship planned work / Produce and prove outcomes
- Unit of work: Ticket, feature, project / Outcome hypothesis with evidence
- Coordination: Handoffs and status meetings / Shared artifacts and policy-controlled execution
- Role of AI: A copilot for individuals / A bounded participant at every stage
- Requirements: Prose, interpreted by people / Executable intent, constraints, and evals
- Quality: A phase after coding / Continuous evidence about behavior and risk
- Governance: Approvals at milestones / Authority and evidence enforced throughout
- Done means: Merged and deployed / An evidence-backed product decision
- Accountability: Spread across teams / A named human owner plus attributable agent actions
Seven Design Principles
- Outcomes before outputs. No agent is dispatched to "build a feature" until someone can say whose problem it solves, what evidence supports it, how success is measured, which harms are unacceptable, and when to stop.
- Explicit intent before delegated execution. Ambiguity multiplied by autonomy produces fast, expensive failure. Every agent mandate names its objective, scope, exclusions, tools, budgets, required evidence, escalation triggers, and accountable owner.
- Evidence before confidence. Models write fluent explanations even when they are wrong. Completion is proven by reproducible artifacts, scaled to the cost of being wrong.
- Separate proposal from permission. The reasoning that decides what an agent wants to do must be architecturally separate from the mechanism that decides what it may do.
- Reversibility before autonomy. Delegate first where mistakes are cheap to spot and undo. Keep irreversible actions (schema migrations, payments, permission changes, customer communications) tightly gated.
- Least agency. Every tool, dataset, or minute of access an agent does not need is attack surface. Grant the narrowest capability that completes the task.
- Learn without uncontrolled self-modification. Agents may propose better prompts, tests, routes, and policies. Those changes are versioned, evaluated, and approved like any other release. Self-improvement never bypasses governance.
Inside the Loop: Agents Execute, Humans Decide
At every stage, agents take on the heavy lifting of synthesis, drafting, and execution, while humans keep the decisions that require legitimacy. Each stage ends with a named artifact, and that chain of artifacts is what makes the whole system auditable.
Stage / What agents do / What humans decide / Artifact produced:
- 1 Observe: Cluster interviews, tickets, usage, incidents, and churn notes, linked to sources / Is the signal representative, or just loud? / Opportunity brief
- 2 Frame: Draft competing problem statements and cheap experiments / Is this worth solving? Is "do nothing" better? / Outcome hypothesis with kill criteria
- 3 Specify: Turn the hypothesis into an intent contract and starter evals / Scope, non-goals, risk boundaries / Product intent contract
- 4 Explore and design: Compare architectures, map dependencies, draft threat models and costs / Long-lived trade-offs and trust boundaries / Decision record
- 5 Build: Implement in sandboxes with task-scoped credentials; open pull requests / Consequential diffs and escalations / Change set with provenance
- 6 Verify: Run deterministic checks
Comments
No comments yet. Start the discussion.