For over two decades, industry consensus held that agile methodologies had rendered the waterfall model obsolete due to its perceived slowness and rigidity. However, a convergence of technical capabilities in late 2025 has made this linear approach practical again for modern software engineering teams. The resurgence is not about reverting to heavyweight ceremonies but rather leveraging large language models (LLMs) with million-token context windows as high-speed execution engines within the traditional stages.
What Changed: From Autocomplete to Controlled Generation
The fundamental shift lies in moving from using LLMs merely for smart autocomplete or text generation to directing a probabilistic generator through strict stage-gated discipline. Previously, models lacked sufficient context and reasoning depth to handle complex system artifacts reliably without human intervention at every step.
Key Enablers
- Mega-Context Windows: Models can now ingest entire project repositories or large sets of architectural documents in a single session, allowing them to reason across dependencies rather than just local code snippets.
- High-Reasoning Modes: Extended-thinking capabilities allow models to spend more time deliberating on complex logic before generating output, significantly improving production-grade reliability.
- MCP and Tool Connectivity: The Model Context Protocol (MCP) provides a standardized interface for connecting these reasoning engines directly to data sources and operational tools.
- Whole-Corpus Reasoning: A single session can now coordinate tasks that previously required weeks of manual synchronization across different team members.
The Five-Stage Pipeline
The new workflow preserves the classical engineering sequence but accelerates each phase through LLM interaction. The engineer's role shifts from writing every line to managing context and validating outputs.1. Vision (30–60 minutes): Instead of lengthy requirement workshops, raw stakeholder notes are fed into an extended-context model session to synthesize a structured vision document defining core problems and success criteria.
2. Architecture Decisions (~2 hours): The system generates compact ADRs for major components based on the synthesized vision. Engineers review these, challenge gaps in reasoning, and iterate through high-reasoning modes to finalize artifacts before implementation begins.
Bubble-Sort Backtracking:
The most significant operational change is how errors are handled. In classic waterfall, backtracking was expensive; here it is cheap.If a fundamental flaw surfaces during prototyping or implementation, the team can roll back to an earlier stage—such as updating the vision document—and regenerate downstream artifacts like ADRs and code skeletons within hours rather than weeks. This low-cost correction loop encourages discovering problems early in the lifecycle.
- Architecture: Teams can afford more rigorous upfront architectural planning because correcting late-stage errors is no longer prohibitively expensive.
3. Prototypes (1–2 days):: Experimental code validates library compatibility and architectural feasibility quickly due to near-zero cost.
4. Architectural Skeleton (~2 hours): Validated prototypes are combined into a unified project structure, including modules and folder layouts.
Diamond Model Testing Strategy:
The final code generation phase emphasizes testing stability over source fidelity since the underlying artifacts can be regenerated. The recommended approach is to write minimal unit tests only where they add unique value, rely heavily on integration tests for broad coverage, and reserve end-to-end tests strictly for critical paths.What This Means For Practitioners
This evolution fundamentally alters the economics of software delivery. Platform teams must prepare to manage sessions that act as small engineering crews rather than simple chat interfaces.
This approach aligns well with the AI engineering pillar, where managing context and reasoning becomes a primary operational skill.
