An Agentic SDLC Built to Multiply Throughput, Not Replace Engineers
Executive Summary
Most software teams still build the way they did before AI agents existed. Work moves from a PRD to epics and stories, through sprints, QA, and release, and every step is done by hand. Each hand-off depends on the person who wrote the last artifact, and knowledge of how the process really works lives in people's heads.
Alethea, a technology organization, set out to change that by moving its software development lifecycle to an AI-first workflow built on Claude. Alethea's Chief Product and Technology Officer had already built an early end-to-end pipeline himself, starting from a Claude skill that interviews the user and produces a PRD. Tech Holding embedded a consultant with Alethea's product and engineering leadership to turn that starting point into a structured, documented Agentic SDLC that the whole team could use.
The result is a 13-step pipeline, from PRD through feature specification, data modeling, implementation, and release, packaged as a Claude Code plugin with a command for each step. Each of the 13 skills comes with its own validators and templates, so every step produces a consistent artifact that feeds the next. Alethea shipped its first project built with the pipeline to production, still uses the pipeline as its standard development process, and owns the full skill library, process documentation, role-specific training guides, and walkthrough videos. That first production project was delivered in about one month, against the team's own estimate of six months, and a PRD that used to take a product manager about a week now takes about a day.
The Problem: A Manual Process That Could Not Scale
Alethea's process worked. Teams received a high-level initiative, internally called a "big rock," aligned on design and a PRD up front, broke the work into epics and user stories, ran two-week sprints, and carried it through QA, deployment, and post-launch monitoring. The problem was not that the process was broken. It was that every stage relied on manual effort:
- Manual, time-intensive stages: every step from PRD through deployment was done by hand, which slowed velocity and made the quality of hand-offs between phases inconsistent. A solid PRD alone typically took a product manager about a week.
- No shared agent or skill library: early AI experiments lived with individuals rather than in a common repository, so the organization built no lasting AI leverage.
- Fragility in AI-generated code: Alethea's own experiments showed that unstructured AI coding tended to introduce regressions quickly, which made human oversight and built-in checks a requirement.
- Undocumented process knowledge: how the team actually worked was informal and unwritten, so it could not scale and new hires could not onboard quickly.
The result was a capable team whose output was capped by how much manual work each person could get through in a sprint.
Solution: An Agentic SDLC Built Around the Team
Tech Holding embedded one Agentic SDLC consultant with Alethea's product and engineering leadership. Rather than imposing a fixed template, the consultant started from how Alethea already worked, and from the pipeline its CPTO had already prototyped, and built the agentic version of that process with the people who would run it.
- Process Mapped – Working sessions with Alethea's product and engineering leadership defined a 13-step flow, starting with the PRD and moving through feature specification, data modeling, implementation, and release.
- Owners and Approvals Defined – Each step was documented with what it produces, who owns it, who approves it, and which earlier steps it depends on, so people stay in control of what moves forward.
- Skills and Agents Built – The team built 13 Claude skills, each with validators and templates, along with orchestrator and implementation sub-agents that carry work from one step to the next.
- Packaged as a Plugin – The full pipeline was packaged as a Claude Code plugin with a command for each step, so anyone on the team can install it and run the process the same way.
- Shipped to Production – Alethea ran its first project through the full pipeline and shipped it to production. The team still runs new work through the pipeline, and the artifacts each project produces, from PRD to code, live in their own repositories alongside it.
- Documentation and Handoff – Tech Holding delivered process documentation, a skill and agent user guide, role-specific training guides, and three short walkthrough videos, all published to Alethea's Confluence.
Product Management
Product managers start a new feature by describing it to Claude. An interview-driven PRD skill draws out the requirements and produces a PRD, which becomes the validated input to the feature specification step.
Engineering
Engineers run the design, data modeling, and implementation steps in Claude Code. Orchestrator and implementation sub-agents write the code and tests, and engineers shift from writing code to reviewing it, with validators checking each step's output before it moves on.
QA & Release
QA and release owners run the test and release steps with the same skill-and-validator pattern, so every build reaches them as a consistent, reviewable artifact.
Version-Controlled and Owned by Alethea
The pipeline, skills, and step ordering live in a GitHub repository that Alethea owns, so the team can update, extend, and maintain the process the same way it maintains code.
Results at a Glance
6× faster delivery to production: 1 month vs. a 6-month estimate | 1 day to produce a PRD, down from about a week | 13 pipeline steps, each with its own Claude skill | 3 role-specific training guides |
Before the engagement, Alethea's team estimated that its first project on the new process would take about six months. Run through the Agentic SDLC, it was delivered and shipped to production in about one month, roughly six times faster, and the team has kept using the pipeline for new work since. The gains show up at every stage: a PRD that used to take a product manager about a week now takes about a day, and each later step starts from a validated artifact instead of a blank page.
Just as important, the process now belongs to Alethea. Every step has a named owner and approver, every skill has validators that catch problems before they reach the next step, and the whole pipeline is documented, versioned, and installable as a single plugin.
Benefits
- Faster Stage-by-Stage Execution: agents produce the first draft of each artifact, from the PRD onward, so each step takes a fraction of the manual effort.
- People Stay in Control: every step has a human owner and approver. Agents propose; people decide what moves forward.
- Consistent Hand-offs: validators and templates on every skill mean each step produces a standard artifact that feeds the next, cutting rework and regressions.
- Role-Specific Enablement: product, engineering, and QA/release each have their own training guide, backed by short videos showing agent interactions and expected outputs.
- Documented, Repeatable Process: process documentation, a skill user guide, and a single installable plugin make the process easy to maintain and fast to teach new hires.
Tools & Technologies Used
- Claude Code: runs the 13-step pipeline as a plugin, with a command for each step and orchestrator and implementation sub-agents.
- Claude skills: 13 custom skills, each with validators and templates, that encode Alethea's process from PRD through release.
- GitHub: version-controlled home for the pipeline and skill library, and for the artifacts each project produces.
- Confluence: home for the process documentation, user guide, training guides, and walkthrough videos.
Our Partners
By using this site, you agree to thePrivacy Policy.