Towards an Agentic Manifesto for Software Development

The rise of coding agents leads to a methodology where the specification becomes the source of truth and test suites serve as safeguards. This approach promises speed and rapid iterations, but it encounters real gray areas, from legacy systems to ambiguities in natural language. From this shift could emerge an "agentic manifesto."

Structuring Limits: Language, Legacy, Costs, and Interfaces

Edsger W. Dijkstra argued that English is too ambiguous to properly specify a software application. While specification is deemed necessary, it is likely insufficient to define software. Not knowing the code could become problematic during a critical incident detected in the middle of the night, even if a coding agent could fix it faster than a human. The outlined approaches would primarily target greenfield contexts, while a large existing codebase would likely limit their methodological impact, a point that remains to be verified. These agents are not free: costs will need to be measured, although the author suspects they will decrease, invoking Moore's Law and its derivatives. The front-end/back-end boundary should be reworked. Clients would likely not accept appearance changes with every iteration; lighter clients and a more substantial back-end are anticipated. Front-ends, being more sensitive to human preferences, will need to balance flexibility and consistency, a domain already considered 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 Feedback

In a methodology refocused on specification, updating it based on feedback could become the bottleneck. In-depth interviews with clients could be recorded, and AI could derive updates to the specification from them. Targeted use of AI would accelerate writing to the point of shifting the bottleneck to obtaining and validating feedback. Clients might then grow weary of a pace perceived as too fast and demanding in terms of availability.

Generative Testing: Towards Defining the Application by Coverage

Coding agents could produce extensive test suites covering the entire implementation, allowing for reconstructions at each iteration as long as the tests pass. If unit, integration, and end-to-end tests covered the entirety of the specification, they could constitute the very definition of the application. Agentic coding is presented as capable of fulfilling the ambition of test-driven development. The author sees no reason to forgo such test generation and questions the value 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 hesitate to write more.

Four Implementation Paths with Non-Deterministic Agents

Several implementation strategies are considered after updating the specification. The first involves discarding each version and rebuilding from scratch, an option deemed risky due to the non-deterministic nature of agents but potentially viable. The second applies the new specification to the previous implementation by updating it incrementally, an approach similar to current practices. A hybrid path asks the agent to examine the existing code, read the new specification, and redesign the application in light of its learnings and feedback. Finally, it is proposed to test these paths simultaneously and select the preferred one, with the extensive use of agents being likened to an unlimited workforce, in a "competition" logic to identify the best solution.

Specification-Centered Process and Document Governance

Two variants of the process are proposed. The first links specification, client validation, agent construction, feedback, specification updates, and iterations until satisfaction, with explicit client validation of both the specification and implementation. The second removes client visibility on the specification and presents only a functional application, while considering the specification, not the code, as the source of truth. This approach blends a requirement for accuracy in the specification (similar to Waterfall) with iterations that incorporate feedback (the Agile principle), aligning with specification-driven development. However, it clashes with a value of the Agile manifesto ("Working software over comprehensive documentation"), the relevance of which is questioned if software can be generated quickly enough to blur the line between executable and documentation. If the specification becomes the subject of iteration, it can be viewed as the source code while the generated code resembles machine code. This centrality suggests version control of the specification, with pull requests and reviews, and raises questions about the necessity of version control for the code if each iteration re-implements the application.

Agile, Waterfall, and the Thesis of a Shift Made Possible by Agents

The Waterfall process relied on a comprehensive specification handed over to development, then testing, before delivery, with costly and formalized changes. Deemed inefficient, it has been supplanted by the rise of Agile, driven by a manifesto co-authored by software figures, popularizing Scrum and other frameworks, while fueling countless debates until Waterfall became a legacy to abandon. The author argues that implementation, now made easy, is no longer the bottleneck, which would necessitate a profound reevaluation of the process. A possible return to Waterfall is sketched if the specification defines the application and if an agent can generate the code in a few hours or days, shifting the iteration to the specification, in an Agile logic applied to the document. This thesis is posed in a context of uncertainties about the future of Agile, the presumed power of coding agents, and a perceived major transformation, questioning the role of the human developer and imagining the emergence of an "agentic manifesto."