The AI-native SDLC: how agents reshape every phase from plan to deploy
A tour through the seven phases of the software development lifecycle where AI coding agents are changing how teams work — what to delegate, what to review, and what engineers still own.
AI coding tools have progressed far beyond autocomplete. Early tools suggested the next line. Chat interfaces enabled pair programming. Today’s agents generate entire features, scaffold projects, translate designs into code, and sustain multi-hour reasoning across dozens of files.
The implication isn’t that engineers are being replaced. It’s that the shape of engineering work is changing — and the teams that understand where agents fit in each phase of the SDLC will move faster than the ones that don’t.
OpenAI’s guide to building AI-native engineering teams lays out a framework organized around seven phases. Each phase has a pattern: what to delegate, what to review, and what to own.
The capability shift
Before diving into phases, it’s worth understanding what changed to make this possible. Four capabilities unlocked the transition from autocomplete to agent:
| Capability | What it enables |
|---|---|
| Unified context across systems | One model reads code, configuration, and telemetry — consistent reasoning across layers that needed separate tooling |
| Structured tool execution | Models call compilers, test runners, and scanners directly — verifiable results, not static suggestions |
| Persistent project memory | Long context windows and compaction let models follow features from proposal to deployment |
| Evaluation loops | Outputs tested against benchmarks — unit tests, latency targets, style guides — improvements grounded in measurable quality |
These capabilities mean agents can now participate in every phase, not just code generation. The task length frontier is roughly 2 hours of continuous work at 50% confidence, doubling every seven months.
Phase 1: Plan
What agents do: Read feature specifications, cross-reference against the codebase, flag ambiguities, break work into subcomponents, estimate difficulty, trace code paths to identify which services are involved.
What engineers review: Validate accuracy, assess completeness, ensure estimates reflect real constraints. Story point assignment, effort sizing, and identifying non-obvious risks still require human judgment.
What engineers own: Strategic decisions — prioritization, long-term direction, sequencing, trade-offs. Agents provide options; the organization decides.
Getting started: Identify common processes that require alignment between features and source code. Start with basic workflows like tagging and deduplicating issues. Graduate to adding sub-tasks based on feature descriptions, or triggering agent runs when tickets reach specific stages.
Phase 2: Design
What agents do: Scaffold boilerplate, build project structures, implement design tokens, convert mockups into components, suggest accessibility improvements, analyze code for user flows and edge cases.
What engineers review: Ensure components follow design conventions, meet quality and accessibility standards, and integrate with existing systems.
What engineers own: The overarching design system, UX patterns, architectural decisions, and final direction of the user experience.
Getting started: Use a multi-modal agent that accepts text and image input. Integrate design tools via MCP. Programmatically expose component libraries through MCP. Build workflows that map designs to components to implementation. Use typed languages (TypeScript) to define valid props and subcomponents for the agent.
Phase 3: Build
This is where agents have the clearest impact. Engineers spend significant time on mechanical work — translating specs into code structures, wiring services, duplicating patterns, filling in boilerplate.
What agents do: Draft entire feature implementations from a written spec. Search and modify code across dozens of files while maintaining consistency. Generate boilerplate matching conventions (error handling, telemetry, security wrappers). Fix build errors as they appear. Write tests alongside implementation. Produce diff-ready changesets with PR messages.
What engineers review: Design choices, performance, security, migration risk, domain alignment. Engineers shape and refine AI-generated code rather than performing the mechanical work.
What engineers own: New abstractions, cross-cutting architectural changes, ambiguous product requirements, long-term maintainability trade-offs.
Getting started: Start with well-specified tasks. Have the agent write a PLAN.md committed to the codebase. Check that agent commands are succeeding. Iterate on an AGENTS.md file that unlocks agentic loops (running tests and linters for feedback).
Phase 4: Test
What agents do: Suggest test cases from requirements documents and feature logic. Surface edge cases and failure modes engineers overlook. Keep tests updated as code evolves. Generate tests in a separate session from feature implementation for independent verification.
What engineers review: Ensure the model didn’t take shortcuts or implement stubbed tests. Verify tests are runnable by agents with appropriate permissions. Confirm context awareness of different test suites.
What engineers own: Aligning test coverage with specifications and user expectations. Adversarial thinking, creativity in mapping edge cases, and focus on test intent.
Phase 5: Review
On average, developers spend 2-5 hours per week on code reviews. Agents allow the review process to scale so every PR gets a consistent baseline of attention.
What agents do: Initial review pass — executing code, interpreting runtime behavior, tracing logic across files and services. Unlike static analysis tools, AI reviewers understand intent, not just patterns.
What engineers review: Architectural alignment, composable patterns, correct conventions, feature-to-requirements mapping. The engineer’s review shifts from “finding bugs” to “assessing design.”
What engineers own: Final review and merge decision. The code that deploys to production.
Getting started: Curate examples of gold-standard PR reviews as an evaluation set. Select a product with a model specifically trained on code review (generalized models nitpick and produce low signal-to-noise). Define quality metrics — PR comment reactions are a low-friction way to mark good and bad reviews.
Phase 6: Document
What agents do: Summarize functionality from code. Generate system diagrams in Mermaid. Update documentation on prompt. Generate release notes from commit history. Keep docs current as code evolves.
What engineers review: Overviews of core services, public API and SDK docs, runbooks, architecture pages — before publication.
What engineers own: Overall documentation strategy and structure, standards and templates agents follow, external-facing and safety-critical documentation.
Getting started: Experiment with documentation generation by prompting the agent. Incorporate documentation guidelines into AGENTS.md. Identify workflows (release cycles) where docs can be auto-generated. Review generated content for quality and correctness.
Phase 7: Deploy and Maintain
What agents do: Parse logs, surface anomalous metrics, identify suspect code changes by correlating errors with git history, propose hotfixes. With MCP access to logging tools, agents have a single workflow for investigation — no tab switching between systems.
What engineers review: Vet AI-generated diagnostics, confirm accuracy, approve remediation steps, ensure fixes meet reliability and security standards.
What engineers own: Novel incidents, sensitive production changes, situations where model confidence is low. Humans remain responsible for judgment and final sign-off.
Getting started: Connect agents to logging and deployment systems via MCP. Define access scopes and permissions. Create reusable prompt templates for common operational queries. Test with simulated incident scenarios.
The delegate-review-own pattern
Every phase follows the same structure. It’s worth internalizing:
- Delegate — The agent takes the first pass. It does the mechanical, high-volume work that would take a human hours.
- Review — The engineer validates, corrects, and refines. The work shifts from production to judgment.
- Own — Strategic decisions, novel problems, and final sign-off remain human. Agents provide leverage, not autonomy.
Teams that start with well-scoped tasks, invest in guardrails (AGENTS.md, evaluation sets, MCP wiring), and iteratively expand agent responsibility see meaningful gains. The shift doesn’t require a radical overhaul — small, targeted workflows compound as agents become more capable.
Every phase follows delegate-review-own
Agents take the first pass on mechanical work. Engineers validate and refine. Strategic decisions and final sign-off remain human. The pattern holds across all seven phases.
Build phase has the clearest impact
Full features end-to-end — data models, APIs, UI, tests, docs — in a single coordinated run. The agent becomes the first-pass implementer; the engineer becomes the reviewer.
Tests become the specification
As agents remove barriers to generating code, high-quality tests are the source of truth for application behavior. Define tests first, let the agent build to them.
Start small, compound fast
Well-scoped tasks with guardrails (AGENTS.md, eval sets, MCP wiring) compound as agents improve. The capability frontier doubles every seven months.
The job changes, it doesn't disappear
Engineers shift from line-by-line implementation to iterative oversight — clarifying specs, reviewing architecture, refining business logic, designing guardrails.