An AI-native SDLC: from prompt to production in seven stages
What actually happens when you certify a feature — the seven stages, the hand-offs, and where you sign off.
Dual7's AI-native SDLC takes a feature from prompt to production in seven stages — requirements, plan, UX, schema, stories, build and publish — each producing an artifact a human can inspect, with mandatory sign-off before anything ships. Here is the pipeline, stage by stage.
1 · Requirements
Your prompt and any uploaded docs become a structured spec — roles, flows, acceptance criteria, edge cases. Ambiguity is surfaced as questions, not guessed. You approve the scope before a line is written.
2 · Plan
The architecture and delivery sequence are designed — which components, which data flows, in what order — so the build is planned, not improvised. You review the approach and its trade-offs.
3 · UX
Flows and wireframes are mapped for every screen, and the interface is produced against your design tokens: layout, components, states, responsive behavior — on-brand and accessible, not generic boilerplate.
4 · Schema
The Postgres data model is designed with multi-tenant isolation (schema-per-tenant plus row-level security) by default. Migrations are generated and reviewable — never silent drops.
5 · Stories
Every requirement becomes a user story with acceptance criteria, so 'done' is defined before code exists. Coverage is reviewed — nothing gets built that traces to no requirement.
6 · Build
The code is generated against the plan, schema and stories — pages wired to real state, typed API clients with proper secret hygiene — then validated and security-audited: authorization on every route, tenant isolation, input validation, dependency checks. The diff and the security report go to a human; sign-off is mandatory.
7 · Publish
The green build ships through your Git to your cloud — certified code in your repo, a release record, and an audit trail that traces every line back to intent. Final sign-off happens here.
What each stage produces — and who signs off
| Stage | What's produced | Who signs off |
|---|---|---|
| 1 · Requirements | Structured spec: roles, flows, acceptance criteria, edge cases | You approve scope |
| 2 · Plan | Architecture and delivery sequence | You review the approach |
| 3 · UX | Flows, wireframes, on-brand screens | You review the experience |
| 4 · Schema | Tenant-isolated Postgres model + reviewable migrations | Migration approval gate |
| 5 · Stories | User stories with acceptance criteria | Coverage review |
| 6 · Build | Validated, security-audited code + security report | Mandatory human sign-off |
| 7 · Publish | Release through your Git, audit trail, release record | Final sign-off |
This is the pipeline behind Governed Mode — and why the output of certification is code that passes review rather than code that needs one. The reasoning for splitting the work across specialists in the first place is covered in multi-agent AI coding.
From intent to production, in seven stages. That's the 7 in Dual7.
Frequently asked questions
What is an AI-native SDLC?
An AI-native software development lifecycle is a development process designed around AI agents doing the production work — with the classic SDLC's structure (requirements, design, build, review, release) preserved as explicit stages, artifacts and human approval gates, rather than collapsed into a single generate step.
Where do humans sign off in Dual7's pipeline?
At every gate that carries risk: scope approval after Requirements, architecture review after Plan, migration approval at Schema, a mandatory sign-off on the diff and security report at Build, and final sign-off at Publish. Nothing reaches production without a human approving it.
Do all seven stages run every time?
Certification runs the full pipeline per feature — that's what makes the result trustworthy. Work that's still exploratory stays in Vibe Mode with no gates at all; you only pay the rigor cost when a feature is ready to ship.
Related posts