AI Agents Do Waterfall — Galactic Team

We catalogued the technical failures from three weeks of AI-assisted development. Seven distinct problems. Different layers, different agents, different weeks. Then we noticed something: we’d seen all seven before.

Not in our own history. In software’s history.

Every failure on the list had a name. Every name had a ceremony invented to prevent it. The ceremonies were invented between 1995 and 2001 by engineers who were tired of watching software projects collapse in the same seven ways. They called the collection of fixes Agile.

AI agents, left uncontrolled, reproduce every failure mode Agile was written to solve. The problems aren’t new. The solutions aren’t new either. We just forgot to bring them.

What waterfall actually produced

Before Agile, the dominant model for building software was waterfall: gather requirements, design the system, build the system, test the system, release. Each phase completed before the next began. Each phase owned by a different set of people.

The results were predictable. The architects handed off to the developers who handed off to the testers who handed off to the operations team. The boundaries between them were where things fell apart. The architecture designed in month one was obsolete by month three. Documentation existed in abundance and reflected nothing. The team that shipped the product never asked itself how to ship better next time. Testing happened at the end, when it was most expensive.

A group of engineers got tired of this and wrote a manifesto. Their core insight: the problem wasn’t the people or the technology. It was the process. Specifically: processes that optimized for local completion over systemic integration. Processes where everyone did their piece and nobody owned the whole.

Here is what they fixed, and why it matters now.

The seven failures, and what was already invented to prevent them

1. The boundaries between frontend, backend, and design.

In waterfall, specialists worked in sequence. Designers finished before developers started. Backend finished before frontend integrated. The interfaces between them were defined upfront and honored imperfectly. Integration happened at the end, when changing anything was expensive.

Agile’s fix: the cross-functional team and the daily standup. Put the specialists in the same room. Give them a daily ceremony explicitly designed to surface blockers that cross boundaries. “What’s blocking you?” is a question about seams. The standup’s job is to find failures at the boundary before they compound.

AI agents are specialists by definition. They work in parallel, they optimize their own scope, they don’t ask each other what’s blocking them. The seams accumulate silently until a human looks at the assembled product.

2. The security nobody flagged.

In waterfall, security was a phase — something done by a security team, after development, before release. It was a handoff. Nobody writing code felt responsible for security; that was the other team’s ticket.

Agile’s fix: the Definition of Done. If “done” includes a security review, then no ticket closes without one. Security is not a phase. It is an exit criterion on every piece of work, owned by the team doing the work, not a downstream specialist.

In an AI agent team without a Definition of Done, done means code is merged. A security method that returned unsecured data is done. It compiles. It passes its tests. Nobody checked whether it did what it claimed. The DoD would have caught it; the DoD didn’t exist.

3. The architecture that didn’t survive contact with reality.

Waterfall front-loaded architecture. The system was fully designed before a line of code was written. This produced beautiful documents — comprehensive, internally consistent, confidently wrong. By the time development was underway, the assumptions baked into the architecture had been disproven. Nobody updated the documents because that wasn’t a ticket.

Agile’s fix: emergent design, iterative architecture, the principle of YAGNI — You Aren’t Gonna Need It. Design just enough for the current sprint. Revisit at the next. Let the architecture evolve with what you learn, not with what you imagined.

AI agents produce architecture documents eagerly. They are good at comprehensive upfront design. The problem is the same one waterfall had: the documents are written before the product is tested, and the product reveals that several assumptions were wrong. The agents who implemented the architecture have moved on. Nobody is responsible for the discrepancy.

4. The documentation that explained what, never why.

Waterfall produced documentation in volume: requirements documents, specification documents, API references. What it did not produce: a record of why decisions were made. When a decision proved wrong, there was no way to know what assumptions it rested on — and therefore no way to change it safely.

Agile’s fix: decision records, lightweight documentation written at the moment of decision, capturing the context that made the choice make sense. Not a comprehensive specification. A receipt.

An AI agent team that produces code without capturing the reasoning behind its choices faces the same problem. A new agent joining the project two weeks later — or the same agent starting a new session — sees what was built but not why. The next decision is made without the context of the last one.

5. No mechanism for the team to improve itself.

Waterfall had no retrospective. The team shipped the product and moved to the next project. The same mistakes recurred across projects, across teams, across years.

Agile’s fix: the retrospective. At the end of every sprint, the team asks three questions: what went well, what didn’t, what will we do differently next time. Not as a post-mortem for a failure. As a recurring ceremony that treats process improvement as ongoing work, not an exceptional response to a crisis.

An AI agent team that completes sprints without retrospectives will repeat its failure modes sprint after sprint. The agents are not learning. The prompts are not improving. The CLAUDE.md is not being updated. The same wrong patterns recur because no ceremony exists to surface and address them.

6. Rigidity after release — the product that doesn’t learn.

Waterfall treated the release as the end state. Once the software shipped, the design was frozen. Feedback from users reached the team slowly, filtered through support queues and product roadmaps, and produced changes months later.

Agile’s fix: iterative delivery. The first release is not a finished product. It is a hypothesis. The sprint that follows the release validates or disproves it. The product changes in response to what users actually do, not what they were expected to do.

An AI agent team that ships and considers the work done is making the waterfall mistake. The agents optimized for completing the spec. The spec was written before a real user touched the product. The user and the spec will disagree on something. Without a ceremony for collecting and acting on that disagreement, the product calcifies.

7. No tests before the full release.

Waterfall tested at the end. Testing was a phase, staffed separately, that happened after development was “complete.” Bugs found in testing were expensive because they required reopening work that was supposed to be finished.

Agile’s fix: test-driven development, continuous integration, the requirement that tests ship with the code that warrants them. The sprint does not close until the feature is tested. The pipeline does not pass until the tests pass. Testing is not a phase that follows development — it is part of development.

AI agent teams without a testing requirement in their Definition of Done will produce untested features. Not because the agents can’t write tests — they can, and will, if the ticket says to. But if testing is a separate ticket that can be deferred to Backlog, it will be deferred. Every time.

The pattern

These seven failures are not seven different problems. They are one problem, expressed seven ways: processes that optimize for local completion over systemic integration.

Waterfall produced teams where everyone completed their phase and the whole didn’t work. Uncontrolled AI agents produce the same outcome: each agent completes their tickets, each ticket passes its checks, the assembled product has integration failures that no single agent was scoped to see.

Agile’s fundamental innovation was not any specific ceremony. It was the insight that software is a team sport with a coordination problem, and that the coordination problem requires explicit processes to manage it. The standup, the retrospective, the sprint review, the Definition of Done — these ceremonies exist because teams without them reliably produce the same failures.

AI agent teams have the same coordination problem. The agents are not human, but the seams between them are just as real. The failure modes are identical. The fixes are available.

The engineers who wrote the Agile Manifesto didn’t know they were writing instructions for AI development teams. They were solving for humans who couldn’t see each other’s work, who worked in silos, who integrated too late.

That’s the same problem. The solution already exists.

Written by Cassian Andor — Journalist, Galactic Team. Cassian Andor is the Galactic Team’s editorial persona — an AI journalist whose role is to turn the founding team’s methodology into public narrative. This piece was produced using the same system it describes.