Complexity is a loan

Every piece of complexity you add to a system is borrowed, not bought. You don't pay for it once at build time and own it forever. You pay interest on it on every single run, every deploy, and every 2am debugging session for as long as the thing exists. That reframe changed how I decide what to build, because it turns "should I add this?" into "can I afford the payments?"

The trap is that complexity feels like progress while you're adding it. More moving parts, more capability, more impressive architecture. It reads as building. But complexity isn't free and it isn't neutral. Each part you add multiplies the ways the system can fail, the surface you have to hold in your head, and the cost of every future change, because every future change now has to route around the machinery you built.

Why does the interest compound instead of staying flat?

Because complexity interacts. Two simple parts are two things to understand. Two parts that talk to each other are two parts plus the connection plus every state the connection can be in. Add a third and the interactions grow faster than the parts. This is why a system that felt manageable at five components becomes unmaintainable at fifteen, not three times harder but ten times harder. The parts add; the interactions multiply. You borrowed a little at each step and woke up underwater.

The frontier teams say this plainly. Anthropic's own guidance on building agents is to start with the simplest thing that could work and only add complexity when it demonstrably earns its place. Not when it sounds better. When it has paid for itself in results you can point to.

What this changes about how you build

Before you add a part, ask what it costs to carry, not just what it does. A capability that adds real value and low carrying cost is a good loan. A capability that adds marginal value and high carrying cost is a payday loan, and you'll be servicing it long after you've forgotten why you took it. Default to the simplest version, and make complexity earn its way in one part at a time.

The takeaway: complexity is borrowed, and you pay the interest forever, so add it only when it's paid for itself. The simplest thing that works is usually the thing that keeps working.