Why feedback beats upfront specs

Series: Aigile deep dives, paper 01 of 09. Elaborates working paper Parts I and II. No dependencies.

Abstract

This paper establishes the intellectual foundation of aigile. It argues that waterfall’s defining property is not sequence but the freezing of outputs between phases; that agile’s essential innovation is the backward edge, the sanctioned channel through which learning flows against the direction of production; that prevailing spec-driven development reproduces the frozen-output shape in compressed time; and that agentic AI changes three economic conditions under which agile was derived, without touching the condition that made agile correct. Every protocol in the aigile framework is a formalized backward edge, and this paper is the justification all of them share.

1. Position in the framework

This is the diagnostic paper. It builds nothing; it establishes why everything else is built the way it is. Papers 02 through 08 each open with a reference to the specific backward edge they formalize.

2. The problem in full

2.1 What waterfall actually is

The standard account says waterfall failed because it was sequential. This account is wrong, and the error matters, because it licenses a false rebuttal: iterative development also sequences analysis, construction, and test inside each iteration, so if sequence were the sin, agile would share it. The objection that agile is merely repeated waterfall rests entirely on this misidentification.

Waterfall is defined by output freezing. In the canonical process, the requirements document, once approved, becomes an immutable input to design. The design, once approved, becomes an immutable input to construction. Each phase gate is a ratchet. Learning generated downstream, and construction generates enormous amounts of it, has no sanctioned path back upstream. The organization is structurally required to keep building on assumptions it has already discovered to be wrong, or to invoke a change-control process so heavy that discovery is quietly suppressed instead.

The result is well documented: feedback latency of months, errors compounding under the frozen layers, and a terminal integration phase in which all deferred learning arrives at once.

2.2 What Royce actually wrote

Winston Royce’s 1970 paper is cited as waterfall’s origin, and it is doubly misread. First, Royce introduced the sequential diagram as a process that is risky and invites failure, then spent the rest of the paper on mitigations, including iteration between adjacent phases and building the system twice. Second, and more relevant here, his central mitigation was documentation at extraordinary scale, on the order of fifteen hundred pages for a five million dollar project.

The character of that documentation is the key. It was evidentiary: written to prove that analysis preceded construction, to satisfy contract and audit. Nothing executed against it. Nobody’s daily work depended on its truthfulness. It was written once and read rarely. When the Agile Manifesto declared working software over comprehensive documentation, this artifact class was the target: documents whose production consumed the project and whose staleness cost nothing.

Hold that distinction. Paper 02 rests on it: a new artifact class now exists whose staleness costs everything, and the manifesto’s logic, correctly applied, puts that class on the working-software side of its own value line.

2.3 What agile actually is

Agile’s innovation is the backward edge: iteration N’s discoveries renegotiate iteration N+1’s scope and may invalidate standing plans. The sprint demo is a machine for generating backward-flowing information from stakeholders. The retrospective is a machine for applying backward-flowing information to the process itself. Short iterations are not valuable in themselves; they are valuable because they shorten the distance every backward edge must travel.

A team that iterates but forbids discoveries from altering the plan practices Scrumfall: waterfall at two-week scale. The shape, not the calendar, is decisive.

2.4 The SDD relapse

Prevailing spec-driven development encodes three correct observations (agents need explicit context; some knowledge is foundational; small well-described tasks improve output) inside a wrong shape: requirements generate a plan, the plan generates tasks, tasks generate code, forward only. Practitioner evaluations of the heavy pipeline report order-of-magnitude slowdowns against iterative prompting with no quality gain, unread markdown at volume, and ceremony without protection. Research on multi-agent pipelines adds a mechanism: waterfall-shaped agent workflows accumulate early-stage hallucinations downstream, because each stage treats the previous stage’s output as ground truth. The pipeline does not fail to catch errors. It launders them, adding confidence at every step.

The deeper error is the outsourcing bet: that understanding can be replaced by description, that a sufficiently clear document will be executed faithfully by whatever reads it. The bet failed when the reader was a contractor. Nothing about a language model changes the failure, because documents carry text and intent is reconstructed by readers, and reconstruction fidelity is precisely what feedback loops exist to check.

3. What changed and what did not

Agile was derived under four conditions: expensive code production, cheap conversation, co-located human memory, and the epistemic fact that correctness emerges from feedback. Agentic AI inverts the first (code is cheap), preserves the second, destroys the third (agents are stateless; every session starts near zero), and leaves the fourth untouched.

The consequences, developed fully in later papers:

• Cheap code moves the bottleneck to verification and validation (Paper 04, Paper 06). Rising production speed with stagnant checking produces the velocity paradox: more code, more instability, more debt.
• Statelessness makes some written artifact layer mandatory (Paper 02). Agile with no memory architecture is vibe coding: locally fluent, cumulatively incoherent. This is the legitimate problem SDD detects; aigile solves it without freezing outputs.
• Documentation read operationally by agents becomes load-bearing (Papers 02 and 03), reversing the maintenance economics that justified the manifesto’s suspicion of documents.
• The feedback principle survives unchanged and strengthens. When the loop from intent to running software compresses from weeks to minutes, the marginal cost of a feedback cycle collapses, and the rational response is more cycles, not bigger upfront artifacts. The one-sentence contrast with SDD follows: prevailing SDD tries to make the specification good enough that feedback becomes unnecessary; aigile makes feedback cheap enough that the specification can stay small.

4. Normative statement

This paper contributes one normative rule, inherited by every protocol in the series:

R1 (Backward-edge primacy). Every aigile process element must define the channel through which its downstream learning flows upstream, the artifact that learning becomes, and the authority that accepts it. A process element with no backward edge is presumed to be waterfall regardless of its iteration length, tooling, or vocabulary.

5. Orderly worked example

Orderly’s team initially adopts an off-the-shelf SDD pipeline. For the feature “consolidated invoicing,” an agent generates an eleven-page requirements document, a plan, and forty tasks. The team approves the documents after skimming. Two days of agent execution later, the demo reveals that consolidated invoices were grouped by shipping address, not by billing entity, a misreading introduced in the requirements generation and faithfully propagated through plan, tasks, and code, gathering internal consistency the whole way. Total loss: two days and forty tasks of rework.

Under R1, the same feature begins with a walking skeleton: one invoice, two orders, grouped, rendered, demoed within hours. The billing-entity misreading surfaces at the skeleton demo, costs one slice, and produces a spec-diff. The remaining slices inherit the correction. Nothing about the team’s diligence changed. The shape did.

6. Failure modes

• Scrumfall relapse: iterations exist, backward edges do not. Detection: count spec-diffs and plan changes per iteration; a flat zero over multiple iterations is not discipline, it is suppression.
• Ceremony inversion: backward edges exist on paper but their latency exceeds the forward pipeline’s, so participants route around them. Detection: measure edge latency (Paper 05 defines the metric family).
• Historical straw men: teams reject all written artifacts because documents equal waterfall. Paper 02 is the corrective.

7. Metrics

Feedback latency per edge type (demo verdict to spec-diff; deviation to decision; drift detection to resolution); spec-diff rate per iteration; rework fraction attributable to late discovery.

8. Open questions

Whether backward-edge latency has a measurable threshold beyond which suppression begins; how edge primacy interacts with regulated change-control regimes; empirical replication of error-laundering in current-generation agent pipelines.

9. Derivative artifacts

Executive slide narrative (the diagnosis story); website manifesto page; playbook introduction; assessment checklist for auditing existing SDD adoptions against R1.