The rise of coding agents leads us to consider a methodology where the specification becomes the source of truth and where test suites serve as safeguards. The approach promises speed and rapid iterations, but it runs into very real gray areas, from legacy to the ambiguities of natural language. From this shift could be born an “agentic manifesto”.
Structuring limits: language, legacy, costs and interfaces
Edsger W. Dijkstra argued that English is too ambiguous to correctly specify a software application. The specification is considered necessary, but probably insufficient to define software. Not knowing the code could prove problematic during a critical incident detected in the middle of the night, even if a coding officer could correct faster than a human. The approaches outlined would mainly target greenfield contexts, while a large existing code base would likely limit their methodological impact, a point which remains to be verified. These agents are not free: costs will have to be measured, even if the author suspects that they will fall, invoking Moore’s law and its derivatives. The front-end/back-end boundary should be reworked. Customers probably wouldn’t accept appearance changes with each iteration; thinner clients and a larger back-end are anticipated. Front-ends, more sensitive to human preferences, will have to combine flexibility and consistency, an area considered already rather well mastered today. Finally, aspects such as appearance, security, performance and accessibility remain difficult to formalize precisely in a specification and will require sustained human effort.
A new bottleneck: customer returns
In a methodology refocused on the specification, updating the latter according to feedback could become the blocking point. In-depth customer interviews could be recorded and AI could derive updates to the specification. Targeted use of AI would speed up writing, to the point of shifting the bottleneck to obtaining and validating feedback. Customers could then get tired of a tempo perceived as too fast and demanding in terms of availability.
Generative testing: towards a definition of the application by coverage
Coding agents could produce massive test suites covering the entire implementation, allowing rebuilds at each iteration as long as the tests pass. If unit, integration, and end-to-end testing covered the entire specification, they could be the very definition of the application. Agentic coding is presented as capable of realizing the ambition of test-driven development. The author sees no reason to deprive oneself of such generation of tests and questions the benefit of focusing on new implementations in the presence of complete coverage. An exhaustive suite would also facilitate the transition from development to maintenance, and an agent would not mind writing more.
Deciphered AI dev tools, agents and new features, every evening in 5 minutes. Free.
Included upon registration: our selection of the best AI guides & comparisons.
Choose your pace
Free · No spam · Unsubscribe in 1 click
Four ways of implementation with non-deterministic agents
Several implementation strategies are considered after updating the specification. The first consists of throwing away each version and rebuilding from scratch, an option considered risky due to the non-deterministic nature of the agents but potentially viable. The second applies the new specification to the previous implementation by updating it incrementally, an approach close to current practices. A hybrid path asks the agent to examine the existing, read the new specification and redesign the application in light of its learnings and feedback. Finally, it is proposed to simultaneously test these paths and retain the preferred one, the massive use of agents being assimilated to an unlimited workforce, in a “competition” logic to identify the best solution.
Specification-centric process and document governance
Two process variants are proposed. The first links specification, customer validation, construction by agent, feedback, updating of the specification and iterations until satisfaction, with explicit validation by the customer of the specification and implementation. The second removes the client’s visibility of the specification and only presents a functional application, while considering the specification, and not the code, as the source of truth. The approach combines a requirement for accuracy of the specification (close to Waterfall) and iterations with feedback (Agile principle), and joins development based on the specification. However, it clashes with a value of the Agile manifesto (“Functional software rather than complete documentation”), the relevance of which is questioned if the software can be generated quickly, to the point of blurring the boundary between executable and documentation. If the specification becomes the object of iteration, it can be seen as the source code while the generated code is similar to machine code. This centrality suggests version control of the specification, with pull requests and reviews, and questions the need for version control of the code if each iteration reimplements the application.
Agile, Waterfall and the thesis of a changeover made possible by agents
The Waterfall process was based on an exhaustive specification transmitted to development, then to testing, before delivery, with costly and formalized changes. Deemed ineffective, it was supplanted by the rise of Agile, driven by a manifesto co-written by software figures, popularizing Scrum and other frameworks, while fueling countless debates to the point of making Waterfall a legacy to be abandoned. The author argues that implementation, which has become easy, no longer constitutes the bottleneck, which would require an in-depth review of the process. It outlines a possible return to Waterfall if the specification defines the application and if an agent can generate the code in a few hours or days, by moving the iteration on the specification, according to Agile logic applied to the document. This thesis is posed in a context of uncertainties about the future of Agile, the supposed power of coding agents and a transformation perceived as major, to the point of questioning the role of the human developer and imagining the emergence of an “agentic manifesto”.

