.svg)
Abstract
This paper examines the relationship between specification-driven development (SDD) and agile methodology in the context of artificial intelligence-assisted software engineering. Contrary to emerging concerns that SDD represents a regression to waterfall methodologies, this analysis demonstrates that specification-driven approaches fundamentally enhance agile practices by dramatically reducing the cost of iteration. Through examination of current industry implementations, empirical data on development efficiency, and analysis of legacy system modernization patterns, this paper argues that SDD enables the full realization of agile principles by removing traditional technical constraints on iterative development. The findings suggest that when implementation costs approach zero through AI-assisted code generation, detailed specifications become enablers rather than inhibitors of organizational agility.
Introduction
The emergence of specification-driven development in artificial intelligence-assisted software engineering has generated substantial debate regarding its compatibility with agile methodologies. Critics have raised concerns that the emphasis on detailed specifications represents a return to waterfall-style development practices, citing examples such as Amazon's Kiro system generating sixteen acceptance criteria for simple bug fixes and GitHub's Spec Kit producing extensive documentation artifacts.[1] However, this perspective fails to recognize a fundamental transformation in the economics of software development: when artificial intelligence can regenerate entire codebases from updated specifications within minutes rather than months, the relationship between documentation and agility undergoes a categorical shift.
This paper contends that specification-driven development represents the agile methodology's natural evolution in an era of AI-assisted programming.
Theoretical Framework: The Economics of Software Iteration
Historical Constraints on Agile Implementation
The Agile Manifesto's [3] prioritization of "responding to change over following a plan" emerged from recognition that traditional development methodologies imposed prohibitive costs on initial application development and subsequent modification by prioritizing and front-loading the creation of immutable requirements before any code could be written. The resultant software product was, therefore, engineered to solve the needs of the business as they existed at a previous point in time – the point when the requirements were captured – rather than evolving to match the ongoing needs of the business.
Maintaining agility becomes a significant challenge in enterprise environments tasked with managing large-scale legacy systems due to poor understanding of the systems’ existing functionality accruing from a lack of comprehensive specifications, unavailability of developers who have been present through the systems’ lifecycle, and accumulated technical debt. For these same reasons, traditional approaches to modernizing legacy systems have required extensive documentation efforts, sometimes spanning twelve to eighteen months before any development could commence.[6] This preliminary phase effectively negated agile methodology's advantages, forcing organizations to choose between comprehensive understanding and rapid iteration — a false dichotomy that specification-driven development resolves.
The Transformation of Specification Economics
Modern specification-driven development tools fundamentally alter the cost structure of software modification. When platforms such as GitHub's Spec Kit enable developers to modify specifications through simple markdown file updates, and when artificial intelligence agents can regenerate implementations from these updated specifications, the traditional relationship between documentation and flexibility inverts.[4,5] Specifications transition from static, immutable artifacts that constrain development to dynamic, “living” documents that facilitate rapid experimentation.
The empirical evidence supports this transformation. Our analysis demonstrates that CoreStory’s intelligence models can analyze hundreds of thousands of lines of legacy code in minutes, compared to eighteen months through manual processes. This reduction in specification generation time from months to minutes fundamentally changes the viability of iterative approaches to complex system modernization. When extracting accurate specifications from existing code becomes a matter of minutes rather than months, development teams can begin iterative cycles immediately rather than deferring them until after extended analysis phases.
Empirical Analysis: Specification-Driven Development in Practice
Quantitative Improvements in Development Efficiency
Research conducted by CoreStory in collaboration with Microsoft demonstrates that structured specifications improve AI agent accuracy by fifty-one percent.[10] While critics interpret this as evidence of AI limitations, the finding actually illustrates the enabling effect of specifications on iterative development. Even with forty-nine percent imperfection, when the cost of regeneration approaches zero, development teams can afford multiple iterations to achieve desired outcomes. This represents a fundamental shift from traditional development, where the cost of iteration imposed strict limits on experimentation.
The Standish Group's Chaos Report provides additional context, documenting that waterfall projects experience a forty-nine percent failure rate compared to agile projects' ten to eleven percent failure rate.[2] These statistics, however, reflect pre-AI development paradigms. When specification-driven development reduces implementation time by multiple orders of magnitude, the economics that produced these differential failure rates no longer apply.
The Evolution of Legacy System Modernization
Large enterprise codebases present a particular challenge for agile methodologies. These systems, often decades old, typically possess specifications that have diverged significantly from their actual implementation through years of patches, emergency fixes, and undocumented modifications. This specification drift has historically made these systems resistant to agile approaches, as teams cannot iterate effectively without understanding current system behavior.
Platforms like CoreStory, that can reverse-engineer accurate specifications from production code resolve this impediment. When development teams can extract current, accurate specifications from existing systems in minutes, they gain the ability to apply agile methodologies to previously intractable legacy modernization projects. The specification becomes an auto-generated artifact rather than a manually constructed one, enabling immediate iteration rather than extended analysis.
Furthermore, the emergence of "living specification" capabilities, where documentation automatically synchronizes with code changes, addresses the perpetual challenge of documentation obsolescence. These systems transform specifications from static snapshots that deteriorate over time into continuously updated representations of system state. This evolution aligns perfectly with agile methodology's preference for working software over comprehensive documentation—the documentation exists precisely to the extent needed to generate working software.
Addressing Critical Objections
The Waterfall Comparison
Critics who equate specification-driven development with waterfall methodology commit a fundamental error. Waterfall's failure stemmed not from the existence of specifications but from their immutability once created. The expense of modifying specifications in waterfall projects created lock-in effects that prevented adaptation to changing requirements. In contrast, modern specification-driven development treats specifications as mutable, low-cost artifacts that can be modified as frequently as needed by leveraging tools like CoreStory.
Martin Fowler's team observed that Kiro generated five thousand lines of code for functionality that could be implemented in eight hundred lines.[1] In traditional development paradigms, this would represent significant waste. However, when generation costs approach zero, such verbosity merely becomes one more iteration in the agile process. Development teams can generate the verbose version, test it, identify necessary functionality, update specifications, and regenerate optimized code—all within timeframes shorter than traditional initial implementation.
Developer Skill Evolution
Concerns about developer deskilling, exemplified by one practitioner's observation that specification-driven development made them feel "like a PM, not an engineer," reflect a misunderstanding of how technical roles evolve with technological advancement.[9] The shift from implementation to specification represents an elevation of developer focus toward system architecture and design rather than syntax and boilerplate code generation.
Stack Overflow's 2025 Developer Survey reveals that forty-six percent of developers distrust AI accuracy, yet forty-seven percent use AI tools daily.[10] This apparent contradiction resolves when recognizing that developers need not trust AI to generate perfect code, only code sufficient for rapid iteration and refinement. The skill set evolves from writing bug-free implementations to recognizing which generated implementations serve business requirements — a higher-order capability that enhances rather than diminishes technical expertise.
Implications for Software Engineering Practice
Redefining Iteration Cycles
Specification-driven development enables a fundamental reconceptualization of agile sprint cycles. Traditional sprints accommodated single major iterations due to implementation constraints. With AI-assisted generation from specifications, teams can explore multiple implementation variants within single sprints, conducting A/B testing and user validation on different approaches before committing to specific solutions. This multiplication of iteration capacity within fixed time intervals represents the full realization of agile methodology's iterative philosophy.
The complaint from Thoughtworks engineers that specification-driven development requires "one to two hours of upfront specification work per medium feature" inadvertently highlights the transformation's magnitude.[1] When two hours of specification work replace twenty to forty hours of implementation effort, the economics of iteration transform completely. Even accounting for review and refinement of generated code, the reduction in iteration cost enables experimentation at scales previously impossible.
Organizational Implications
The integration of specification-driven development into agile frameworks requires organizational adaptation. Sprint planning evolves from estimating implementation effort to designing specification experiments. Daily standups shift focus from implementation blockers to specification refinements. Sprint reviews demonstrate multiple working variants rather than single implementations. These changes represent not abandonment of agile practices but their evolution to leverage new technological capabilities.
Research indicates that forty-two percent of projects fail due to unclear objectives, while seventy percent of digital transformation projects fail overall.[9] These failures often stem from inability to iterate rapidly enough to discover effective solutions. When specification-driven development enables rapid generation and testing of multiple approaches, organizations can explore solution spaces more thoroughly before committing resources to specific directions.
Conclusion
Specification-driven development does not represent a return to waterfall methodology but rather the removal of technical constraints that have historically limited agile methodology's effectiveness in large-scale enterprise software development initiatives, especially legacy systems modernization and maintenance. When artificial intelligence can generate implementations from specifications in minutes rather than months, the cost of iteration approaches zero, enabling true responsiveness to changing requirements.
The empirical evidence demonstrates that specification-driven development enhances rather than constrains agility, particularly in complex domains such as legacy system modernization where traditional agile approaches face significant obstacles. As specification platforms evolve to maintain synchronization between documentation and code automatically, they fulfill agile methodology's vision of just-enough, just-in-time documentation that enables rather than impedes development.
The transformation requires reconceptualizing specifications not as immutable contracts but as mutable hypotheses that can be rapidly tested and refined. When viewed through this lens, specification-driven development represents not the death of agile methodology but its acceleration beyond human-scale constraints. The question facing software engineering is not whether specification-driven development threatens agile practices, but whether organizations can adapt quickly enough to leverage its potential for achieving unprecedented development agility.
References
[1] Fowler, M. (2025). Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl. Martin Fowler. https://martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html
[2] Mersino, A. (2020). Why Agile is Better than Waterfall (Based on Standish Group Chaos Report 2020). Medium. https://medium.com/leadership-and-agility/agile-project-success-rates-are-2x-higher-than-traditional-projects-376a05e590d4
[3] Beck, K., et al. (2001). Manifesto for Agile Software Development. Agile Manifesto. https://agilemanifesto.org/
[4] GitHub. (2025). Spec-driven development with AI: Get started with a new open source toolkit. GitHub Blog. https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/
[5] Grove, S. (2025). Quoted in "The Rise of Spec-Driven Development." Frontend at Scale. https://frontendatscale.com/issues/49/
[6] Business Wire. (2025, October 28). CoreStory Raises $32 Million Series A to Modernize the World's Legacy Software with AI for Code Intelligence. https://www.businesswire.com/news/home/20251028246851/en/
[7] Hacker News Discussion. (2025). Quoted in "Spec Driven Development (SDD) - A initial review." DEV Community. https://dev.to/danielsogl/spec-driven-development-sdd-a-initial-review-2llp
[8] Stack Overflow. (2025). 2025 Developer Survey Results. Stack Overflow. https://stackoverflow.blog/2025/01/09/the-2025-developer-survey-is-here/
[9] Requiment. (2025). Why Do Software Development Projects Fail? https://www.requiment.com/why-do-software-development-projects-fail/
[10] Hymel, C., et al. (2024). Improving Performance of Commercially Available AI Products in a Multi-Agent Configuration. arXiv preprint arXiv:2410.22129 [cs.SE] (2024). https://arxiv.org/abs/2410.22129
.png)
.png)