I wrote about how product engineering is replacing the PM/Eng split. The interface between “what to build” and “how to build it” is dissolving as specs become executable and engineers talk directly to users.

But that’s not the only thing collapsing.

OpenAI recently published a guide on building “AI-native engineering teams” that walks through each phase of the software development lifecycle: Plan, Design, Build, Test, Review, Document, Deploy. Reading it, one thing becomes clear: the phases themselves are blurring together.

Why the SDLC Had Phases

Traditional software development separated concerns into distinct stages. Plan with PMs, design with architects, build with engineers, test with QA, review with peers, document for posterity, deploy with ops. Each phase had specialists, handoffs, and gates.

This made sense when:

  • Context transfer was expensive: Each specialist needed time to understand the work
  • Execution was slow: Writing code, tests, and docs took significant human hours
  • Coordination required meetings: Aligning across phases meant scheduling

The phases weren’t arbitrary. They reflected the reality that humans can only hold so much context, and handing off between specialists was more efficient than having one person do everything.

What Changed

Models can now sustain multi-hour reasoning. METR found that leading models complete over 2 hours of continuous work with 50% confidence of a correct answer. A few years ago, that number was 30 seconds: enough for autocomplete, not much else.

The entire software development lifecycle is potentially in scope for AI assistance, enabling coding agents to contribute effectively to planning, design, development, testing, code reviews, and deployment.
— OpenAI, Building an AI-native engineering team

When agents can reason across the full lifecycle, the phase boundaries start to dissolve:

  • Planning and building merge: Agents read specs, map them to code, identify dependencies, and surface ambiguities in one pass
  • Design and implementation overlap: Agents scaffold projects, generate boilerplate, and translate mockups to components while you’re still iterating on concepts
  • Building includes testing: Agents write tests alongside implementation as part of a single workflow
  • Review becomes continuous: Every PR gets AI review before human eyes see it
  • Documentation happens inline: Agents update docs as they build, not as a separate phase

The phases don’t disappear. But the hard handoffs between them do.

The OpenAI Guide, Distilled

OpenAI’s guide covers each SDLC phase with a consistent pattern: what agents can do, what engineers do instead, and a delegate/review/own breakdown. Here’s the essential takeaway from each:

Plan: Agents take the first pass at feasibility analysis. They read specs, trace code paths, identify dependencies, and estimate difficulty. Engineers review findings and own strategic decisions like prioritization and sequencing.

Design: Agents scaffold projects, generate boilerplate, translate mockups to components, and apply design systems. Engineers focus on architectural patterns, UX decisions, and quality standards.

Build: Agents draft full feature implementations: data models, APIs, UI, tests, and documentation in one coordinated run. Engineers shift from writing code to reviewing it, focusing on correctness, security, and long-term maintainability.

Test: Agents suggest test cases based on specs and code logic, surfacing edge cases humans might overlook. Engineers own aligning coverage with requirements and maintaining adversarial thinking about failure modes.

Review: Every PR gets consistent AI review that can execute code and trace logic across files. Engineers still own the final merge decision, focusing on architectural alignment and whether functionality matches requirements.

Document: Agents generate summaries, dependency lists, and even system diagrams. Engineers shape the documentation strategy and review critical or customer-facing content.

Deploy & Maintain: Agents parse logs, surface anomalies, identify suspect commits, and propose hotfixes. Engineers validate diagnostics, approve remediation, and own novel incidents.

The pattern that holds

Across every phase, the same framework applies: Delegate mechanical work to agents, Review for accuracy and alignment, Own the judgment calls. The phases blur, but this pattern survives.

What This Means Practically

The shift has concrete implications for how you work:

  • Fewer handoffs, more checkpoints: Instead of passing work between specialists at phase boundaries, you review agent output at natural breakpoints within continuous flow
  • Context stays unified: One agent session can span planning through implementation through testing, maintaining context that would be lost in traditional handoffs
  • Specialists become reviewers: The QA engineer doesn’t disappear, but their role shifts from writing tests to reviewing agent-generated tests and owning coverage strategy
  • Documentation stops being an afterthought: When agents can update docs inline with code changes, “we’ll document it later” stops being the default

The OpenAI guide frames this as agents becoming “first-pass implementers” while engineers become “reviewers, editors, and sources of direction.” That’s accurate, but it understates the change. When agents handle first passes across all phases, the engineer’s role becomes orchestration and judgment across the entire lifecycle, not just the build phase.

What Doesn’t Collapse

Some things remain distinctly human:

  • Strategic product vision: What market to enter, what problem to solve, why customers care
  • Novel architecture: New abstractions and cross-cutting changes that require deep system intuition
  • Ambiguous requirements: When the spec is unclear, agents can’t resolve the ambiguity themselves
  • Ethical judgment: Decisions about data, privacy, and impact that carry moral weight
  • Final accountability: Engineers own what ships, regardless of who (or what) wrote the code
The judgment layer doesn't automate

The phases collapse because mechanical execution is automatable. Judgment isn’t. As more execution moves to agents, the value of human judgment increases, not decreases.

The 90/90 rule still applies

The first 90% of the code takes 90% of the time. The remaining 10% takes the other 90%. Agents accelerate the first pass, but the long tail of edge cases, integration issues, and iterative refinement remains long and highly iterative. The phases collapse; the iteration doesn’t.

The New Shape

The traditional SDLC was a pipeline: work flowed through sequential phases with gates and handoffs. The emerging model is more like continuous flow with human checkpoints.

This mirrors what happened with DevOps. The wall between Dev and Ops dissolved into continuous integration and deployment. Now the walls between Plan/Design/Build/Test/Review/Document/Deploy are dissolving into continuous agent-assisted flow with human oversight at judgment points.

Just as product engineering emerged from the PM/Eng collapse, a new model is emerging from the SDLC collapse. The question isn’t which phase you’re in. It’s what needs delegation, what needs review, and what needs human ownership.

The phases were always just a way to organize work around human limitations. As those limitations shift, so does the organization.

The core insight is simple: agents don’t just help with coding. They help with the entire lifecycle. And when they do, the lifecycle itself changes shape.

Read the full guide

OpenAI’s Building an AI-native engineering team guide is worth reading if you’re thinking about team-level adoption. It includes getting-started checklists for each SDLC phase and case studies from Cloudwalk, Sansan, and Virgin Atlantic.

Related Posts