AI does not remove architectural decisions. It just defers them until two independently built components have to talk to each other, and nobody ever agreed on what language they'd use.
The cost of writing code has fallen far faster than the cost of understanding it, and that widening gap is where debt quietly builds.
The Details:
Old friction points, slow compiles, painful abstractions, tough code reviews, forced deliberation at exactly the moments that mattered. AI removes that friction but keeps the same underlying need for pauses at load-bearing decisions. Nothing stops you now, so nothing reminds you where to stop.
The classic failure mode: two features, each clean in isolation, need to share data later. One defines a user object one way, the other slightly differently; they're ninety percent compatible, which is worse than fully incompatible because the mismatch only shows up on rare edge cases in production. Error handling suffers the same fate when one piece throws exceptions, another returns null, and a third wraps failures in result objects.
The fix is not slowing everything down, it's restoring friction at two or three genuinely load-bearing points per session. A two-minute boundary conversation before building anything new, focused only on what a component receives, returns, owns, and does on failure, catches most of this. A one-paragraph shared vocabulary document defining terms like user, order, or failed state acts as a tuning fork across sessions.
Progress shows up in boring metrics: small changes staying small, code reviews arguing about logic instead of interfaces, and how much of last quarter's code you're still comfortable extending. Raw output speed is the wrong thing to track.
Bottom Line: Speed without deliberate pauses at system boundaries isn't free velocity. It's a loan against next quarter's stability.
Enjoy this article?
Listen to the Claude Code Conversations radio show or join the community.
