Stewart Brand has this framework called Pace Layers. The idea is that complex systems(like Civilization itself) operate at multiple speeds simultaneously. Fashion changes weekly, commerce yearly, infrastructure over decades. The fast parts experiment and absorb shocks, and the slow parts remember and stabilize.
Codebases work the same way. Some parts you can change ten times a day. Others you change once in months and think hard before you do. The stability at the bottom is what makes speed possible above it.
But what happens when we introduce AI agents?
They don’t see layers. They optimize for the immediate task. They refactor your core abstractions with the same energy they rename a variable, propose schema changes as casually as CSS tweaks. They bury decisions that should have been made deliberately in unrelated work. Architectural assumptions slip into a bug fix PR. Schema changes quietly lock you into the wrong data model. Optimizations couple components that were meant to stay independent.
A few months pass by and you end up fighting those decisions on every new feature. Each change seemed reasonable in isolation, but it compounded and created a mess.
This is going to be the primary failure mode. Not spaghetti code(that’s actually improved with newer models), but layer violations. Treating slow things as fast.
So, what do we do? To work effectively with agents, we must know ourselves the layer we’re operating in. And make the boundaries explicit, putting gates around the slow layers: RFCs, stricter reviews, compound engineering. Speed is great until you’re fast in the wrong place.