The Architecture Nobody Decided: AI and the Slow Collapse of Async Code

A pipeline built one AI session at a time can run perfectly and still have no shape anyone can describe. Each added retry or guard clause looks sensible in isolation, but nobody ever decided how the whole system should behave, and six weeks later that gap becomes expensive.

The Details:

• Incremental generation optimizes for the last thing that broke, not for the system as a whole. A developer building async code solo over weeks has pauses between sessions to notice the mess forming. An AI assistant fills in the next step on request, so every change looks locally correct even as nested try/catch blocks and misplaced retries pile up without anyone calling a halt.

• Three symptoms reveal the drift before anyone names it. A stack trace that cannot point to which stage of the pipeline triggered the error means the boundaries have already blurred. A month of bug fixes that are all guard clauses means no single place in the code tracks actual state. And when someone says "just rerun it, it usually works the second time," retries have quietly replaced understanding.

• The fix is a five-minute pause before any code gets written: name the stages, the boundaries between them, and who owns failure at each one. That decision needs to live outside the code, in a short comment block or README, updated in the same commit as any change, so the next session starts from an intended design rather than from whatever shape the code happens to be in.

• AI assistants can expose the problem instead of hiding it. Dropped into a messy pipeline cold, without the accumulated context that makes a mess feel normal, an assistant may immediately question why one stage knows about another's retry count. Giving it one sentence of boundary context before asking for a fix changes what it optimizes for, at almost no cost.

Bottom Line: AI did not create sloppy async code. It just made it possible to accumulate sloppiness faster than anyone notices.